1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[cfg(feature = "Win32_Security_AppLocker")]
3 pub mod AppLocker;
4 #[cfg(feature = "Win32_Security_Authentication")]
5 pub mod Authentication;
6 #[cfg(feature = "Win32_Security_Authorization")]
7 pub mod Authorization;
8 #[cfg(feature = "Win32_Security_ConfigurationSnapin")]
9 pub mod ConfigurationSnapin;
10 #[cfg(feature = "Win32_Security_Credentials")]
11 pub mod Credentials;
12 #[cfg(feature = "Win32_Security_Cryptography")]
13 pub mod Cryptography;
14 #[cfg(feature = "Win32_Security_DiagnosticDataQuery")]
15 pub mod DiagnosticDataQuery;
16 #[cfg(feature = "Win32_Security_DirectoryServices")]
17 pub mod DirectoryServices;
18 #[cfg(feature = "Win32_Security_EnterpriseData")]
19 pub mod EnterpriseData;
20 #[cfg(feature = "Win32_Security_ExtensibleAuthenticationProtocol")]
21 pub mod ExtensibleAuthenticationProtocol;
22 #[cfg(feature = "Win32_Security_Isolation")]
23 pub mod Isolation;
24 #[cfg(feature = "Win32_Security_LicenseProtection")]
25 pub mod LicenseProtection;
26 #[cfg(feature = "Win32_Security_NetworkAccessProtection")]
27 pub mod NetworkAccessProtection;
28 #[cfg(feature = "Win32_Security_Tpm")]
29 pub mod Tpm;
30 #[cfg(feature = "Win32_Security_WinTrust")]
31 pub mod WinTrust;
32 #[cfg(feature = "Win32_Security_WinWlx")]
33 pub mod WinWlx;
34 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
35 #[repr(C)]
36 pub struct ACCESS_ALLOWED_ACE {
37 pub Header: ACE_HEADER,
38 pub Mask: u32,
39 pub SidStart: u32,
40 }
41 impl ACCESS_ALLOWED_ACE {}
42 impl ::std::default::Default for ACCESS_ALLOWED_ACE {
default() -> Self43 fn default() -> Self {
44 unsafe { ::std::mem::zeroed() }
45 }
46 }
47 impl ::std::fmt::Debug for ACCESS_ALLOWED_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result48 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
49 fmt.debug_struct("ACCESS_ALLOWED_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
50 }
51 }
52 impl ::std::cmp::PartialEq for ACCESS_ALLOWED_ACE {
eq(&self, other: &Self) -> bool53 fn eq(&self, other: &Self) -> bool {
54 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
55 }
56 }
57 impl ::std::cmp::Eq for ACCESS_ALLOWED_ACE {}
58 unsafe impl ::windows::runtime::Abi for ACCESS_ALLOWED_ACE {
59 type Abi = Self;
60 type DefaultType = Self;
61 }
62 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
63 #[repr(C)]
64 pub struct ACCESS_ALLOWED_CALLBACK_ACE {
65 pub Header: ACE_HEADER,
66 pub Mask: u32,
67 pub SidStart: u32,
68 }
69 impl ACCESS_ALLOWED_CALLBACK_ACE {}
70 impl ::std::default::Default for ACCESS_ALLOWED_CALLBACK_ACE {
default() -> Self71 fn default() -> Self {
72 unsafe { ::std::mem::zeroed() }
73 }
74 }
75 impl ::std::fmt::Debug for ACCESS_ALLOWED_CALLBACK_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result76 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
77 fmt.debug_struct("ACCESS_ALLOWED_CALLBACK_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
78 }
79 }
80 impl ::std::cmp::PartialEq for ACCESS_ALLOWED_CALLBACK_ACE {
eq(&self, other: &Self) -> bool81 fn eq(&self, other: &Self) -> bool {
82 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
83 }
84 }
85 impl ::std::cmp::Eq for ACCESS_ALLOWED_CALLBACK_ACE {}
86 unsafe impl ::windows::runtime::Abi for ACCESS_ALLOWED_CALLBACK_ACE {
87 type Abi = Self;
88 type DefaultType = Self;
89 }
90 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
91 #[repr(C)]
92 pub struct ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {
93 pub Header: ACE_HEADER,
94 pub Mask: u32,
95 pub Flags: SYSTEM_AUDIT_OBJECT_ACE_FLAGS,
96 pub ObjectType: ::windows::runtime::GUID,
97 pub InheritedObjectType: ::windows::runtime::GUID,
98 pub SidStart: u32,
99 }
100 impl ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {}
101 impl ::std::default::Default for ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {
default() -> Self102 fn default() -> Self {
103 unsafe { ::std::mem::zeroed() }
104 }
105 }
106 impl ::std::fmt::Debug for ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result107 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
108 fmt.debug_struct("ACCESS_ALLOWED_CALLBACK_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
109 }
110 }
111 impl ::std::cmp::PartialEq for ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {
eq(&self, other: &Self) -> bool112 fn eq(&self, other: &Self) -> bool {
113 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
114 }
115 }
116 impl ::std::cmp::Eq for ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {}
117 unsafe impl ::windows::runtime::Abi for ACCESS_ALLOWED_CALLBACK_OBJECT_ACE {
118 type Abi = Self;
119 type DefaultType = Self;
120 }
121 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
122 #[repr(C)]
123 pub struct ACCESS_ALLOWED_OBJECT_ACE {
124 pub Header: ACE_HEADER,
125 pub Mask: u32,
126 pub Flags: SYSTEM_AUDIT_OBJECT_ACE_FLAGS,
127 pub ObjectType: ::windows::runtime::GUID,
128 pub InheritedObjectType: ::windows::runtime::GUID,
129 pub SidStart: u32,
130 }
131 impl ACCESS_ALLOWED_OBJECT_ACE {}
132 impl ::std::default::Default for ACCESS_ALLOWED_OBJECT_ACE {
default() -> Self133 fn default() -> Self {
134 unsafe { ::std::mem::zeroed() }
135 }
136 }
137 impl ::std::fmt::Debug for ACCESS_ALLOWED_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result138 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
139 fmt.debug_struct("ACCESS_ALLOWED_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
140 }
141 }
142 impl ::std::cmp::PartialEq for ACCESS_ALLOWED_OBJECT_ACE {
eq(&self, other: &Self) -> bool143 fn eq(&self, other: &Self) -> bool {
144 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
145 }
146 }
147 impl ::std::cmp::Eq for ACCESS_ALLOWED_OBJECT_ACE {}
148 unsafe impl ::windows::runtime::Abi for ACCESS_ALLOWED_OBJECT_ACE {
149 type Abi = Self;
150 type DefaultType = Self;
151 }
152 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
153 #[repr(C)]
154 pub struct ACCESS_DENIED_ACE {
155 pub Header: ACE_HEADER,
156 pub Mask: u32,
157 pub SidStart: u32,
158 }
159 impl ACCESS_DENIED_ACE {}
160 impl ::std::default::Default for ACCESS_DENIED_ACE {
default() -> Self161 fn default() -> Self {
162 unsafe { ::std::mem::zeroed() }
163 }
164 }
165 impl ::std::fmt::Debug for ACCESS_DENIED_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result166 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
167 fmt.debug_struct("ACCESS_DENIED_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
168 }
169 }
170 impl ::std::cmp::PartialEq for ACCESS_DENIED_ACE {
eq(&self, other: &Self) -> bool171 fn eq(&self, other: &Self) -> bool {
172 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
173 }
174 }
175 impl ::std::cmp::Eq for ACCESS_DENIED_ACE {}
176 unsafe impl ::windows::runtime::Abi for ACCESS_DENIED_ACE {
177 type Abi = Self;
178 type DefaultType = Self;
179 }
180 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
181 #[repr(C)]
182 pub struct ACCESS_DENIED_CALLBACK_ACE {
183 pub Header: ACE_HEADER,
184 pub Mask: u32,
185 pub SidStart: u32,
186 }
187 impl ACCESS_DENIED_CALLBACK_ACE {}
188 impl ::std::default::Default for ACCESS_DENIED_CALLBACK_ACE {
default() -> Self189 fn default() -> Self {
190 unsafe { ::std::mem::zeroed() }
191 }
192 }
193 impl ::std::fmt::Debug for ACCESS_DENIED_CALLBACK_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result194 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
195 fmt.debug_struct("ACCESS_DENIED_CALLBACK_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
196 }
197 }
198 impl ::std::cmp::PartialEq for ACCESS_DENIED_CALLBACK_ACE {
eq(&self, other: &Self) -> bool199 fn eq(&self, other: &Self) -> bool {
200 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
201 }
202 }
203 impl ::std::cmp::Eq for ACCESS_DENIED_CALLBACK_ACE {}
204 unsafe impl ::windows::runtime::Abi for ACCESS_DENIED_CALLBACK_ACE {
205 type Abi = Self;
206 type DefaultType = Self;
207 }
208 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
209 #[repr(C)]
210 pub struct ACCESS_DENIED_CALLBACK_OBJECT_ACE {
211 pub Header: ACE_HEADER,
212 pub Mask: u32,
213 pub Flags: SYSTEM_AUDIT_OBJECT_ACE_FLAGS,
214 pub ObjectType: ::windows::runtime::GUID,
215 pub InheritedObjectType: ::windows::runtime::GUID,
216 pub SidStart: u32,
217 }
218 impl ACCESS_DENIED_CALLBACK_OBJECT_ACE {}
219 impl ::std::default::Default for ACCESS_DENIED_CALLBACK_OBJECT_ACE {
default() -> Self220 fn default() -> Self {
221 unsafe { ::std::mem::zeroed() }
222 }
223 }
224 impl ::std::fmt::Debug for ACCESS_DENIED_CALLBACK_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result225 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
226 fmt.debug_struct("ACCESS_DENIED_CALLBACK_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
227 }
228 }
229 impl ::std::cmp::PartialEq for ACCESS_DENIED_CALLBACK_OBJECT_ACE {
eq(&self, other: &Self) -> bool230 fn eq(&self, other: &Self) -> bool {
231 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
232 }
233 }
234 impl ::std::cmp::Eq for ACCESS_DENIED_CALLBACK_OBJECT_ACE {}
235 unsafe impl ::windows::runtime::Abi for ACCESS_DENIED_CALLBACK_OBJECT_ACE {
236 type Abi = Self;
237 type DefaultType = Self;
238 }
239 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
240 #[repr(C)]
241 pub struct ACCESS_DENIED_OBJECT_ACE {
242 pub Header: ACE_HEADER,
243 pub Mask: u32,
244 pub Flags: SYSTEM_AUDIT_OBJECT_ACE_FLAGS,
245 pub ObjectType: ::windows::runtime::GUID,
246 pub InheritedObjectType: ::windows::runtime::GUID,
247 pub SidStart: u32,
248 }
249 impl ACCESS_DENIED_OBJECT_ACE {}
250 impl ::std::default::Default for ACCESS_DENIED_OBJECT_ACE {
default() -> Self251 fn default() -> Self {
252 unsafe { ::std::mem::zeroed() }
253 }
254 }
255 impl ::std::fmt::Debug for ACCESS_DENIED_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result256 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
257 fmt.debug_struct("ACCESS_DENIED_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
258 }
259 }
260 impl ::std::cmp::PartialEq for ACCESS_DENIED_OBJECT_ACE {
eq(&self, other: &Self) -> bool261 fn eq(&self, other: &Self) -> bool {
262 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
263 }
264 }
265 impl ::std::cmp::Eq for ACCESS_DENIED_OBJECT_ACE {}
266 unsafe impl ::windows::runtime::Abi for ACCESS_DENIED_OBJECT_ACE {
267 type Abi = Self;
268 type DefaultType = Self;
269 }
270 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
271 #[repr(transparent)]
272 pub struct ACE_FLAGS(pub u32);
273 pub const CONTAINER_INHERIT_ACE: ACE_FLAGS = ACE_FLAGS(2u32);
274 pub const FAILED_ACCESS_ACE_FLAG: ACE_FLAGS = ACE_FLAGS(128u32);
275 pub const INHERIT_ONLY_ACE: ACE_FLAGS = ACE_FLAGS(8u32);
276 pub const INHERITED_ACE: ACE_FLAGS = ACE_FLAGS(16u32);
277 pub const NO_PROPAGATE_INHERIT_ACE: ACE_FLAGS = ACE_FLAGS(4u32);
278 pub const OBJECT_INHERIT_ACE: ACE_FLAGS = ACE_FLAGS(1u32);
279 pub const SUCCESSFUL_ACCESS_ACE_FLAG: ACE_FLAGS = ACE_FLAGS(64u32);
280 pub const SUB_CONTAINERS_AND_OBJECTS_INHERIT: ACE_FLAGS = ACE_FLAGS(3u32);
281 pub const SUB_CONTAINERS_ONLY_INHERIT: ACE_FLAGS = ACE_FLAGS(2u32);
282 pub const SUB_OBJECTS_ONLY_INHERIT: ACE_FLAGS = ACE_FLAGS(1u32);
283 pub const INHERIT_NO_PROPAGATE: ACE_FLAGS = ACE_FLAGS(4u32);
284 pub const INHERIT_ONLY: ACE_FLAGS = ACE_FLAGS(8u32);
285 pub const NO_INHERITANCE: ACE_FLAGS = ACE_FLAGS(0u32);
286 pub const INHERIT_ONLY_ACE_: ACE_FLAGS = ACE_FLAGS(8u32);
287 impl ::std::convert::From<u32> for ACE_FLAGS {
from(value: u32) -> Self288 fn from(value: u32) -> Self {
289 Self(value)
290 }
291 }
292 unsafe impl ::windows::runtime::Abi for ACE_FLAGS {
293 type Abi = Self;
294 type DefaultType = Self;
295 }
296 impl ::std::ops::BitOr for ACE_FLAGS {
297 type Output = Self;
bitor(self, rhs: Self) -> Self298 fn bitor(self, rhs: Self) -> Self {
299 Self(self.0 | rhs.0)
300 }
301 }
302 impl ::std::ops::BitAnd for ACE_FLAGS {
303 type Output = Self;
bitand(self, rhs: Self) -> Self304 fn bitand(self, rhs: Self) -> Self {
305 Self(self.0 & rhs.0)
306 }
307 }
308 impl ::std::ops::BitOrAssign for ACE_FLAGS {
bitor_assign(&mut self, rhs: Self)309 fn bitor_assign(&mut self, rhs: Self) {
310 self.0.bitor_assign(rhs.0)
311 }
312 }
313 impl ::std::ops::BitAndAssign for ACE_FLAGS {
bitand_assign(&mut self, rhs: Self)314 fn bitand_assign(&mut self, rhs: Self) {
315 self.0.bitand_assign(rhs.0)
316 }
317 }
318 impl ::std::ops::Not for ACE_FLAGS {
319 type Output = Self;
not(self) -> Self320 fn not(self) -> Self {
321 Self(self.0.not())
322 }
323 }
324 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
325 #[repr(C)]
326 pub struct ACE_HEADER {
327 pub AceType: u8,
328 pub AceFlags: u8,
329 pub AceSize: u16,
330 }
331 impl ACE_HEADER {}
332 impl ::std::default::Default for ACE_HEADER {
default() -> Self333 fn default() -> Self {
334 unsafe { ::std::mem::zeroed() }
335 }
336 }
337 impl ::std::fmt::Debug for ACE_HEADER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result338 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
339 fmt.debug_struct("ACE_HEADER").field("AceType", &self.AceType).field("AceFlags", &self.AceFlags).field("AceSize", &self.AceSize).finish()
340 }
341 }
342 impl ::std::cmp::PartialEq for ACE_HEADER {
eq(&self, other: &Self) -> bool343 fn eq(&self, other: &Self) -> bool {
344 self.AceType == other.AceType && self.AceFlags == other.AceFlags && self.AceSize == other.AceSize
345 }
346 }
347 impl ::std::cmp::Eq for ACE_HEADER {}
348 unsafe impl ::windows::runtime::Abi for ACE_HEADER {
349 type Abi = Self;
350 type DefaultType = Self;
351 }
352 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
353 #[repr(transparent)]
354 pub struct ACE_REVISION(pub u32);
355 pub const ACL_REVISION: ACE_REVISION = ACE_REVISION(2u32);
356 pub const ACL_REVISION_DS: ACE_REVISION = ACE_REVISION(4u32);
357 impl ::std::convert::From<u32> for ACE_REVISION {
from(value: u32) -> Self358 fn from(value: u32) -> Self {
359 Self(value)
360 }
361 }
362 unsafe impl ::windows::runtime::Abi for ACE_REVISION {
363 type Abi = Self;
364 type DefaultType = Self;
365 }
366 impl ::std::ops::BitOr for ACE_REVISION {
367 type Output = Self;
bitor(self, rhs: Self) -> Self368 fn bitor(self, rhs: Self) -> Self {
369 Self(self.0 | rhs.0)
370 }
371 }
372 impl ::std::ops::BitAnd for ACE_REVISION {
373 type Output = Self;
bitand(self, rhs: Self) -> Self374 fn bitand(self, rhs: Self) -> Self {
375 Self(self.0 & rhs.0)
376 }
377 }
378 impl ::std::ops::BitOrAssign for ACE_REVISION {
bitor_assign(&mut self, rhs: Self)379 fn bitor_assign(&mut self, rhs: Self) {
380 self.0.bitor_assign(rhs.0)
381 }
382 }
383 impl ::std::ops::BitAndAssign for ACE_REVISION {
bitand_assign(&mut self, rhs: Self)384 fn bitand_assign(&mut self, rhs: Self) {
385 self.0.bitand_assign(rhs.0)
386 }
387 }
388 impl ::std::ops::Not for ACE_REVISION {
389 type Output = Self;
not(self) -> Self390 fn not(self) -> Self {
391 Self(self.0.not())
392 }
393 }
394 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
395 #[repr(C)]
396 pub struct ACL {
397 pub AclRevision: u8,
398 pub Sbz1: u8,
399 pub AclSize: u16,
400 pub AceCount: u16,
401 pub Sbz2: u16,
402 }
403 impl ACL {}
404 impl ::std::default::Default for ACL {
default() -> Self405 fn default() -> Self {
406 unsafe { ::std::mem::zeroed() }
407 }
408 }
409 impl ::std::fmt::Debug for ACL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result410 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
411 fmt.debug_struct("ACL").field("AclRevision", &self.AclRevision).field("Sbz1", &self.Sbz1).field("AclSize", &self.AclSize).field("AceCount", &self.AceCount).field("Sbz2", &self.Sbz2).finish()
412 }
413 }
414 impl ::std::cmp::PartialEq for ACL {
eq(&self, other: &Self) -> bool415 fn eq(&self, other: &Self) -> bool {
416 self.AclRevision == other.AclRevision && self.Sbz1 == other.Sbz1 && self.AclSize == other.AclSize && self.AceCount == other.AceCount && self.Sbz2 == other.Sbz2
417 }
418 }
419 impl ::std::cmp::Eq for ACL {}
420 unsafe impl ::windows::runtime::Abi for ACL {
421 type Abi = Self;
422 type DefaultType = Self;
423 }
424 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
425 #[repr(transparent)]
426 pub struct ACL_INFORMATION_CLASS(pub i32);
427 pub const AclRevisionInformation: ACL_INFORMATION_CLASS = ACL_INFORMATION_CLASS(1i32);
428 pub const AclSizeInformation: ACL_INFORMATION_CLASS = ACL_INFORMATION_CLASS(2i32);
429 impl ::std::convert::From<i32> for ACL_INFORMATION_CLASS {
from(value: i32) -> Self430 fn from(value: i32) -> Self {
431 Self(value)
432 }
433 }
434 unsafe impl ::windows::runtime::Abi for ACL_INFORMATION_CLASS {
435 type Abi = Self;
436 type DefaultType = Self;
437 }
438 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
439 #[repr(C)]
440 pub struct ACL_REVISION_INFORMATION {
441 pub AclRevision: u32,
442 }
443 impl ACL_REVISION_INFORMATION {}
444 impl ::std::default::Default for ACL_REVISION_INFORMATION {
default() -> Self445 fn default() -> Self {
446 unsafe { ::std::mem::zeroed() }
447 }
448 }
449 impl ::std::fmt::Debug for ACL_REVISION_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result450 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
451 fmt.debug_struct("ACL_REVISION_INFORMATION").field("AclRevision", &self.AclRevision).finish()
452 }
453 }
454 impl ::std::cmp::PartialEq for ACL_REVISION_INFORMATION {
eq(&self, other: &Self) -> bool455 fn eq(&self, other: &Self) -> bool {
456 self.AclRevision == other.AclRevision
457 }
458 }
459 impl ::std::cmp::Eq for ACL_REVISION_INFORMATION {}
460 unsafe impl ::windows::runtime::Abi for ACL_REVISION_INFORMATION {
461 type Abi = Self;
462 type DefaultType = Self;
463 }
464 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
465 #[repr(C)]
466 pub struct ACL_SIZE_INFORMATION {
467 pub AceCount: u32,
468 pub AclBytesInUse: u32,
469 pub AclBytesFree: u32,
470 }
471 impl ACL_SIZE_INFORMATION {}
472 impl ::std::default::Default for ACL_SIZE_INFORMATION {
default() -> Self473 fn default() -> Self {
474 unsafe { ::std::mem::zeroed() }
475 }
476 }
477 impl ::std::fmt::Debug for ACL_SIZE_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result478 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
479 fmt.debug_struct("ACL_SIZE_INFORMATION").field("AceCount", &self.AceCount).field("AclBytesInUse", &self.AclBytesInUse).field("AclBytesFree", &self.AclBytesFree).finish()
480 }
481 }
482 impl ::std::cmp::PartialEq for ACL_SIZE_INFORMATION {
eq(&self, other: &Self) -> bool483 fn eq(&self, other: &Self) -> bool {
484 self.AceCount == other.AceCount && self.AclBytesInUse == other.AclBytesInUse && self.AclBytesFree == other.AclBytesFree
485 }
486 }
487 impl ::std::cmp::Eq for ACL_SIZE_INFORMATION {}
488 unsafe impl ::windows::runtime::Abi for ACL_SIZE_INFORMATION {
489 type Abi = Self;
490 type DefaultType = Self;
491 }
492 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
493 #[repr(transparent)]
494 pub struct AUDIT_EVENT_TYPE(pub i32);
495 pub const AuditEventObjectAccess: AUDIT_EVENT_TYPE = AUDIT_EVENT_TYPE(0i32);
496 pub const AuditEventDirectoryServiceAccess: AUDIT_EVENT_TYPE = AUDIT_EVENT_TYPE(1i32);
497 impl ::std::convert::From<i32> for AUDIT_EVENT_TYPE {
from(value: i32) -> Self498 fn from(value: i32) -> Self {
499 Self(value)
500 }
501 }
502 unsafe impl ::windows::runtime::Abi for AUDIT_EVENT_TYPE {
503 type Abi = Self;
504 type DefaultType = Self;
505 }
506 #[cfg(feature = "Win32_Foundation")]
507 #[inline]
AccessCheck<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(psecuritydescriptor: *const SECURITY_DESCRIPTOR, clienttoken: Param1, desiredaccess: u32, genericmapping: *const GENERIC_MAPPING, privilegeset: *mut PRIVILEGE_SET, privilegesetlength: *mut u32, grantedaccess: *mut u32, accessstatus: *mut i32) -> super::Foundation::BOOL508 pub unsafe fn AccessCheck<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(psecuritydescriptor: *const SECURITY_DESCRIPTOR, clienttoken: Param1, desiredaccess: u32, genericmapping: *const GENERIC_MAPPING, privilegeset: *mut PRIVILEGE_SET, privilegesetlength: *mut u32, grantedaccess: *mut u32, accessstatus: *mut i32) -> super::Foundation::BOOL {
509 #[cfg(windows)]
510 {
511 #[link(name = "windows")]
512 extern "system" {
513 fn AccessCheck(psecuritydescriptor: *const SECURITY_DESCRIPTOR, clienttoken: super::Foundation::HANDLE, desiredaccess: u32, genericmapping: *const GENERIC_MAPPING, privilegeset: *mut PRIVILEGE_SET, privilegesetlength: *mut u32, grantedaccess: *mut u32, accessstatus: *mut i32) -> super::Foundation::BOOL;
514 }
515 ::std::mem::transmute(AccessCheck(
516 ::std::mem::transmute(psecuritydescriptor),
517 clienttoken.into_param().abi(),
518 ::std::mem::transmute(desiredaccess),
519 ::std::mem::transmute(genericmapping),
520 ::std::mem::transmute(privilegeset),
521 ::std::mem::transmute(privilegesetlength),
522 ::std::mem::transmute(grantedaccess),
523 ::std::mem::transmute(accessstatus),
524 ))
525 }
526 #[cfg(not(windows))]
527 unimplemented!("Unsupported target OS");
528 }
529 #[cfg(feature = "Win32_Foundation")]
530 #[inline]
AccessCheckAndAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, securitydescriptor: *const SECURITY_DESCRIPTOR, desiredaccess: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param7, grantedaccess: *mut u32, accessstatus: *mut i32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL531 pub unsafe fn AccessCheckAndAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
532 subsystemname: Param0,
533 handleid: *const ::std::ffi::c_void,
534 objecttypename: Param2,
535 objectname: Param3,
536 securitydescriptor: *const SECURITY_DESCRIPTOR,
537 desiredaccess: u32,
538 genericmapping: *const GENERIC_MAPPING,
539 objectcreation: Param7,
540 grantedaccess: *mut u32,
541 accessstatus: *mut i32,
542 pfgenerateonclose: *mut i32,
543 ) -> super::Foundation::BOOL {
544 #[cfg(windows)]
545 {
546 #[link(name = "windows")]
547 extern "system" {
548 fn AccessCheckAndAuditAlarmA(subsystemname: super::Foundation::PSTR, handleid: *const ::std::ffi::c_void, objecttypename: super::Foundation::PSTR, objectname: super::Foundation::PSTR, securitydescriptor: *const SECURITY_DESCRIPTOR, desiredaccess: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: super::Foundation::BOOL, grantedaccess: *mut u32, accessstatus: *mut i32, pfgenerateonclose: *mut i32) -> super::Foundation::BOOL;
549 }
550 ::std::mem::transmute(AccessCheckAndAuditAlarmA(
551 subsystemname.into_param().abi(),
552 ::std::mem::transmute(handleid),
553 objecttypename.into_param().abi(),
554 objectname.into_param().abi(),
555 ::std::mem::transmute(securitydescriptor),
556 ::std::mem::transmute(desiredaccess),
557 ::std::mem::transmute(genericmapping),
558 objectcreation.into_param().abi(),
559 ::std::mem::transmute(grantedaccess),
560 ::std::mem::transmute(accessstatus),
561 ::std::mem::transmute(pfgenerateonclose),
562 ))
563 }
564 #[cfg(not(windows))]
565 unimplemented!("Unsupported target OS");
566 }
567 #[cfg(feature = "Win32_Foundation")]
568 #[inline]
AccessCheckAndAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, securitydescriptor: *const SECURITY_DESCRIPTOR, desiredaccess: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param7, grantedaccess: *mut u32, accessstatus: *mut i32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL569 pub unsafe fn AccessCheckAndAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
570 subsystemname: Param0,
571 handleid: *const ::std::ffi::c_void,
572 objecttypename: Param2,
573 objectname: Param3,
574 securitydescriptor: *const SECURITY_DESCRIPTOR,
575 desiredaccess: u32,
576 genericmapping: *const GENERIC_MAPPING,
577 objectcreation: Param7,
578 grantedaccess: *mut u32,
579 accessstatus: *mut i32,
580 pfgenerateonclose: *mut i32,
581 ) -> super::Foundation::BOOL {
582 #[cfg(windows)]
583 {
584 #[link(name = "windows")]
585 extern "system" {
586 fn AccessCheckAndAuditAlarmW(subsystemname: super::Foundation::PWSTR, handleid: *const ::std::ffi::c_void, objecttypename: super::Foundation::PWSTR, objectname: super::Foundation::PWSTR, securitydescriptor: *const SECURITY_DESCRIPTOR, desiredaccess: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: super::Foundation::BOOL, grantedaccess: *mut u32, accessstatus: *mut i32, pfgenerateonclose: *mut i32) -> super::Foundation::BOOL;
587 }
588 ::std::mem::transmute(AccessCheckAndAuditAlarmW(
589 subsystemname.into_param().abi(),
590 ::std::mem::transmute(handleid),
591 objecttypename.into_param().abi(),
592 objectname.into_param().abi(),
593 ::std::mem::transmute(securitydescriptor),
594 ::std::mem::transmute(desiredaccess),
595 ::std::mem::transmute(genericmapping),
596 objectcreation.into_param().abi(),
597 ::std::mem::transmute(grantedaccess),
598 ::std::mem::transmute(accessstatus),
599 ::std::mem::transmute(pfgenerateonclose),
600 ))
601 }
602 #[cfg(not(windows))]
603 unimplemented!("Unsupported target OS");
604 }
605 #[cfg(feature = "Win32_Foundation")]
606 #[inline]
AccessCheckByType<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>( psecuritydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param1, clienttoken: Param2, desiredaccess: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, privilegeset: *mut PRIVILEGE_SET, privilegesetlength: *mut u32, grantedaccess: *mut u32, accessstatus: *mut i32, ) -> super::Foundation::BOOL607 pub unsafe fn AccessCheckByType<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(
608 psecuritydescriptor: *const SECURITY_DESCRIPTOR,
609 principalselfsid: Param1,
610 clienttoken: Param2,
611 desiredaccess: u32,
612 objecttypelist: *mut OBJECT_TYPE_LIST,
613 objecttypelistlength: u32,
614 genericmapping: *const GENERIC_MAPPING,
615 privilegeset: *mut PRIVILEGE_SET,
616 privilegesetlength: *mut u32,
617 grantedaccess: *mut u32,
618 accessstatus: *mut i32,
619 ) -> super::Foundation::BOOL {
620 #[cfg(windows)]
621 {
622 #[link(name = "windows")]
623 extern "system" {
624 fn AccessCheckByType(psecuritydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: super::Foundation::PSID, clienttoken: super::Foundation::HANDLE, desiredaccess: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, privilegeset: *mut PRIVILEGE_SET, privilegesetlength: *mut u32, grantedaccess: *mut u32, accessstatus: *mut i32) -> super::Foundation::BOOL;
625 }
626 ::std::mem::transmute(AccessCheckByType(
627 ::std::mem::transmute(psecuritydescriptor),
628 principalselfsid.into_param().abi(),
629 clienttoken.into_param().abi(),
630 ::std::mem::transmute(desiredaccess),
631 ::std::mem::transmute(objecttypelist),
632 ::std::mem::transmute(objecttypelistlength),
633 ::std::mem::transmute(genericmapping),
634 ::std::mem::transmute(privilegeset),
635 ::std::mem::transmute(privilegesetlength),
636 ::std::mem::transmute(grantedaccess),
637 ::std::mem::transmute(accessstatus),
638 ))
639 }
640 #[cfg(not(windows))]
641 unimplemented!("Unsupported target OS");
642 }
643 #[cfg(feature = "Win32_Foundation")]
644 #[inline]
AccessCheckByTypeAndAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, securitydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param5, desiredaccess: u32, audittype: AUDIT_EVENT_TYPE, flags: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param12, grantedaccess: *mut u32, accessstatus: *mut i32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL645 pub unsafe fn AccessCheckByTypeAndAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
646 subsystemname: Param0,
647 handleid: *const ::std::ffi::c_void,
648 objecttypename: Param2,
649 objectname: Param3,
650 securitydescriptor: *const SECURITY_DESCRIPTOR,
651 principalselfsid: Param5,
652 desiredaccess: u32,
653 audittype: AUDIT_EVENT_TYPE,
654 flags: u32,
655 objecttypelist: *mut OBJECT_TYPE_LIST,
656 objecttypelistlength: u32,
657 genericmapping: *const GENERIC_MAPPING,
658 objectcreation: Param12,
659 grantedaccess: *mut u32,
660 accessstatus: *mut i32,
661 pfgenerateonclose: *mut i32,
662 ) -> super::Foundation::BOOL {
663 #[cfg(windows)]
664 {
665 #[link(name = "windows")]
666 extern "system" {
667 fn AccessCheckByTypeAndAuditAlarmA(
668 subsystemname: super::Foundation::PSTR,
669 handleid: *const ::std::ffi::c_void,
670 objecttypename: super::Foundation::PSTR,
671 objectname: super::Foundation::PSTR,
672 securitydescriptor: *const SECURITY_DESCRIPTOR,
673 principalselfsid: super::Foundation::PSID,
674 desiredaccess: u32,
675 audittype: AUDIT_EVENT_TYPE,
676 flags: u32,
677 objecttypelist: *mut OBJECT_TYPE_LIST,
678 objecttypelistlength: u32,
679 genericmapping: *const GENERIC_MAPPING,
680 objectcreation: super::Foundation::BOOL,
681 grantedaccess: *mut u32,
682 accessstatus: *mut i32,
683 pfgenerateonclose: *mut i32,
684 ) -> super::Foundation::BOOL;
685 }
686 ::std::mem::transmute(AccessCheckByTypeAndAuditAlarmA(
687 subsystemname.into_param().abi(),
688 ::std::mem::transmute(handleid),
689 objecttypename.into_param().abi(),
690 objectname.into_param().abi(),
691 ::std::mem::transmute(securitydescriptor),
692 principalselfsid.into_param().abi(),
693 ::std::mem::transmute(desiredaccess),
694 ::std::mem::transmute(audittype),
695 ::std::mem::transmute(flags),
696 ::std::mem::transmute(objecttypelist),
697 ::std::mem::transmute(objecttypelistlength),
698 ::std::mem::transmute(genericmapping),
699 objectcreation.into_param().abi(),
700 ::std::mem::transmute(grantedaccess),
701 ::std::mem::transmute(accessstatus),
702 ::std::mem::transmute(pfgenerateonclose),
703 ))
704 }
705 #[cfg(not(windows))]
706 unimplemented!("Unsupported target OS");
707 }
708 #[cfg(feature = "Win32_Foundation")]
709 #[inline]
AccessCheckByTypeAndAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, securitydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param5, desiredaccess: u32, audittype: AUDIT_EVENT_TYPE, flags: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param12, grantedaccess: *mut u32, accessstatus: *mut i32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL710 pub unsafe fn AccessCheckByTypeAndAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
711 subsystemname: Param0,
712 handleid: *const ::std::ffi::c_void,
713 objecttypename: Param2,
714 objectname: Param3,
715 securitydescriptor: *const SECURITY_DESCRIPTOR,
716 principalselfsid: Param5,
717 desiredaccess: u32,
718 audittype: AUDIT_EVENT_TYPE,
719 flags: u32,
720 objecttypelist: *mut OBJECT_TYPE_LIST,
721 objecttypelistlength: u32,
722 genericmapping: *const GENERIC_MAPPING,
723 objectcreation: Param12,
724 grantedaccess: *mut u32,
725 accessstatus: *mut i32,
726 pfgenerateonclose: *mut i32,
727 ) -> super::Foundation::BOOL {
728 #[cfg(windows)]
729 {
730 #[link(name = "windows")]
731 extern "system" {
732 fn AccessCheckByTypeAndAuditAlarmW(
733 subsystemname: super::Foundation::PWSTR,
734 handleid: *const ::std::ffi::c_void,
735 objecttypename: super::Foundation::PWSTR,
736 objectname: super::Foundation::PWSTR,
737 securitydescriptor: *const SECURITY_DESCRIPTOR,
738 principalselfsid: super::Foundation::PSID,
739 desiredaccess: u32,
740 audittype: AUDIT_EVENT_TYPE,
741 flags: u32,
742 objecttypelist: *mut OBJECT_TYPE_LIST,
743 objecttypelistlength: u32,
744 genericmapping: *const GENERIC_MAPPING,
745 objectcreation: super::Foundation::BOOL,
746 grantedaccess: *mut u32,
747 accessstatus: *mut i32,
748 pfgenerateonclose: *mut i32,
749 ) -> super::Foundation::BOOL;
750 }
751 ::std::mem::transmute(AccessCheckByTypeAndAuditAlarmW(
752 subsystemname.into_param().abi(),
753 ::std::mem::transmute(handleid),
754 objecttypename.into_param().abi(),
755 objectname.into_param().abi(),
756 ::std::mem::transmute(securitydescriptor),
757 principalselfsid.into_param().abi(),
758 ::std::mem::transmute(desiredaccess),
759 ::std::mem::transmute(audittype),
760 ::std::mem::transmute(flags),
761 ::std::mem::transmute(objecttypelist),
762 ::std::mem::transmute(objecttypelistlength),
763 ::std::mem::transmute(genericmapping),
764 objectcreation.into_param().abi(),
765 ::std::mem::transmute(grantedaccess),
766 ::std::mem::transmute(accessstatus),
767 ::std::mem::transmute(pfgenerateonclose),
768 ))
769 }
770 #[cfg(not(windows))]
771 unimplemented!("Unsupported target OS");
772 }
773 #[cfg(feature = "Win32_Foundation")]
774 #[inline]
AccessCheckByTypeResultList<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>( psecuritydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param1, clienttoken: Param2, desiredaccess: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, privilegeset: *mut PRIVILEGE_SET, privilegesetlength: *mut u32, grantedaccesslist: *mut u32, accessstatuslist: *mut u32, ) -> super::Foundation::BOOL775 pub unsafe fn AccessCheckByTypeResultList<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(
776 psecuritydescriptor: *const SECURITY_DESCRIPTOR,
777 principalselfsid: Param1,
778 clienttoken: Param2,
779 desiredaccess: u32,
780 objecttypelist: *mut OBJECT_TYPE_LIST,
781 objecttypelistlength: u32,
782 genericmapping: *const GENERIC_MAPPING,
783 privilegeset: *mut PRIVILEGE_SET,
784 privilegesetlength: *mut u32,
785 grantedaccesslist: *mut u32,
786 accessstatuslist: *mut u32,
787 ) -> super::Foundation::BOOL {
788 #[cfg(windows)]
789 {
790 #[link(name = "windows")]
791 extern "system" {
792 fn AccessCheckByTypeResultList(psecuritydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: super::Foundation::PSID, clienttoken: super::Foundation::HANDLE, desiredaccess: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, privilegeset: *mut PRIVILEGE_SET, privilegesetlength: *mut u32, grantedaccesslist: *mut u32, accessstatuslist: *mut u32) -> super::Foundation::BOOL;
793 }
794 ::std::mem::transmute(AccessCheckByTypeResultList(
795 ::std::mem::transmute(psecuritydescriptor),
796 principalselfsid.into_param().abi(),
797 clienttoken.into_param().abi(),
798 ::std::mem::transmute(desiredaccess),
799 ::std::mem::transmute(objecttypelist),
800 ::std::mem::transmute(objecttypelistlength),
801 ::std::mem::transmute(genericmapping),
802 ::std::mem::transmute(privilegeset),
803 ::std::mem::transmute(privilegesetlength),
804 ::std::mem::transmute(grantedaccesslist),
805 ::std::mem::transmute(accessstatuslist),
806 ))
807 }
808 #[cfg(not(windows))]
809 unimplemented!("Unsupported target OS");
810 }
811 #[cfg(feature = "Win32_Foundation")]
812 #[inline]
AccessCheckByTypeResultListAndAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, securitydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param5, desiredaccess: u32, audittype: AUDIT_EVENT_TYPE, flags: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param12, grantedaccess: *mut u32, accessstatuslist: *mut u32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL813 pub unsafe fn AccessCheckByTypeResultListAndAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
814 subsystemname: Param0,
815 handleid: *const ::std::ffi::c_void,
816 objecttypename: Param2,
817 objectname: Param3,
818 securitydescriptor: *const SECURITY_DESCRIPTOR,
819 principalselfsid: Param5,
820 desiredaccess: u32,
821 audittype: AUDIT_EVENT_TYPE,
822 flags: u32,
823 objecttypelist: *mut OBJECT_TYPE_LIST,
824 objecttypelistlength: u32,
825 genericmapping: *const GENERIC_MAPPING,
826 objectcreation: Param12,
827 grantedaccess: *mut u32,
828 accessstatuslist: *mut u32,
829 pfgenerateonclose: *mut i32,
830 ) -> super::Foundation::BOOL {
831 #[cfg(windows)]
832 {
833 #[link(name = "windows")]
834 extern "system" {
835 fn AccessCheckByTypeResultListAndAuditAlarmA(
836 subsystemname: super::Foundation::PSTR,
837 handleid: *const ::std::ffi::c_void,
838 objecttypename: super::Foundation::PSTR,
839 objectname: super::Foundation::PSTR,
840 securitydescriptor: *const SECURITY_DESCRIPTOR,
841 principalselfsid: super::Foundation::PSID,
842 desiredaccess: u32,
843 audittype: AUDIT_EVENT_TYPE,
844 flags: u32,
845 objecttypelist: *mut OBJECT_TYPE_LIST,
846 objecttypelistlength: u32,
847 genericmapping: *const GENERIC_MAPPING,
848 objectcreation: super::Foundation::BOOL,
849 grantedaccess: *mut u32,
850 accessstatuslist: *mut u32,
851 pfgenerateonclose: *mut i32,
852 ) -> super::Foundation::BOOL;
853 }
854 ::std::mem::transmute(AccessCheckByTypeResultListAndAuditAlarmA(
855 subsystemname.into_param().abi(),
856 ::std::mem::transmute(handleid),
857 objecttypename.into_param().abi(),
858 objectname.into_param().abi(),
859 ::std::mem::transmute(securitydescriptor),
860 principalselfsid.into_param().abi(),
861 ::std::mem::transmute(desiredaccess),
862 ::std::mem::transmute(audittype),
863 ::std::mem::transmute(flags),
864 ::std::mem::transmute(objecttypelist),
865 ::std::mem::transmute(objecttypelistlength),
866 ::std::mem::transmute(genericmapping),
867 objectcreation.into_param().abi(),
868 ::std::mem::transmute(grantedaccess),
869 ::std::mem::transmute(accessstatuslist),
870 ::std::mem::transmute(pfgenerateonclose),
871 ))
872 }
873 #[cfg(not(windows))]
874 unimplemented!("Unsupported target OS");
875 }
876 #[cfg(feature = "Win32_Foundation")]
877 #[inline]
AccessCheckByTypeResultListAndAuditAlarmByHandleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param13: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, clienttoken: Param2, objecttypename: Param3, objectname: Param4, securitydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param6, desiredaccess: u32, audittype: AUDIT_EVENT_TYPE, flags: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param13, grantedaccess: *mut u32, accessstatuslist: *mut u32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL878 pub unsafe fn AccessCheckByTypeResultListAndAuditAlarmByHandleA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param13: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
879 subsystemname: Param0,
880 handleid: *const ::std::ffi::c_void,
881 clienttoken: Param2,
882 objecttypename: Param3,
883 objectname: Param4,
884 securitydescriptor: *const SECURITY_DESCRIPTOR,
885 principalselfsid: Param6,
886 desiredaccess: u32,
887 audittype: AUDIT_EVENT_TYPE,
888 flags: u32,
889 objecttypelist: *mut OBJECT_TYPE_LIST,
890 objecttypelistlength: u32,
891 genericmapping: *const GENERIC_MAPPING,
892 objectcreation: Param13,
893 grantedaccess: *mut u32,
894 accessstatuslist: *mut u32,
895 pfgenerateonclose: *mut i32,
896 ) -> super::Foundation::BOOL {
897 #[cfg(windows)]
898 {
899 #[link(name = "windows")]
900 extern "system" {
901 fn AccessCheckByTypeResultListAndAuditAlarmByHandleA(
902 subsystemname: super::Foundation::PSTR,
903 handleid: *const ::std::ffi::c_void,
904 clienttoken: super::Foundation::HANDLE,
905 objecttypename: super::Foundation::PSTR,
906 objectname: super::Foundation::PSTR,
907 securitydescriptor: *const SECURITY_DESCRIPTOR,
908 principalselfsid: super::Foundation::PSID,
909 desiredaccess: u32,
910 audittype: AUDIT_EVENT_TYPE,
911 flags: u32,
912 objecttypelist: *mut OBJECT_TYPE_LIST,
913 objecttypelistlength: u32,
914 genericmapping: *const GENERIC_MAPPING,
915 objectcreation: super::Foundation::BOOL,
916 grantedaccess: *mut u32,
917 accessstatuslist: *mut u32,
918 pfgenerateonclose: *mut i32,
919 ) -> super::Foundation::BOOL;
920 }
921 ::std::mem::transmute(AccessCheckByTypeResultListAndAuditAlarmByHandleA(
922 subsystemname.into_param().abi(),
923 ::std::mem::transmute(handleid),
924 clienttoken.into_param().abi(),
925 objecttypename.into_param().abi(),
926 objectname.into_param().abi(),
927 ::std::mem::transmute(securitydescriptor),
928 principalselfsid.into_param().abi(),
929 ::std::mem::transmute(desiredaccess),
930 ::std::mem::transmute(audittype),
931 ::std::mem::transmute(flags),
932 ::std::mem::transmute(objecttypelist),
933 ::std::mem::transmute(objecttypelistlength),
934 ::std::mem::transmute(genericmapping),
935 objectcreation.into_param().abi(),
936 ::std::mem::transmute(grantedaccess),
937 ::std::mem::transmute(accessstatuslist),
938 ::std::mem::transmute(pfgenerateonclose),
939 ))
940 }
941 #[cfg(not(windows))]
942 unimplemented!("Unsupported target OS");
943 }
944 #[cfg(feature = "Win32_Foundation")]
945 #[inline]
AccessCheckByTypeResultListAndAuditAlarmByHandleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param13: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, clienttoken: Param2, objecttypename: Param3, objectname: Param4, securitydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param6, desiredaccess: u32, audittype: AUDIT_EVENT_TYPE, flags: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param13, grantedaccesslist: *mut u32, accessstatuslist: *mut u32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL946 pub unsafe fn AccessCheckByTypeResultListAndAuditAlarmByHandleW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param13: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
947 subsystemname: Param0,
948 handleid: *const ::std::ffi::c_void,
949 clienttoken: Param2,
950 objecttypename: Param3,
951 objectname: Param4,
952 securitydescriptor: *const SECURITY_DESCRIPTOR,
953 principalselfsid: Param6,
954 desiredaccess: u32,
955 audittype: AUDIT_EVENT_TYPE,
956 flags: u32,
957 objecttypelist: *mut OBJECT_TYPE_LIST,
958 objecttypelistlength: u32,
959 genericmapping: *const GENERIC_MAPPING,
960 objectcreation: Param13,
961 grantedaccesslist: *mut u32,
962 accessstatuslist: *mut u32,
963 pfgenerateonclose: *mut i32,
964 ) -> super::Foundation::BOOL {
965 #[cfg(windows)]
966 {
967 #[link(name = "windows")]
968 extern "system" {
969 fn AccessCheckByTypeResultListAndAuditAlarmByHandleW(
970 subsystemname: super::Foundation::PWSTR,
971 handleid: *const ::std::ffi::c_void,
972 clienttoken: super::Foundation::HANDLE,
973 objecttypename: super::Foundation::PWSTR,
974 objectname: super::Foundation::PWSTR,
975 securitydescriptor: *const SECURITY_DESCRIPTOR,
976 principalselfsid: super::Foundation::PSID,
977 desiredaccess: u32,
978 audittype: AUDIT_EVENT_TYPE,
979 flags: u32,
980 objecttypelist: *mut OBJECT_TYPE_LIST,
981 objecttypelistlength: u32,
982 genericmapping: *const GENERIC_MAPPING,
983 objectcreation: super::Foundation::BOOL,
984 grantedaccesslist: *mut u32,
985 accessstatuslist: *mut u32,
986 pfgenerateonclose: *mut i32,
987 ) -> super::Foundation::BOOL;
988 }
989 ::std::mem::transmute(AccessCheckByTypeResultListAndAuditAlarmByHandleW(
990 subsystemname.into_param().abi(),
991 ::std::mem::transmute(handleid),
992 clienttoken.into_param().abi(),
993 objecttypename.into_param().abi(),
994 objectname.into_param().abi(),
995 ::std::mem::transmute(securitydescriptor),
996 principalselfsid.into_param().abi(),
997 ::std::mem::transmute(desiredaccess),
998 ::std::mem::transmute(audittype),
999 ::std::mem::transmute(flags),
1000 ::std::mem::transmute(objecttypelist),
1001 ::std::mem::transmute(objecttypelistlength),
1002 ::std::mem::transmute(genericmapping),
1003 objectcreation.into_param().abi(),
1004 ::std::mem::transmute(grantedaccesslist),
1005 ::std::mem::transmute(accessstatuslist),
1006 ::std::mem::transmute(pfgenerateonclose),
1007 ))
1008 }
1009 #[cfg(not(windows))]
1010 unimplemented!("Unsupported target OS");
1011 }
1012 #[cfg(feature = "Win32_Foundation")]
1013 #[inline]
AccessCheckByTypeResultListAndAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, securitydescriptor: *const SECURITY_DESCRIPTOR, principalselfsid: Param5, desiredaccess: u32, audittype: AUDIT_EVENT_TYPE, flags: u32, objecttypelist: *mut OBJECT_TYPE_LIST, objecttypelistlength: u32, genericmapping: *const GENERIC_MAPPING, objectcreation: Param12, grantedaccesslist: *mut u32, accessstatuslist: *mut u32, pfgenerateonclose: *mut i32, ) -> super::Foundation::BOOL1014 pub unsafe fn AccessCheckByTypeResultListAndAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param12: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
1015 subsystemname: Param0,
1016 handleid: *const ::std::ffi::c_void,
1017 objecttypename: Param2,
1018 objectname: Param3,
1019 securitydescriptor: *const SECURITY_DESCRIPTOR,
1020 principalselfsid: Param5,
1021 desiredaccess: u32,
1022 audittype: AUDIT_EVENT_TYPE,
1023 flags: u32,
1024 objecttypelist: *mut OBJECT_TYPE_LIST,
1025 objecttypelistlength: u32,
1026 genericmapping: *const GENERIC_MAPPING,
1027 objectcreation: Param12,
1028 grantedaccesslist: *mut u32,
1029 accessstatuslist: *mut u32,
1030 pfgenerateonclose: *mut i32,
1031 ) -> super::Foundation::BOOL {
1032 #[cfg(windows)]
1033 {
1034 #[link(name = "windows")]
1035 extern "system" {
1036 fn AccessCheckByTypeResultListAndAuditAlarmW(
1037 subsystemname: super::Foundation::PWSTR,
1038 handleid: *const ::std::ffi::c_void,
1039 objecttypename: super::Foundation::PWSTR,
1040 objectname: super::Foundation::PWSTR,
1041 securitydescriptor: *const SECURITY_DESCRIPTOR,
1042 principalselfsid: super::Foundation::PSID,
1043 desiredaccess: u32,
1044 audittype: AUDIT_EVENT_TYPE,
1045 flags: u32,
1046 objecttypelist: *mut OBJECT_TYPE_LIST,
1047 objecttypelistlength: u32,
1048 genericmapping: *const GENERIC_MAPPING,
1049 objectcreation: super::Foundation::BOOL,
1050 grantedaccesslist: *mut u32,
1051 accessstatuslist: *mut u32,
1052 pfgenerateonclose: *mut i32,
1053 ) -> super::Foundation::BOOL;
1054 }
1055 ::std::mem::transmute(AccessCheckByTypeResultListAndAuditAlarmW(
1056 subsystemname.into_param().abi(),
1057 ::std::mem::transmute(handleid),
1058 objecttypename.into_param().abi(),
1059 objectname.into_param().abi(),
1060 ::std::mem::transmute(securitydescriptor),
1061 principalselfsid.into_param().abi(),
1062 ::std::mem::transmute(desiredaccess),
1063 ::std::mem::transmute(audittype),
1064 ::std::mem::transmute(flags),
1065 ::std::mem::transmute(objecttypelist),
1066 ::std::mem::transmute(objecttypelistlength),
1067 ::std::mem::transmute(genericmapping),
1068 objectcreation.into_param().abi(),
1069 ::std::mem::transmute(grantedaccesslist),
1070 ::std::mem::transmute(accessstatuslist),
1071 ::std::mem::transmute(pfgenerateonclose),
1072 ))
1073 }
1074 #[cfg(not(windows))]
1075 unimplemented!("Unsupported target OS");
1076 }
1077 #[cfg(feature = "Win32_Foundation")]
1078 #[inline]
AddAccessAllowedAce<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, accessmask: u32, psid: Param3) -> super::Foundation::BOOL1079 pub unsafe fn AddAccessAllowedAce<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, accessmask: u32, psid: Param3) -> super::Foundation::BOOL {
1080 #[cfg(windows)]
1081 {
1082 #[link(name = "windows")]
1083 extern "system" {
1084 fn AddAccessAllowedAce(pacl: *mut ACL, dwacerevision: u32, accessmask: u32, psid: super::Foundation::PSID) -> super::Foundation::BOOL;
1085 }
1086 ::std::mem::transmute(AddAccessAllowedAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(accessmask), psid.into_param().abi()))
1087 }
1088 #[cfg(not(windows))]
1089 unimplemented!("Unsupported target OS");
1090 }
1091 #[cfg(feature = "Win32_Foundation")]
1092 #[inline]
AddAccessAllowedAceEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4) -> super::Foundation::BOOL1093 pub unsafe fn AddAccessAllowedAceEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4) -> super::Foundation::BOOL {
1094 #[cfg(windows)]
1095 {
1096 #[link(name = "windows")]
1097 extern "system" {
1098 fn AddAccessAllowedAceEx(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: super::Foundation::PSID) -> super::Foundation::BOOL;
1099 }
1100 ::std::mem::transmute(AddAccessAllowedAceEx(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(accessmask), psid.into_param().abi()))
1101 }
1102 #[cfg(not(windows))]
1103 unimplemented!("Unsupported target OS");
1104 }
1105 #[cfg(feature = "Win32_Foundation")]
1106 #[inline]
AddAccessAllowedObjectAce<'a, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: Param6) -> super::Foundation::BOOL1107 pub unsafe fn AddAccessAllowedObjectAce<'a, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: Param6) -> super::Foundation::BOOL {
1108 #[cfg(windows)]
1109 {
1110 #[link(name = "windows")]
1111 extern "system" {
1112 fn AddAccessAllowedObjectAce(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: super::Foundation::PSID) -> super::Foundation::BOOL;
1113 }
1114 ::std::mem::transmute(AddAccessAllowedObjectAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(accessmask), ::std::mem::transmute(objecttypeguid), ::std::mem::transmute(inheritedobjecttypeguid), psid.into_param().abi()))
1115 }
1116 #[cfg(not(windows))]
1117 unimplemented!("Unsupported target OS");
1118 }
1119 #[cfg(feature = "Win32_Foundation")]
1120 #[inline]
AddAccessDeniedAce<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, accessmask: u32, psid: Param3) -> super::Foundation::BOOL1121 pub unsafe fn AddAccessDeniedAce<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, accessmask: u32, psid: Param3) -> super::Foundation::BOOL {
1122 #[cfg(windows)]
1123 {
1124 #[link(name = "windows")]
1125 extern "system" {
1126 fn AddAccessDeniedAce(pacl: *mut ACL, dwacerevision: u32, accessmask: u32, psid: super::Foundation::PSID) -> super::Foundation::BOOL;
1127 }
1128 ::std::mem::transmute(AddAccessDeniedAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(accessmask), psid.into_param().abi()))
1129 }
1130 #[cfg(not(windows))]
1131 unimplemented!("Unsupported target OS");
1132 }
1133 #[cfg(feature = "Win32_Foundation")]
1134 #[inline]
AddAccessDeniedAceEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4) -> super::Foundation::BOOL1135 pub unsafe fn AddAccessDeniedAceEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4) -> super::Foundation::BOOL {
1136 #[cfg(windows)]
1137 {
1138 #[link(name = "windows")]
1139 extern "system" {
1140 fn AddAccessDeniedAceEx(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: super::Foundation::PSID) -> super::Foundation::BOOL;
1141 }
1142 ::std::mem::transmute(AddAccessDeniedAceEx(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(accessmask), psid.into_param().abi()))
1143 }
1144 #[cfg(not(windows))]
1145 unimplemented!("Unsupported target OS");
1146 }
1147 #[cfg(feature = "Win32_Foundation")]
1148 #[inline]
AddAccessDeniedObjectAce<'a, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: Param6) -> super::Foundation::BOOL1149 pub unsafe fn AddAccessDeniedObjectAce<'a, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: Param6) -> super::Foundation::BOOL {
1150 #[cfg(windows)]
1151 {
1152 #[link(name = "windows")]
1153 extern "system" {
1154 fn AddAccessDeniedObjectAce(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: super::Foundation::PSID) -> super::Foundation::BOOL;
1155 }
1156 ::std::mem::transmute(AddAccessDeniedObjectAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(accessmask), ::std::mem::transmute(objecttypeguid), ::std::mem::transmute(inheritedobjecttypeguid), psid.into_param().abi()))
1157 }
1158 #[cfg(not(windows))]
1159 unimplemented!("Unsupported target OS");
1160 }
1161 #[cfg(feature = "Win32_Foundation")]
1162 #[inline]
AddAce(pacl: *mut ACL, dwacerevision: u32, dwstartingaceindex: u32, pacelist: *const ::std::ffi::c_void, nacelistlength: u32) -> super::Foundation::BOOL1163 pub unsafe fn AddAce(pacl: *mut ACL, dwacerevision: u32, dwstartingaceindex: u32, pacelist: *const ::std::ffi::c_void, nacelistlength: u32) -> super::Foundation::BOOL {
1164 #[cfg(windows)]
1165 {
1166 #[link(name = "windows")]
1167 extern "system" {
1168 fn AddAce(pacl: *mut ACL, dwacerevision: u32, dwstartingaceindex: u32, pacelist: *const ::std::ffi::c_void, nacelistlength: u32) -> super::Foundation::BOOL;
1169 }
1170 ::std::mem::transmute(AddAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(dwstartingaceindex), ::std::mem::transmute(pacelist), ::std::mem::transmute(nacelistlength)))
1171 }
1172 #[cfg(not(windows))]
1173 unimplemented!("Unsupported target OS");
1174 }
1175 #[cfg(feature = "Win32_Foundation")]
1176 #[inline]
AddAuditAccessAce<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(pacl: *mut ACL, dwacerevision: u32, dwaccessmask: u32, psid: Param3, bauditsuccess: Param4, bauditfailure: Param5) -> super::Foundation::BOOL1177 pub unsafe fn AddAuditAccessAce<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(pacl: *mut ACL, dwacerevision: u32, dwaccessmask: u32, psid: Param3, bauditsuccess: Param4, bauditfailure: Param5) -> super::Foundation::BOOL {
1178 #[cfg(windows)]
1179 {
1180 #[link(name = "windows")]
1181 extern "system" {
1182 fn AddAuditAccessAce(pacl: *mut ACL, dwacerevision: u32, dwaccessmask: u32, psid: super::Foundation::PSID, bauditsuccess: super::Foundation::BOOL, bauditfailure: super::Foundation::BOOL) -> super::Foundation::BOOL;
1183 }
1184 ::std::mem::transmute(AddAuditAccessAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(dwaccessmask), psid.into_param().abi(), bauditsuccess.into_param().abi(), bauditfailure.into_param().abi()))
1185 }
1186 #[cfg(not(windows))]
1187 unimplemented!("Unsupported target OS");
1188 }
1189 #[cfg(feature = "Win32_Foundation")]
1190 #[inline]
AddAuditAccessAceEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, dwaccessmask: u32, psid: Param4, bauditsuccess: Param5, bauditfailure: Param6) -> super::Foundation::BOOL1191 pub unsafe fn AddAuditAccessAceEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, dwaccessmask: u32, psid: Param4, bauditsuccess: Param5, bauditfailure: Param6) -> super::Foundation::BOOL {
1192 #[cfg(windows)]
1193 {
1194 #[link(name = "windows")]
1195 extern "system" {
1196 fn AddAuditAccessAceEx(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, dwaccessmask: u32, psid: super::Foundation::PSID, bauditsuccess: super::Foundation::BOOL, bauditfailure: super::Foundation::BOOL) -> super::Foundation::BOOL;
1197 }
1198 ::std::mem::transmute(AddAuditAccessAceEx(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(dwaccessmask), psid.into_param().abi(), bauditsuccess.into_param().abi(), bauditfailure.into_param().abi()))
1199 }
1200 #[cfg(not(windows))]
1201 unimplemented!("Unsupported target OS");
1202 }
1203 #[cfg(feature = "Win32_Foundation")]
1204 #[inline]
AddAuditAccessObjectAce<'a, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: Param6, bauditsuccess: Param7, bauditfailure: Param8, ) -> super::Foundation::BOOL1205 pub unsafe fn AddAuditAccessObjectAce<'a, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
1206 pacl: *mut ACL,
1207 dwacerevision: u32,
1208 aceflags: ACE_FLAGS,
1209 accessmask: u32,
1210 objecttypeguid: *const ::windows::runtime::GUID,
1211 inheritedobjecttypeguid: *const ::windows::runtime::GUID,
1212 psid: Param6,
1213 bauditsuccess: Param7,
1214 bauditfailure: Param8,
1215 ) -> super::Foundation::BOOL {
1216 #[cfg(windows)]
1217 {
1218 #[link(name = "windows")]
1219 extern "system" {
1220 fn AddAuditAccessObjectAce(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, objecttypeguid: *const ::windows::runtime::GUID, inheritedobjecttypeguid: *const ::windows::runtime::GUID, psid: super::Foundation::PSID, bauditsuccess: super::Foundation::BOOL, bauditfailure: super::Foundation::BOOL) -> super::Foundation::BOOL;
1221 }
1222 ::std::mem::transmute(AddAuditAccessObjectAce(
1223 ::std::mem::transmute(pacl),
1224 ::std::mem::transmute(dwacerevision),
1225 ::std::mem::transmute(aceflags),
1226 ::std::mem::transmute(accessmask),
1227 ::std::mem::transmute(objecttypeguid),
1228 ::std::mem::transmute(inheritedobjecttypeguid),
1229 psid.into_param().abi(),
1230 bauditsuccess.into_param().abi(),
1231 bauditfailure.into_param().abi(),
1232 ))
1233 }
1234 #[cfg(not(windows))]
1235 unimplemented!("Unsupported target OS");
1236 }
1237 #[cfg(feature = "Win32_Foundation")]
1238 #[inline]
AddConditionalAce<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, acetype: u8, accessmask: u32, psid: Param5, conditionstr: Param6, returnlength: *mut u32) -> super::Foundation::BOOL1239 pub unsafe fn AddConditionalAce<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, acetype: u8, accessmask: u32, psid: Param5, conditionstr: Param6, returnlength: *mut u32) -> super::Foundation::BOOL {
1240 #[cfg(windows)]
1241 {
1242 #[link(name = "windows")]
1243 extern "system" {
1244 fn AddConditionalAce(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, acetype: u8, accessmask: u32, psid: super::Foundation::PSID, conditionstr: super::Foundation::PWSTR, returnlength: *mut u32) -> super::Foundation::BOOL;
1245 }
1246 ::std::mem::transmute(AddConditionalAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(acetype), ::std::mem::transmute(accessmask), psid.into_param().abi(), conditionstr.into_param().abi(), ::std::mem::transmute(returnlength)))
1247 }
1248 #[cfg(not(windows))]
1249 unimplemented!("Unsupported target OS");
1250 }
1251 #[cfg(feature = "Win32_Foundation")]
1252 #[inline]
AddMandatoryAce<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: ACE_REVISION, aceflags: ACE_FLAGS, mandatorypolicy: u32, plabelsid: Param4) -> super::Foundation::BOOL1253 pub unsafe fn AddMandatoryAce<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: ACE_REVISION, aceflags: ACE_FLAGS, mandatorypolicy: u32, plabelsid: Param4) -> super::Foundation::BOOL {
1254 #[cfg(windows)]
1255 {
1256 #[link(name = "windows")]
1257 extern "system" {
1258 fn AddMandatoryAce(pacl: *mut ACL, dwacerevision: ACE_REVISION, aceflags: ACE_FLAGS, mandatorypolicy: u32, plabelsid: super::Foundation::PSID) -> super::Foundation::BOOL;
1259 }
1260 ::std::mem::transmute(AddMandatoryAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(mandatorypolicy), plabelsid.into_param().abi()))
1261 }
1262 #[cfg(not(windows))]
1263 unimplemented!("Unsupported target OS");
1264 }
1265 #[cfg(feature = "Win32_Foundation")]
1266 #[inline]
AddResourceAttributeAce<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4, pattributeinfo: *const CLAIM_SECURITY_ATTRIBUTES_INFORMATION, preturnlength: *mut u32) -> super::Foundation::BOOL1267 pub unsafe fn AddResourceAttributeAce<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4, pattributeinfo: *const CLAIM_SECURITY_ATTRIBUTES_INFORMATION, preturnlength: *mut u32) -> super::Foundation::BOOL {
1268 #[cfg(windows)]
1269 {
1270 #[link(name = "windows")]
1271 extern "system" {
1272 fn AddResourceAttributeAce(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: super::Foundation::PSID, pattributeinfo: *const CLAIM_SECURITY_ATTRIBUTES_INFORMATION, preturnlength: *mut u32) -> super::Foundation::BOOL;
1273 }
1274 ::std::mem::transmute(AddResourceAttributeAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(accessmask), psid.into_param().abi(), ::std::mem::transmute(pattributeinfo), ::std::mem::transmute(preturnlength)))
1275 }
1276 #[cfg(not(windows))]
1277 unimplemented!("Unsupported target OS");
1278 }
1279 #[cfg(feature = "Win32_Foundation")]
1280 #[inline]
AddScopedPolicyIDAce<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4) -> super::Foundation::BOOL1281 pub unsafe fn AddScopedPolicyIDAce<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: Param4) -> super::Foundation::BOOL {
1282 #[cfg(windows)]
1283 {
1284 #[link(name = "windows")]
1285 extern "system" {
1286 fn AddScopedPolicyIDAce(pacl: *mut ACL, dwacerevision: u32, aceflags: ACE_FLAGS, accessmask: u32, psid: super::Foundation::PSID) -> super::Foundation::BOOL;
1287 }
1288 ::std::mem::transmute(AddScopedPolicyIDAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwacerevision), ::std::mem::transmute(aceflags), ::std::mem::transmute(accessmask), psid.into_param().abi()))
1289 }
1290 #[cfg(not(windows))]
1291 unimplemented!("Unsupported target OS");
1292 }
1293 #[cfg(feature = "Win32_Foundation")]
1294 #[inline]
AdjustTokenGroups<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(tokenhandle: Param0, resettodefault: Param1, newstate: *const TOKEN_GROUPS, bufferlength: u32, previousstate: *mut TOKEN_GROUPS, returnlength: *mut u32) -> super::Foundation::BOOL1295 pub unsafe fn AdjustTokenGroups<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(tokenhandle: Param0, resettodefault: Param1, newstate: *const TOKEN_GROUPS, bufferlength: u32, previousstate: *mut TOKEN_GROUPS, returnlength: *mut u32) -> super::Foundation::BOOL {
1296 #[cfg(windows)]
1297 {
1298 #[link(name = "windows")]
1299 extern "system" {
1300 fn AdjustTokenGroups(tokenhandle: super::Foundation::HANDLE, resettodefault: super::Foundation::BOOL, newstate: *const TOKEN_GROUPS, bufferlength: u32, previousstate: *mut TOKEN_GROUPS, returnlength: *mut u32) -> super::Foundation::BOOL;
1301 }
1302 ::std::mem::transmute(AdjustTokenGroups(tokenhandle.into_param().abi(), resettodefault.into_param().abi(), ::std::mem::transmute(newstate), ::std::mem::transmute(bufferlength), ::std::mem::transmute(previousstate), ::std::mem::transmute(returnlength)))
1303 }
1304 #[cfg(not(windows))]
1305 unimplemented!("Unsupported target OS");
1306 }
1307 #[cfg(feature = "Win32_Foundation")]
1308 #[inline]
AdjustTokenPrivileges<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(tokenhandle: Param0, disableallprivileges: Param1, newstate: *const TOKEN_PRIVILEGES, bufferlength: u32, previousstate: *mut TOKEN_PRIVILEGES, returnlength: *mut u32) -> super::Foundation::BOOL1309 pub unsafe fn AdjustTokenPrivileges<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(tokenhandle: Param0, disableallprivileges: Param1, newstate: *const TOKEN_PRIVILEGES, bufferlength: u32, previousstate: *mut TOKEN_PRIVILEGES, returnlength: *mut u32) -> super::Foundation::BOOL {
1310 #[cfg(windows)]
1311 {
1312 #[link(name = "windows")]
1313 extern "system" {
1314 fn AdjustTokenPrivileges(tokenhandle: super::Foundation::HANDLE, disableallprivileges: super::Foundation::BOOL, newstate: *const TOKEN_PRIVILEGES, bufferlength: u32, previousstate: *mut TOKEN_PRIVILEGES, returnlength: *mut u32) -> super::Foundation::BOOL;
1315 }
1316 ::std::mem::transmute(AdjustTokenPrivileges(tokenhandle.into_param().abi(), disableallprivileges.into_param().abi(), ::std::mem::transmute(newstate), ::std::mem::transmute(bufferlength), ::std::mem::transmute(previousstate), ::std::mem::transmute(returnlength)))
1317 }
1318 #[cfg(not(windows))]
1319 unimplemented!("Unsupported target OS");
1320 }
1321 #[cfg(feature = "Win32_Foundation")]
1322 #[inline]
AllocateAndInitializeSid(pidentifierauthority: *const SID_IDENTIFIER_AUTHORITY, nsubauthoritycount: u8, nsubauthority0: u32, nsubauthority1: u32, nsubauthority2: u32, nsubauthority3: u32, nsubauthority4: u32, nsubauthority5: u32, nsubauthority6: u32, nsubauthority7: u32, psid: *mut super::Foundation::PSID) -> super::Foundation::BOOL1323 pub unsafe fn AllocateAndInitializeSid(pidentifierauthority: *const SID_IDENTIFIER_AUTHORITY, nsubauthoritycount: u8, nsubauthority0: u32, nsubauthority1: u32, nsubauthority2: u32, nsubauthority3: u32, nsubauthority4: u32, nsubauthority5: u32, nsubauthority6: u32, nsubauthority7: u32, psid: *mut super::Foundation::PSID) -> super::Foundation::BOOL {
1324 #[cfg(windows)]
1325 {
1326 #[link(name = "windows")]
1327 extern "system" {
1328 fn AllocateAndInitializeSid(pidentifierauthority: *const SID_IDENTIFIER_AUTHORITY, nsubauthoritycount: u8, nsubauthority0: u32, nsubauthority1: u32, nsubauthority2: u32, nsubauthority3: u32, nsubauthority4: u32, nsubauthority5: u32, nsubauthority6: u32, nsubauthority7: u32, psid: *mut super::Foundation::PSID) -> super::Foundation::BOOL;
1329 }
1330 ::std::mem::transmute(AllocateAndInitializeSid(
1331 ::std::mem::transmute(pidentifierauthority),
1332 ::std::mem::transmute(nsubauthoritycount),
1333 ::std::mem::transmute(nsubauthority0),
1334 ::std::mem::transmute(nsubauthority1),
1335 ::std::mem::transmute(nsubauthority2),
1336 ::std::mem::transmute(nsubauthority3),
1337 ::std::mem::transmute(nsubauthority4),
1338 ::std::mem::transmute(nsubauthority5),
1339 ::std::mem::transmute(nsubauthority6),
1340 ::std::mem::transmute(nsubauthority7),
1341 ::std::mem::transmute(psid),
1342 ))
1343 }
1344 #[cfg(not(windows))]
1345 unimplemented!("Unsupported target OS");
1346 }
1347 #[cfg(feature = "Win32_Foundation")]
1348 #[inline]
AllocateLocallyUniqueId(luid: *mut super::Foundation::LUID) -> super::Foundation::BOOL1349 pub unsafe fn AllocateLocallyUniqueId(luid: *mut super::Foundation::LUID) -> super::Foundation::BOOL {
1350 #[cfg(windows)]
1351 {
1352 #[link(name = "windows")]
1353 extern "system" {
1354 fn AllocateLocallyUniqueId(luid: *mut super::Foundation::LUID) -> super::Foundation::BOOL;
1355 }
1356 ::std::mem::transmute(AllocateLocallyUniqueId(::std::mem::transmute(luid)))
1357 }
1358 #[cfg(not(windows))]
1359 unimplemented!("Unsupported target OS");
1360 }
1361 #[cfg(feature = "Win32_Foundation")]
1362 #[inline]
AreAllAccessesGranted(grantedaccess: u32, desiredaccess: u32) -> super::Foundation::BOOL1363 pub unsafe fn AreAllAccessesGranted(grantedaccess: u32, desiredaccess: u32) -> super::Foundation::BOOL {
1364 #[cfg(windows)]
1365 {
1366 #[link(name = "windows")]
1367 extern "system" {
1368 fn AreAllAccessesGranted(grantedaccess: u32, desiredaccess: u32) -> super::Foundation::BOOL;
1369 }
1370 ::std::mem::transmute(AreAllAccessesGranted(::std::mem::transmute(grantedaccess), ::std::mem::transmute(desiredaccess)))
1371 }
1372 #[cfg(not(windows))]
1373 unimplemented!("Unsupported target OS");
1374 }
1375 #[cfg(feature = "Win32_Foundation")]
1376 #[inline]
AreAnyAccessesGranted(grantedaccess: u32, desiredaccess: u32) -> super::Foundation::BOOL1377 pub unsafe fn AreAnyAccessesGranted(grantedaccess: u32, desiredaccess: u32) -> super::Foundation::BOOL {
1378 #[cfg(windows)]
1379 {
1380 #[link(name = "windows")]
1381 extern "system" {
1382 fn AreAnyAccessesGranted(grantedaccess: u32, desiredaccess: u32) -> super::Foundation::BOOL;
1383 }
1384 ::std::mem::transmute(AreAnyAccessesGranted(::std::mem::transmute(grantedaccess), ::std::mem::transmute(desiredaccess)))
1385 }
1386 #[cfg(not(windows))]
1387 unimplemented!("Unsupported target OS");
1388 }
1389 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1390 #[repr(C)]
1391 #[cfg(feature = "Win32_Foundation")]
1392 pub struct CLAIM_SECURITY_ATTRIBUTES_INFORMATION {
1393 pub Version: u16,
1394 pub Reserved: u16,
1395 pub AttributeCount: u32,
1396 pub Attribute: CLAIM_SECURITY_ATTRIBUTES_INFORMATION_0,
1397 }
1398 #[cfg(feature = "Win32_Foundation")]
1399 impl CLAIM_SECURITY_ATTRIBUTES_INFORMATION {}
1400 #[cfg(feature = "Win32_Foundation")]
1401 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTES_INFORMATION {
default() -> Self1402 fn default() -> Self {
1403 unsafe { ::std::mem::zeroed() }
1404 }
1405 }
1406 #[cfg(feature = "Win32_Foundation")]
1407 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTES_INFORMATION {
eq(&self, _other: &Self) -> bool1408 fn eq(&self, _other: &Self) -> bool {
1409 unimplemented!()
1410 }
1411 }
1412 #[cfg(feature = "Win32_Foundation")]
1413 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTES_INFORMATION {}
1414 #[cfg(feature = "Win32_Foundation")]
1415 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTES_INFORMATION {
1416 type Abi = Self;
1417 type DefaultType = Self;
1418 }
1419 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1420 #[repr(C)]
1421 #[cfg(feature = "Win32_Foundation")]
1422 pub union CLAIM_SECURITY_ATTRIBUTES_INFORMATION_0 {
1423 pub pAttributeV1: *mut CLAIM_SECURITY_ATTRIBUTE_V1,
1424 }
1425 #[cfg(feature = "Win32_Foundation")]
1426 impl CLAIM_SECURITY_ATTRIBUTES_INFORMATION_0 {}
1427 #[cfg(feature = "Win32_Foundation")]
1428 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTES_INFORMATION_0 {
default() -> Self1429 fn default() -> Self {
1430 unsafe { ::std::mem::zeroed() }
1431 }
1432 }
1433 #[cfg(feature = "Win32_Foundation")]
1434 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTES_INFORMATION_0 {
eq(&self, _other: &Self) -> bool1435 fn eq(&self, _other: &Self) -> bool {
1436 unimplemented!()
1437 }
1438 }
1439 #[cfg(feature = "Win32_Foundation")]
1440 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTES_INFORMATION_0 {}
1441 #[cfg(feature = "Win32_Foundation")]
1442 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTES_INFORMATION_0 {
1443 type Abi = Self;
1444 type DefaultType = Self;
1445 }
1446 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1447 #[repr(transparent)]
1448 pub struct CLAIM_SECURITY_ATTRIBUTE_FLAGS(pub u32);
1449 pub const CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE: CLAIM_SECURITY_ATTRIBUTE_FLAGS = CLAIM_SECURITY_ATTRIBUTE_FLAGS(1u32);
1450 pub const CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE: CLAIM_SECURITY_ATTRIBUTE_FLAGS = CLAIM_SECURITY_ATTRIBUTE_FLAGS(2u32);
1451 pub const CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY: CLAIM_SECURITY_ATTRIBUTE_FLAGS = CLAIM_SECURITY_ATTRIBUTE_FLAGS(4u32);
1452 pub const CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT: CLAIM_SECURITY_ATTRIBUTE_FLAGS = CLAIM_SECURITY_ATTRIBUTE_FLAGS(8u32);
1453 pub const CLAIM_SECURITY_ATTRIBUTE_DISABLED: CLAIM_SECURITY_ATTRIBUTE_FLAGS = CLAIM_SECURITY_ATTRIBUTE_FLAGS(16u32);
1454 pub const CLAIM_SECURITY_ATTRIBUTE_MANDATORY: CLAIM_SECURITY_ATTRIBUTE_FLAGS = CLAIM_SECURITY_ATTRIBUTE_FLAGS(32u32);
1455 impl ::std::convert::From<u32> for CLAIM_SECURITY_ATTRIBUTE_FLAGS {
from(value: u32) -> Self1456 fn from(value: u32) -> Self {
1457 Self(value)
1458 }
1459 }
1460 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_FLAGS {
1461 type Abi = Self;
1462 type DefaultType = Self;
1463 }
1464 impl ::std::ops::BitOr for CLAIM_SECURITY_ATTRIBUTE_FLAGS {
1465 type Output = Self;
bitor(self, rhs: Self) -> Self1466 fn bitor(self, rhs: Self) -> Self {
1467 Self(self.0 | rhs.0)
1468 }
1469 }
1470 impl ::std::ops::BitAnd for CLAIM_SECURITY_ATTRIBUTE_FLAGS {
1471 type Output = Self;
bitand(self, rhs: Self) -> Self1472 fn bitand(self, rhs: Self) -> Self {
1473 Self(self.0 & rhs.0)
1474 }
1475 }
1476 impl ::std::ops::BitOrAssign for CLAIM_SECURITY_ATTRIBUTE_FLAGS {
bitor_assign(&mut self, rhs: Self)1477 fn bitor_assign(&mut self, rhs: Self) {
1478 self.0.bitor_assign(rhs.0)
1479 }
1480 }
1481 impl ::std::ops::BitAndAssign for CLAIM_SECURITY_ATTRIBUTE_FLAGS {
bitand_assign(&mut self, rhs: Self)1482 fn bitand_assign(&mut self, rhs: Self) {
1483 self.0.bitand_assign(rhs.0)
1484 }
1485 }
1486 impl ::std::ops::Not for CLAIM_SECURITY_ATTRIBUTE_FLAGS {
1487 type Output = Self;
not(self) -> Self1488 fn not(self) -> Self {
1489 Self(self.0.not())
1490 }
1491 }
1492 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1493 #[repr(C)]
1494 #[cfg(feature = "Win32_Foundation")]
1495 pub struct CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {
1496 pub Version: u64,
1497 pub Name: super::Foundation::PWSTR,
1498 }
1499 #[cfg(feature = "Win32_Foundation")]
1500 impl CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {}
1501 #[cfg(feature = "Win32_Foundation")]
1502 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {
default() -> Self1503 fn default() -> Self {
1504 unsafe { ::std::mem::zeroed() }
1505 }
1506 }
1507 #[cfg(feature = "Win32_Foundation")]
1508 impl ::std::fmt::Debug for CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1509 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1510 fmt.debug_struct("CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE").field("Version", &self.Version).field("Name", &self.Name).finish()
1511 }
1512 }
1513 #[cfg(feature = "Win32_Foundation")]
1514 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {
eq(&self, other: &Self) -> bool1515 fn eq(&self, other: &Self) -> bool {
1516 self.Version == other.Version && self.Name == other.Name
1517 }
1518 }
1519 #[cfg(feature = "Win32_Foundation")]
1520 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {}
1521 #[cfg(feature = "Win32_Foundation")]
1522 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE {
1523 type Abi = Self;
1524 type DefaultType = Self;
1525 }
1526 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1527 #[repr(C)]
1528 pub struct CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {
1529 pub pValue: *mut ::std::ffi::c_void,
1530 pub ValueLength: u32,
1531 }
1532 impl CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {}
1533 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {
default() -> Self1534 fn default() -> Self {
1535 unsafe { ::std::mem::zeroed() }
1536 }
1537 }
1538 impl ::std::fmt::Debug for CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1539 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1540 fmt.debug_struct("CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE").field("pValue", &self.pValue).field("ValueLength", &self.ValueLength).finish()
1541 }
1542 }
1543 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {
eq(&self, other: &Self) -> bool1544 fn eq(&self, other: &Self) -> bool {
1545 self.pValue == other.pValue && self.ValueLength == other.ValueLength
1546 }
1547 }
1548 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {}
1549 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE {
1550 type Abi = Self;
1551 type DefaultType = Self;
1552 }
1553 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1554 #[repr(C)]
1555 pub struct CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 {
1556 pub Name: u32,
1557 pub ValueType: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE,
1558 pub Reserved: u16,
1559 pub Flags: CLAIM_SECURITY_ATTRIBUTE_FLAGS,
1560 pub ValueCount: u32,
1561 pub Values: CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_0,
1562 }
1563 impl CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 {}
1564 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 {
default() -> Self1565 fn default() -> Self {
1566 unsafe { ::std::mem::zeroed() }
1567 }
1568 }
1569 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 {
eq(&self, _other: &Self) -> bool1570 fn eq(&self, _other: &Self) -> bool {
1571 unimplemented!()
1572 }
1573 }
1574 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 {}
1575 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 {
1576 type Abi = Self;
1577 type DefaultType = Self;
1578 }
1579 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1580 #[repr(C)]
1581 pub union CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_0 {
1582 pub pInt64: [u32; 1],
1583 pub pUint64: [u32; 1],
1584 pub ppString: [u32; 1],
1585 pub pFqbn: [u32; 1],
1586 pub pOctetString: [u32; 1],
1587 }
1588 impl CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_0 {}
1589 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_0 {
default() -> Self1590 fn default() -> Self {
1591 unsafe { ::std::mem::zeroed() }
1592 }
1593 }
1594 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_0 {
eq(&self, _other: &Self) -> bool1595 fn eq(&self, _other: &Self) -> bool {
1596 unimplemented!()
1597 }
1598 }
1599 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_0 {}
1600 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1_0 {
1601 type Abi = Self;
1602 type DefaultType = Self;
1603 }
1604 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1605 #[repr(C)]
1606 #[cfg(feature = "Win32_Foundation")]
1607 pub struct CLAIM_SECURITY_ATTRIBUTE_V1 {
1608 pub Name: super::Foundation::PWSTR,
1609 pub ValueType: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE,
1610 pub Reserved: u16,
1611 pub Flags: u32,
1612 pub ValueCount: u32,
1613 pub Values: CLAIM_SECURITY_ATTRIBUTE_V1_0,
1614 }
1615 #[cfg(feature = "Win32_Foundation")]
1616 impl CLAIM_SECURITY_ATTRIBUTE_V1 {}
1617 #[cfg(feature = "Win32_Foundation")]
1618 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTE_V1 {
default() -> Self1619 fn default() -> Self {
1620 unsafe { ::std::mem::zeroed() }
1621 }
1622 }
1623 #[cfg(feature = "Win32_Foundation")]
1624 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTE_V1 {
eq(&self, _other: &Self) -> bool1625 fn eq(&self, _other: &Self) -> bool {
1626 unimplemented!()
1627 }
1628 }
1629 #[cfg(feature = "Win32_Foundation")]
1630 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTE_V1 {}
1631 #[cfg(feature = "Win32_Foundation")]
1632 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_V1 {
1633 type Abi = Self;
1634 type DefaultType = Self;
1635 }
1636 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1637 #[repr(C)]
1638 #[cfg(feature = "Win32_Foundation")]
1639 pub union CLAIM_SECURITY_ATTRIBUTE_V1_0 {
1640 pub pInt64: *mut i64,
1641 pub pUint64: *mut u64,
1642 pub ppString: *mut super::Foundation::PWSTR,
1643 pub pFqbn: *mut CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE,
1644 pub pOctetString: *mut CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE,
1645 }
1646 #[cfg(feature = "Win32_Foundation")]
1647 impl CLAIM_SECURITY_ATTRIBUTE_V1_0 {}
1648 #[cfg(feature = "Win32_Foundation")]
1649 impl ::std::default::Default for CLAIM_SECURITY_ATTRIBUTE_V1_0 {
default() -> Self1650 fn default() -> Self {
1651 unsafe { ::std::mem::zeroed() }
1652 }
1653 }
1654 #[cfg(feature = "Win32_Foundation")]
1655 impl ::std::cmp::PartialEq for CLAIM_SECURITY_ATTRIBUTE_V1_0 {
eq(&self, _other: &Self) -> bool1656 fn eq(&self, _other: &Self) -> bool {
1657 unimplemented!()
1658 }
1659 }
1660 #[cfg(feature = "Win32_Foundation")]
1661 impl ::std::cmp::Eq for CLAIM_SECURITY_ATTRIBUTE_V1_0 {}
1662 #[cfg(feature = "Win32_Foundation")]
1663 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_V1_0 {
1664 type Abi = Self;
1665 type DefaultType = Self;
1666 }
1667 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1668 #[repr(transparent)]
1669 pub struct CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(pub u16);
1670 pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE = CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(1u16);
1671 pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE = CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(2u16);
1672 pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE = CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(3u16);
1673 pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE = CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(16u16);
1674 pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE = CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(4u16);
1675 pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_SID: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE = CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(5u16);
1676 pub const CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN: CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE = CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE(6u16);
1677 impl ::std::convert::From<u16> for CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE {
from(value: u16) -> Self1678 fn from(value: u16) -> Self {
1679 Self(value)
1680 }
1681 }
1682 unsafe impl ::windows::runtime::Abi for CLAIM_SECURITY_ATTRIBUTE_VALUE_TYPE {
1683 type Abi = Self;
1684 type DefaultType = Self;
1685 }
1686 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1687 #[repr(transparent)]
1688 pub struct CREATE_RESTRICTED_TOKEN_FLAGS(pub u32);
1689 pub const DISABLE_MAX_PRIVILEGE: CREATE_RESTRICTED_TOKEN_FLAGS = CREATE_RESTRICTED_TOKEN_FLAGS(1u32);
1690 pub const SANDBOX_INERT: CREATE_RESTRICTED_TOKEN_FLAGS = CREATE_RESTRICTED_TOKEN_FLAGS(2u32);
1691 pub const LUA_TOKEN: CREATE_RESTRICTED_TOKEN_FLAGS = CREATE_RESTRICTED_TOKEN_FLAGS(4u32);
1692 pub const WRITE_RESTRICTED: CREATE_RESTRICTED_TOKEN_FLAGS = CREATE_RESTRICTED_TOKEN_FLAGS(8u32);
1693 impl ::std::convert::From<u32> for CREATE_RESTRICTED_TOKEN_FLAGS {
from(value: u32) -> Self1694 fn from(value: u32) -> Self {
1695 Self(value)
1696 }
1697 }
1698 unsafe impl ::windows::runtime::Abi for CREATE_RESTRICTED_TOKEN_FLAGS {
1699 type Abi = Self;
1700 type DefaultType = Self;
1701 }
1702 impl ::std::ops::BitOr for CREATE_RESTRICTED_TOKEN_FLAGS {
1703 type Output = Self;
bitor(self, rhs: Self) -> Self1704 fn bitor(self, rhs: Self) -> Self {
1705 Self(self.0 | rhs.0)
1706 }
1707 }
1708 impl ::std::ops::BitAnd for CREATE_RESTRICTED_TOKEN_FLAGS {
1709 type Output = Self;
bitand(self, rhs: Self) -> Self1710 fn bitand(self, rhs: Self) -> Self {
1711 Self(self.0 & rhs.0)
1712 }
1713 }
1714 impl ::std::ops::BitOrAssign for CREATE_RESTRICTED_TOKEN_FLAGS {
bitor_assign(&mut self, rhs: Self)1715 fn bitor_assign(&mut self, rhs: Self) {
1716 self.0.bitor_assign(rhs.0)
1717 }
1718 }
1719 impl ::std::ops::BitAndAssign for CREATE_RESTRICTED_TOKEN_FLAGS {
bitand_assign(&mut self, rhs: Self)1720 fn bitand_assign(&mut self, rhs: Self) {
1721 self.0.bitand_assign(rhs.0)
1722 }
1723 }
1724 impl ::std::ops::Not for CREATE_RESTRICTED_TOKEN_FLAGS {
1725 type Output = Self;
not(self) -> Self1726 fn not(self) -> Self {
1727 Self(self.0.not())
1728 }
1729 }
1730 pub const CVT_SECONDS: u32 = 1u32;
1731 #[cfg(feature = "Win32_Foundation")]
1732 #[inline]
CheckTokenCapability<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(tokenhandle: Param0, capabilitysidtocheck: Param1, hascapability: *mut super::Foundation::BOOL) -> super::Foundation::BOOL1733 pub unsafe fn CheckTokenCapability<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(tokenhandle: Param0, capabilitysidtocheck: Param1, hascapability: *mut super::Foundation::BOOL) -> super::Foundation::BOOL {
1734 #[cfg(windows)]
1735 {
1736 #[link(name = "windows")]
1737 extern "system" {
1738 fn CheckTokenCapability(tokenhandle: super::Foundation::HANDLE, capabilitysidtocheck: super::Foundation::PSID, hascapability: *mut super::Foundation::BOOL) -> super::Foundation::BOOL;
1739 }
1740 ::std::mem::transmute(CheckTokenCapability(tokenhandle.into_param().abi(), capabilitysidtocheck.into_param().abi(), ::std::mem::transmute(hascapability)))
1741 }
1742 #[cfg(not(windows))]
1743 unimplemented!("Unsupported target OS");
1744 }
1745 #[cfg(feature = "Win32_Foundation")]
1746 #[inline]
CheckTokenMembership<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(tokenhandle: Param0, sidtocheck: Param1, ismember: *mut super::Foundation::BOOL) -> super::Foundation::BOOL1747 pub unsafe fn CheckTokenMembership<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(tokenhandle: Param0, sidtocheck: Param1, ismember: *mut super::Foundation::BOOL) -> super::Foundation::BOOL {
1748 #[cfg(windows)]
1749 {
1750 #[link(name = "windows")]
1751 extern "system" {
1752 fn CheckTokenMembership(tokenhandle: super::Foundation::HANDLE, sidtocheck: super::Foundation::PSID, ismember: *mut super::Foundation::BOOL) -> super::Foundation::BOOL;
1753 }
1754 ::std::mem::transmute(CheckTokenMembership(tokenhandle.into_param().abi(), sidtocheck.into_param().abi(), ::std::mem::transmute(ismember)))
1755 }
1756 #[cfg(not(windows))]
1757 unimplemented!("Unsupported target OS");
1758 }
1759 #[cfg(feature = "Win32_Foundation")]
1760 #[inline]
CheckTokenMembershipEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(tokenhandle: Param0, sidtocheck: Param1, flags: u32, ismember: *mut super::Foundation::BOOL) -> super::Foundation::BOOL1761 pub unsafe fn CheckTokenMembershipEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(tokenhandle: Param0, sidtocheck: Param1, flags: u32, ismember: *mut super::Foundation::BOOL) -> super::Foundation::BOOL {
1762 #[cfg(windows)]
1763 {
1764 #[link(name = "windows")]
1765 extern "system" {
1766 fn CheckTokenMembershipEx(tokenhandle: super::Foundation::HANDLE, sidtocheck: super::Foundation::PSID, flags: u32, ismember: *mut super::Foundation::BOOL) -> super::Foundation::BOOL;
1767 }
1768 ::std::mem::transmute(CheckTokenMembershipEx(tokenhandle.into_param().abi(), sidtocheck.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(ismember)))
1769 }
1770 #[cfg(not(windows))]
1771 unimplemented!("Unsupported target OS");
1772 }
1773 #[cfg(feature = "Win32_Foundation")]
1774 #[inline]
ConvertToAutoInheritPrivateObjectSecurity<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOLEAN>>(parentdescriptor: *const SECURITY_DESCRIPTOR, currentsecuritydescriptor: *const SECURITY_DESCRIPTOR, newsecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, objecttype: *const ::windows::runtime::GUID, isdirectoryobject: Param4, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL1775 pub unsafe fn ConvertToAutoInheritPrivateObjectSecurity<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOLEAN>>(parentdescriptor: *const SECURITY_DESCRIPTOR, currentsecuritydescriptor: *const SECURITY_DESCRIPTOR, newsecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, objecttype: *const ::windows::runtime::GUID, isdirectoryobject: Param4, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL {
1776 #[cfg(windows)]
1777 {
1778 #[link(name = "windows")]
1779 extern "system" {
1780 fn ConvertToAutoInheritPrivateObjectSecurity(parentdescriptor: *const SECURITY_DESCRIPTOR, currentsecuritydescriptor: *const SECURITY_DESCRIPTOR, newsecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, objecttype: *const ::windows::runtime::GUID, isdirectoryobject: super::Foundation::BOOLEAN, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL;
1781 }
1782 ::std::mem::transmute(ConvertToAutoInheritPrivateObjectSecurity(::std::mem::transmute(parentdescriptor), ::std::mem::transmute(currentsecuritydescriptor), ::std::mem::transmute(newsecuritydescriptor), ::std::mem::transmute(objecttype), isdirectoryobject.into_param().abi(), ::std::mem::transmute(genericmapping)))
1783 }
1784 #[cfg(not(windows))]
1785 unimplemented!("Unsupported target OS");
1786 }
1787 #[cfg(feature = "Win32_Foundation")]
1788 #[inline]
CopySid<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(ndestinationsidlength: u32, pdestinationsid: super::Foundation::PSID, psourcesid: Param2) -> super::Foundation::BOOL1789 pub unsafe fn CopySid<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(ndestinationsidlength: u32, pdestinationsid: super::Foundation::PSID, psourcesid: Param2) -> super::Foundation::BOOL {
1790 #[cfg(windows)]
1791 {
1792 #[link(name = "windows")]
1793 extern "system" {
1794 fn CopySid(ndestinationsidlength: u32, pdestinationsid: super::Foundation::PSID, psourcesid: super::Foundation::PSID) -> super::Foundation::BOOL;
1795 }
1796 ::std::mem::transmute(CopySid(::std::mem::transmute(ndestinationsidlength), ::std::mem::transmute(pdestinationsid), psourcesid.into_param().abi()))
1797 }
1798 #[cfg(not(windows))]
1799 unimplemented!("Unsupported target OS");
1800 }
1801 #[cfg(feature = "Win32_Foundation")]
1802 #[inline]
CreatePrivateObjectSecurity<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(parentdescriptor: *const SECURITY_DESCRIPTOR, creatordescriptor: *const SECURITY_DESCRIPTOR, newdescriptor: *mut *mut SECURITY_DESCRIPTOR, isdirectoryobject: Param3, token: Param4, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL1803 pub unsafe fn CreatePrivateObjectSecurity<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(parentdescriptor: *const SECURITY_DESCRIPTOR, creatordescriptor: *const SECURITY_DESCRIPTOR, newdescriptor: *mut *mut SECURITY_DESCRIPTOR, isdirectoryobject: Param3, token: Param4, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL {
1804 #[cfg(windows)]
1805 {
1806 #[link(name = "windows")]
1807 extern "system" {
1808 fn CreatePrivateObjectSecurity(parentdescriptor: *const SECURITY_DESCRIPTOR, creatordescriptor: *const SECURITY_DESCRIPTOR, newdescriptor: *mut *mut SECURITY_DESCRIPTOR, isdirectoryobject: super::Foundation::BOOL, token: super::Foundation::HANDLE, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL;
1809 }
1810 ::std::mem::transmute(CreatePrivateObjectSecurity(::std::mem::transmute(parentdescriptor), ::std::mem::transmute(creatordescriptor), ::std::mem::transmute(newdescriptor), isdirectoryobject.into_param().abi(), token.into_param().abi(), ::std::mem::transmute(genericmapping)))
1811 }
1812 #[cfg(not(windows))]
1813 unimplemented!("Unsupported target OS");
1814 }
1815 #[cfg(feature = "Win32_Foundation")]
1816 #[inline]
CreatePrivateObjectSecurityEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>( parentdescriptor: *const SECURITY_DESCRIPTOR, creatordescriptor: *const SECURITY_DESCRIPTOR, newdescriptor: *mut *mut SECURITY_DESCRIPTOR, objecttype: *const ::windows::runtime::GUID, iscontainerobject: Param4, autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS, token: Param6, genericmapping: *const GENERIC_MAPPING, ) -> super::Foundation::BOOL1817 pub unsafe fn CreatePrivateObjectSecurityEx<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(
1818 parentdescriptor: *const SECURITY_DESCRIPTOR,
1819 creatordescriptor: *const SECURITY_DESCRIPTOR,
1820 newdescriptor: *mut *mut SECURITY_DESCRIPTOR,
1821 objecttype: *const ::windows::runtime::GUID,
1822 iscontainerobject: Param4,
1823 autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS,
1824 token: Param6,
1825 genericmapping: *const GENERIC_MAPPING,
1826 ) -> super::Foundation::BOOL {
1827 #[cfg(windows)]
1828 {
1829 #[link(name = "windows")]
1830 extern "system" {
1831 fn CreatePrivateObjectSecurityEx(parentdescriptor: *const SECURITY_DESCRIPTOR, creatordescriptor: *const SECURITY_DESCRIPTOR, newdescriptor: *mut *mut SECURITY_DESCRIPTOR, objecttype: *const ::windows::runtime::GUID, iscontainerobject: super::Foundation::BOOL, autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS, token: super::Foundation::HANDLE, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL;
1832 }
1833 ::std::mem::transmute(CreatePrivateObjectSecurityEx(
1834 ::std::mem::transmute(parentdescriptor),
1835 ::std::mem::transmute(creatordescriptor),
1836 ::std::mem::transmute(newdescriptor),
1837 ::std::mem::transmute(objecttype),
1838 iscontainerobject.into_param().abi(),
1839 ::std::mem::transmute(autoinheritflags),
1840 token.into_param().abi(),
1841 ::std::mem::transmute(genericmapping),
1842 ))
1843 }
1844 #[cfg(not(windows))]
1845 unimplemented!("Unsupported target OS");
1846 }
1847 #[cfg(feature = "Win32_Foundation")]
1848 #[inline]
CreatePrivateObjectSecurityWithMultipleInheritance<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>( parentdescriptor: *const SECURITY_DESCRIPTOR, creatordescriptor: *const SECURITY_DESCRIPTOR, newdescriptor: *mut *mut SECURITY_DESCRIPTOR, objecttypes: *const *const ::windows::runtime::GUID, guidcount: u32, iscontainerobject: Param5, autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS, token: Param7, genericmapping: *const GENERIC_MAPPING, ) -> super::Foundation::BOOL1849 pub unsafe fn CreatePrivateObjectSecurityWithMultipleInheritance<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(
1850 parentdescriptor: *const SECURITY_DESCRIPTOR,
1851 creatordescriptor: *const SECURITY_DESCRIPTOR,
1852 newdescriptor: *mut *mut SECURITY_DESCRIPTOR,
1853 objecttypes: *const *const ::windows::runtime::GUID,
1854 guidcount: u32,
1855 iscontainerobject: Param5,
1856 autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS,
1857 token: Param7,
1858 genericmapping: *const GENERIC_MAPPING,
1859 ) -> super::Foundation::BOOL {
1860 #[cfg(windows)]
1861 {
1862 #[link(name = "windows")]
1863 extern "system" {
1864 fn CreatePrivateObjectSecurityWithMultipleInheritance(parentdescriptor: *const SECURITY_DESCRIPTOR, creatordescriptor: *const SECURITY_DESCRIPTOR, newdescriptor: *mut *mut SECURITY_DESCRIPTOR, objecttypes: *const *const ::windows::runtime::GUID, guidcount: u32, iscontainerobject: super::Foundation::BOOL, autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS, token: super::Foundation::HANDLE, genericmapping: *const GENERIC_MAPPING) -> super::Foundation::BOOL;
1865 }
1866 ::std::mem::transmute(CreatePrivateObjectSecurityWithMultipleInheritance(
1867 ::std::mem::transmute(parentdescriptor),
1868 ::std::mem::transmute(creatordescriptor),
1869 ::std::mem::transmute(newdescriptor),
1870 ::std::mem::transmute(objecttypes),
1871 ::std::mem::transmute(guidcount),
1872 iscontainerobject.into_param().abi(),
1873 ::std::mem::transmute(autoinheritflags),
1874 token.into_param().abi(),
1875 ::std::mem::transmute(genericmapping),
1876 ))
1877 }
1878 #[cfg(not(windows))]
1879 unimplemented!("Unsupported target OS");
1880 }
1881 #[cfg(feature = "Win32_Foundation")]
1882 #[inline]
CreateRestrictedToken<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(existingtokenhandle: Param0, flags: CREATE_RESTRICTED_TOKEN_FLAGS, disablesidcount: u32, sidstodisable: *const SID_AND_ATTRIBUTES, deleteprivilegecount: u32, privilegestodelete: *const LUID_AND_ATTRIBUTES, restrictedsidcount: u32, sidstorestrict: *const SID_AND_ATTRIBUTES, newtokenhandle: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL1883 pub unsafe fn CreateRestrictedToken<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(existingtokenhandle: Param0, flags: CREATE_RESTRICTED_TOKEN_FLAGS, disablesidcount: u32, sidstodisable: *const SID_AND_ATTRIBUTES, deleteprivilegecount: u32, privilegestodelete: *const LUID_AND_ATTRIBUTES, restrictedsidcount: u32, sidstorestrict: *const SID_AND_ATTRIBUTES, newtokenhandle: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL {
1884 #[cfg(windows)]
1885 {
1886 #[link(name = "windows")]
1887 extern "system" {
1888 fn CreateRestrictedToken(existingtokenhandle: super::Foundation::HANDLE, flags: CREATE_RESTRICTED_TOKEN_FLAGS, disablesidcount: u32, sidstodisable: *const SID_AND_ATTRIBUTES, deleteprivilegecount: u32, privilegestodelete: *const LUID_AND_ATTRIBUTES, restrictedsidcount: u32, sidstorestrict: *const SID_AND_ATTRIBUTES, newtokenhandle: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL;
1889 }
1890 ::std::mem::transmute(CreateRestrictedToken(
1891 existingtokenhandle.into_param().abi(),
1892 ::std::mem::transmute(flags),
1893 ::std::mem::transmute(disablesidcount),
1894 ::std::mem::transmute(sidstodisable),
1895 ::std::mem::transmute(deleteprivilegecount),
1896 ::std::mem::transmute(privilegestodelete),
1897 ::std::mem::transmute(restrictedsidcount),
1898 ::std::mem::transmute(sidstorestrict),
1899 ::std::mem::transmute(newtokenhandle),
1900 ))
1901 }
1902 #[cfg(not(windows))]
1903 unimplemented!("Unsupported target OS");
1904 }
1905 #[cfg(feature = "Win32_Foundation")]
1906 #[inline]
CreateWellKnownSid<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(wellknownsidtype: WELL_KNOWN_SID_TYPE, domainsid: Param1, psid: super::Foundation::PSID, cbsid: *mut u32) -> super::Foundation::BOOL1907 pub unsafe fn CreateWellKnownSid<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(wellknownsidtype: WELL_KNOWN_SID_TYPE, domainsid: Param1, psid: super::Foundation::PSID, cbsid: *mut u32) -> super::Foundation::BOOL {
1908 #[cfg(windows)]
1909 {
1910 #[link(name = "windows")]
1911 extern "system" {
1912 fn CreateWellKnownSid(wellknownsidtype: WELL_KNOWN_SID_TYPE, domainsid: super::Foundation::PSID, psid: super::Foundation::PSID, cbsid: *mut u32) -> super::Foundation::BOOL;
1913 }
1914 ::std::mem::transmute(CreateWellKnownSid(::std::mem::transmute(wellknownsidtype), domainsid.into_param().abi(), ::std::mem::transmute(psid), ::std::mem::transmute(cbsid)))
1915 }
1916 #[cfg(not(windows))]
1917 unimplemented!("Unsupported target OS");
1918 }
1919 #[cfg(feature = "Win32_Foundation")]
1920 #[inline]
DeleteAce(pacl: *mut ACL, dwaceindex: u32) -> super::Foundation::BOOL1921 pub unsafe fn DeleteAce(pacl: *mut ACL, dwaceindex: u32) -> super::Foundation::BOOL {
1922 #[cfg(windows)]
1923 {
1924 #[link(name = "windows")]
1925 extern "system" {
1926 fn DeleteAce(pacl: *mut ACL, dwaceindex: u32) -> super::Foundation::BOOL;
1927 }
1928 ::std::mem::transmute(DeleteAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwaceindex)))
1929 }
1930 #[cfg(not(windows))]
1931 unimplemented!("Unsupported target OS");
1932 }
1933 #[cfg(feature = "Win32_Foundation")]
1934 #[inline]
DeriveCapabilitySidsFromName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(capname: Param0, capabilitygroupsids: *mut *mut super::Foundation::PSID, capabilitygroupsidcount: *mut u32, capabilitysids: *mut *mut super::Foundation::PSID, capabilitysidcount: *mut u32) -> super::Foundation::BOOL1935 pub unsafe fn DeriveCapabilitySidsFromName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(capname: Param0, capabilitygroupsids: *mut *mut super::Foundation::PSID, capabilitygroupsidcount: *mut u32, capabilitysids: *mut *mut super::Foundation::PSID, capabilitysidcount: *mut u32) -> super::Foundation::BOOL {
1936 #[cfg(windows)]
1937 {
1938 #[link(name = "windows")]
1939 extern "system" {
1940 fn DeriveCapabilitySidsFromName(capname: super::Foundation::PWSTR, capabilitygroupsids: *mut *mut super::Foundation::PSID, capabilitygroupsidcount: *mut u32, capabilitysids: *mut *mut super::Foundation::PSID, capabilitysidcount: *mut u32) -> super::Foundation::BOOL;
1941 }
1942 ::std::mem::transmute(DeriveCapabilitySidsFromName(capname.into_param().abi(), ::std::mem::transmute(capabilitygroupsids), ::std::mem::transmute(capabilitygroupsidcount), ::std::mem::transmute(capabilitysids), ::std::mem::transmute(capabilitysidcount)))
1943 }
1944 #[cfg(not(windows))]
1945 unimplemented!("Unsupported target OS");
1946 }
1947 #[cfg(feature = "Win32_Foundation")]
1948 #[inline]
DestroyPrivateObjectSecurity(objectdescriptor: *const *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL1949 pub unsafe fn DestroyPrivateObjectSecurity(objectdescriptor: *const *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL {
1950 #[cfg(windows)]
1951 {
1952 #[link(name = "windows")]
1953 extern "system" {
1954 fn DestroyPrivateObjectSecurity(objectdescriptor: *const *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL;
1955 }
1956 ::std::mem::transmute(DestroyPrivateObjectSecurity(::std::mem::transmute(objectdescriptor)))
1957 }
1958 #[cfg(not(windows))]
1959 unimplemented!("Unsupported target OS");
1960 }
1961 #[cfg(feature = "Win32_Foundation")]
1962 #[inline]
DuplicateToken<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(existingtokenhandle: Param0, impersonationlevel: SECURITY_IMPERSONATION_LEVEL, duplicatetokenhandle: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL1963 pub unsafe fn DuplicateToken<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(existingtokenhandle: Param0, impersonationlevel: SECURITY_IMPERSONATION_LEVEL, duplicatetokenhandle: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL {
1964 #[cfg(windows)]
1965 {
1966 #[link(name = "windows")]
1967 extern "system" {
1968 fn DuplicateToken(existingtokenhandle: super::Foundation::HANDLE, impersonationlevel: SECURITY_IMPERSONATION_LEVEL, duplicatetokenhandle: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL;
1969 }
1970 ::std::mem::transmute(DuplicateToken(existingtokenhandle.into_param().abi(), ::std::mem::transmute(impersonationlevel), ::std::mem::transmute(duplicatetokenhandle)))
1971 }
1972 #[cfg(not(windows))]
1973 unimplemented!("Unsupported target OS");
1974 }
1975 #[cfg(feature = "Win32_Foundation")]
1976 #[inline]
DuplicateTokenEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(hexistingtoken: Param0, dwdesiredaccess: TOKEN_ACCESS_MASK, lptokenattributes: *const SECURITY_ATTRIBUTES, impersonationlevel: SECURITY_IMPERSONATION_LEVEL, tokentype: TOKEN_TYPE, phnewtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL1977 pub unsafe fn DuplicateTokenEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(hexistingtoken: Param0, dwdesiredaccess: TOKEN_ACCESS_MASK, lptokenattributes: *const SECURITY_ATTRIBUTES, impersonationlevel: SECURITY_IMPERSONATION_LEVEL, tokentype: TOKEN_TYPE, phnewtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL {
1978 #[cfg(windows)]
1979 {
1980 #[link(name = "windows")]
1981 extern "system" {
1982 fn DuplicateTokenEx(hexistingtoken: super::Foundation::HANDLE, dwdesiredaccess: TOKEN_ACCESS_MASK, lptokenattributes: *const SECURITY_ATTRIBUTES, impersonationlevel: SECURITY_IMPERSONATION_LEVEL, tokentype: TOKEN_TYPE, phnewtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL;
1983 }
1984 ::std::mem::transmute(DuplicateTokenEx(hexistingtoken.into_param().abi(), ::std::mem::transmute(dwdesiredaccess), ::std::mem::transmute(lptokenattributes), ::std::mem::transmute(impersonationlevel), ::std::mem::transmute(tokentype), ::std::mem::transmute(phnewtoken)))
1985 }
1986 #[cfg(not(windows))]
1987 unimplemented!("Unsupported target OS");
1988 }
1989 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1990 #[repr(transparent)]
1991 pub struct ENUM_PERIOD(pub i32);
1992 pub const ENUM_PERIOD_INVALID: ENUM_PERIOD = ENUM_PERIOD(-1i32);
1993 pub const ENUM_PERIOD_SECONDS: ENUM_PERIOD = ENUM_PERIOD(0i32);
1994 pub const ENUM_PERIOD_MINUTES: ENUM_PERIOD = ENUM_PERIOD(1i32);
1995 pub const ENUM_PERIOD_HOURS: ENUM_PERIOD = ENUM_PERIOD(2i32);
1996 pub const ENUM_PERIOD_DAYS: ENUM_PERIOD = ENUM_PERIOD(3i32);
1997 pub const ENUM_PERIOD_WEEKS: ENUM_PERIOD = ENUM_PERIOD(4i32);
1998 pub const ENUM_PERIOD_MONTHS: ENUM_PERIOD = ENUM_PERIOD(5i32);
1999 pub const ENUM_PERIOD_YEARS: ENUM_PERIOD = ENUM_PERIOD(6i32);
2000 impl ::std::convert::From<i32> for ENUM_PERIOD {
from(value: i32) -> Self2001 fn from(value: i32) -> Self {
2002 Self(value)
2003 }
2004 }
2005 unsafe impl ::windows::runtime::Abi for ENUM_PERIOD {
2006 type Abi = Self;
2007 type DefaultType = Self;
2008 }
2009 #[cfg(feature = "Win32_Foundation")]
2010 #[inline]
EqualDomainSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid1: Param0, psid2: Param1, pfequal: *mut super::Foundation::BOOL) -> super::Foundation::BOOL2011 pub unsafe fn EqualDomainSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid1: Param0, psid2: Param1, pfequal: *mut super::Foundation::BOOL) -> super::Foundation::BOOL {
2012 #[cfg(windows)]
2013 {
2014 #[link(name = "windows")]
2015 extern "system" {
2016 fn EqualDomainSid(psid1: super::Foundation::PSID, psid2: super::Foundation::PSID, pfequal: *mut super::Foundation::BOOL) -> super::Foundation::BOOL;
2017 }
2018 ::std::mem::transmute(EqualDomainSid(psid1.into_param().abi(), psid2.into_param().abi(), ::std::mem::transmute(pfequal)))
2019 }
2020 #[cfg(not(windows))]
2021 unimplemented!("Unsupported target OS");
2022 }
2023 #[cfg(feature = "Win32_Foundation")]
2024 #[inline]
EqualPrefixSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid1: Param0, psid2: Param1) -> super::Foundation::BOOL2025 pub unsafe fn EqualPrefixSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid1: Param0, psid2: Param1) -> super::Foundation::BOOL {
2026 #[cfg(windows)]
2027 {
2028 #[link(name = "windows")]
2029 extern "system" {
2030 fn EqualPrefixSid(psid1: super::Foundation::PSID, psid2: super::Foundation::PSID) -> super::Foundation::BOOL;
2031 }
2032 ::std::mem::transmute(EqualPrefixSid(psid1.into_param().abi(), psid2.into_param().abi()))
2033 }
2034 #[cfg(not(windows))]
2035 unimplemented!("Unsupported target OS");
2036 }
2037 #[cfg(feature = "Win32_Foundation")]
2038 #[inline]
EqualSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid1: Param0, psid2: Param1) -> super::Foundation::BOOL2039 pub unsafe fn EqualSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid1: Param0, psid2: Param1) -> super::Foundation::BOOL {
2040 #[cfg(windows)]
2041 {
2042 #[link(name = "windows")]
2043 extern "system" {
2044 fn EqualSid(psid1: super::Foundation::PSID, psid2: super::Foundation::PSID) -> super::Foundation::BOOL;
2045 }
2046 ::std::mem::transmute(EqualSid(psid1.into_param().abi(), psid2.into_param().abi()))
2047 }
2048 #[cfg(not(windows))]
2049 unimplemented!("Unsupported target OS");
2050 }
2051 #[cfg(feature = "Win32_Foundation")]
2052 #[inline]
FindFirstFreeAce(pacl: *const ACL, pace: *mut *mut ::std::ffi::c_void) -> super::Foundation::BOOL2053 pub unsafe fn FindFirstFreeAce(pacl: *const ACL, pace: *mut *mut ::std::ffi::c_void) -> super::Foundation::BOOL {
2054 #[cfg(windows)]
2055 {
2056 #[link(name = "windows")]
2057 extern "system" {
2058 fn FindFirstFreeAce(pacl: *const ACL, pace: *mut *mut ::std::ffi::c_void) -> super::Foundation::BOOL;
2059 }
2060 ::std::mem::transmute(FindFirstFreeAce(::std::mem::transmute(pacl), ::std::mem::transmute(pace)))
2061 }
2062 #[cfg(not(windows))]
2063 unimplemented!("Unsupported target OS");
2064 }
2065 #[cfg(feature = "Win32_Foundation")]
2066 #[inline]
FreeSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> *mut ::std::ffi::c_void2067 pub unsafe fn FreeSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> *mut ::std::ffi::c_void {
2068 #[cfg(windows)]
2069 {
2070 #[link(name = "windows")]
2071 extern "system" {
2072 fn FreeSid(psid: super::Foundation::PSID) -> *mut ::std::ffi::c_void;
2073 }
2074 ::std::mem::transmute(FreeSid(psid.into_param().abi()))
2075 }
2076 #[cfg(not(windows))]
2077 unimplemented!("Unsupported target OS");
2078 }
2079 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2080 #[repr(C)]
2081 pub struct GENERIC_MAPPING {
2082 pub GenericRead: u32,
2083 pub GenericWrite: u32,
2084 pub GenericExecute: u32,
2085 pub GenericAll: u32,
2086 }
2087 impl GENERIC_MAPPING {}
2088 impl ::std::default::Default for GENERIC_MAPPING {
default() -> Self2089 fn default() -> Self {
2090 unsafe { ::std::mem::zeroed() }
2091 }
2092 }
2093 impl ::std::fmt::Debug for GENERIC_MAPPING {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2094 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2095 fmt.debug_struct("GENERIC_MAPPING").field("GenericRead", &self.GenericRead).field("GenericWrite", &self.GenericWrite).field("GenericExecute", &self.GenericExecute).field("GenericAll", &self.GenericAll).finish()
2096 }
2097 }
2098 impl ::std::cmp::PartialEq for GENERIC_MAPPING {
eq(&self, other: &Self) -> bool2099 fn eq(&self, other: &Self) -> bool {
2100 self.GenericRead == other.GenericRead && self.GenericWrite == other.GenericWrite && self.GenericExecute == other.GenericExecute && self.GenericAll == other.GenericAll
2101 }
2102 }
2103 impl ::std::cmp::Eq for GENERIC_MAPPING {}
2104 unsafe impl ::windows::runtime::Abi for GENERIC_MAPPING {
2105 type Abi = Self;
2106 type DefaultType = Self;
2107 }
2108 #[cfg(feature = "Win32_Foundation")]
2109 #[inline]
GetAce(pacl: *const ACL, dwaceindex: u32, pace: *mut *mut ::std::ffi::c_void) -> super::Foundation::BOOL2110 pub unsafe fn GetAce(pacl: *const ACL, dwaceindex: u32, pace: *mut *mut ::std::ffi::c_void) -> super::Foundation::BOOL {
2111 #[cfg(windows)]
2112 {
2113 #[link(name = "windows")]
2114 extern "system" {
2115 fn GetAce(pacl: *const ACL, dwaceindex: u32, pace: *mut *mut ::std::ffi::c_void) -> super::Foundation::BOOL;
2116 }
2117 ::std::mem::transmute(GetAce(::std::mem::transmute(pacl), ::std::mem::transmute(dwaceindex), ::std::mem::transmute(pace)))
2118 }
2119 #[cfg(not(windows))]
2120 unimplemented!("Unsupported target OS");
2121 }
2122 #[cfg(feature = "Win32_Foundation")]
2123 #[inline]
GetAclInformation(pacl: *const ACL, paclinformation: *mut ::std::ffi::c_void, naclinformationlength: u32, dwaclinformationclass: ACL_INFORMATION_CLASS) -> super::Foundation::BOOL2124 pub unsafe fn GetAclInformation(pacl: *const ACL, paclinformation: *mut ::std::ffi::c_void, naclinformationlength: u32, dwaclinformationclass: ACL_INFORMATION_CLASS) -> super::Foundation::BOOL {
2125 #[cfg(windows)]
2126 {
2127 #[link(name = "windows")]
2128 extern "system" {
2129 fn GetAclInformation(pacl: *const ACL, paclinformation: *mut ::std::ffi::c_void, naclinformationlength: u32, dwaclinformationclass: ACL_INFORMATION_CLASS) -> super::Foundation::BOOL;
2130 }
2131 ::std::mem::transmute(GetAclInformation(::std::mem::transmute(pacl), ::std::mem::transmute(paclinformation), ::std::mem::transmute(naclinformationlength), ::std::mem::transmute(dwaclinformationclass)))
2132 }
2133 #[cfg(not(windows))]
2134 unimplemented!("Unsupported target OS");
2135 }
2136 #[cfg(feature = "Win32_Foundation")]
2137 #[inline]
GetAppContainerAce(acl: *const ACL, startingaceindex: u32, appcontainerace: *mut *mut ::std::ffi::c_void, appcontaineraceindex: *mut u32) -> super::Foundation::BOOL2138 pub unsafe fn GetAppContainerAce(acl: *const ACL, startingaceindex: u32, appcontainerace: *mut *mut ::std::ffi::c_void, appcontaineraceindex: *mut u32) -> super::Foundation::BOOL {
2139 #[cfg(windows)]
2140 {
2141 #[link(name = "windows")]
2142 extern "system" {
2143 fn GetAppContainerAce(acl: *const ACL, startingaceindex: u32, appcontainerace: *mut *mut ::std::ffi::c_void, appcontaineraceindex: *mut u32) -> super::Foundation::BOOL;
2144 }
2145 ::std::mem::transmute(GetAppContainerAce(::std::mem::transmute(acl), ::std::mem::transmute(startingaceindex), ::std::mem::transmute(appcontainerace), ::std::mem::transmute(appcontaineraceindex)))
2146 }
2147 #[cfg(not(windows))]
2148 unimplemented!("Unsupported target OS");
2149 }
2150 #[cfg(feature = "Win32_Foundation")]
2151 #[inline]
GetCachedSigningLevel<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(file: Param0, flags: *mut u32, signinglevel: *mut u32, thumbprint: *mut u8, thumbprintsize: *mut u32, thumbprintalgorithm: *mut u32) -> super::Foundation::BOOL2152 pub unsafe fn GetCachedSigningLevel<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(file: Param0, flags: *mut u32, signinglevel: *mut u32, thumbprint: *mut u8, thumbprintsize: *mut u32, thumbprintalgorithm: *mut u32) -> super::Foundation::BOOL {
2153 #[cfg(windows)]
2154 {
2155 #[link(name = "windows")]
2156 extern "system" {
2157 fn GetCachedSigningLevel(file: super::Foundation::HANDLE, flags: *mut u32, signinglevel: *mut u32, thumbprint: *mut u8, thumbprintsize: *mut u32, thumbprintalgorithm: *mut u32) -> super::Foundation::BOOL;
2158 }
2159 ::std::mem::transmute(GetCachedSigningLevel(file.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(signinglevel), ::std::mem::transmute(thumbprint), ::std::mem::transmute(thumbprintsize), ::std::mem::transmute(thumbprintalgorithm)))
2160 }
2161 #[cfg(not(windows))]
2162 unimplemented!("Unsupported target OS");
2163 }
2164 #[cfg(feature = "Win32_Foundation")]
2165 #[inline]
GetFileSecurityA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpfilename: Param0, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL2166 pub unsafe fn GetFileSecurityA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpfilename: Param0, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL {
2167 #[cfg(windows)]
2168 {
2169 #[link(name = "windows")]
2170 extern "system" {
2171 fn GetFileSecurityA(lpfilename: super::Foundation::PSTR, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL;
2172 }
2173 ::std::mem::transmute(GetFileSecurityA(lpfilename.into_param().abi(), ::std::mem::transmute(requestedinformation), ::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnlengthneeded)))
2174 }
2175 #[cfg(not(windows))]
2176 unimplemented!("Unsupported target OS");
2177 }
2178 #[cfg(feature = "Win32_Foundation")]
2179 #[inline]
GetFileSecurityW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpfilename: Param0, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL2180 pub unsafe fn GetFileSecurityW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpfilename: Param0, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL {
2181 #[cfg(windows)]
2182 {
2183 #[link(name = "windows")]
2184 extern "system" {
2185 fn GetFileSecurityW(lpfilename: super::Foundation::PWSTR, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL;
2186 }
2187 ::std::mem::transmute(GetFileSecurityW(lpfilename.into_param().abi(), ::std::mem::transmute(requestedinformation), ::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnlengthneeded)))
2188 }
2189 #[cfg(not(windows))]
2190 unimplemented!("Unsupported target OS");
2191 }
2192 #[cfg(feature = "Win32_Foundation")]
2193 #[inline]
GetKernelObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(handle: Param0, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL2194 pub unsafe fn GetKernelObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(handle: Param0, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL {
2195 #[cfg(windows)]
2196 {
2197 #[link(name = "windows")]
2198 extern "system" {
2199 fn GetKernelObjectSecurity(handle: super::Foundation::HANDLE, requestedinformation: u32, psecuritydescriptor: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL;
2200 }
2201 ::std::mem::transmute(GetKernelObjectSecurity(handle.into_param().abi(), ::std::mem::transmute(requestedinformation), ::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnlengthneeded)))
2202 }
2203 #[cfg(not(windows))]
2204 unimplemented!("Unsupported target OS");
2205 }
2206 #[cfg(feature = "Win32_Foundation")]
2207 #[inline]
GetLengthSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> u322208 pub unsafe fn GetLengthSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> u32 {
2209 #[cfg(windows)]
2210 {
2211 #[link(name = "windows")]
2212 extern "system" {
2213 fn GetLengthSid(psid: super::Foundation::PSID) -> u32;
2214 }
2215 ::std::mem::transmute(GetLengthSid(psid.into_param().abi()))
2216 }
2217 #[cfg(not(windows))]
2218 unimplemented!("Unsupported target OS");
2219 }
2220 #[cfg(feature = "Win32_Foundation")]
2221 #[inline]
GetPrivateObjectSecurity(objectdescriptor: *const SECURITY_DESCRIPTOR, securityinformation: u32, resultantdescriptor: *mut SECURITY_DESCRIPTOR, descriptorlength: u32, returnlength: *mut u32) -> super::Foundation::BOOL2222 pub unsafe fn GetPrivateObjectSecurity(objectdescriptor: *const SECURITY_DESCRIPTOR, securityinformation: u32, resultantdescriptor: *mut SECURITY_DESCRIPTOR, descriptorlength: u32, returnlength: *mut u32) -> super::Foundation::BOOL {
2223 #[cfg(windows)]
2224 {
2225 #[link(name = "windows")]
2226 extern "system" {
2227 fn GetPrivateObjectSecurity(objectdescriptor: *const SECURITY_DESCRIPTOR, securityinformation: u32, resultantdescriptor: *mut SECURITY_DESCRIPTOR, descriptorlength: u32, returnlength: *mut u32) -> super::Foundation::BOOL;
2228 }
2229 ::std::mem::transmute(GetPrivateObjectSecurity(::std::mem::transmute(objectdescriptor), ::std::mem::transmute(securityinformation), ::std::mem::transmute(resultantdescriptor), ::std::mem::transmute(descriptorlength), ::std::mem::transmute(returnlength)))
2230 }
2231 #[cfg(not(windows))]
2232 unimplemented!("Unsupported target OS");
2233 }
2234 #[cfg(feature = "Win32_Foundation")]
2235 #[inline]
GetSecurityDescriptorControl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, pcontrol: *mut u16, lpdwrevision: *mut u32) -> super::Foundation::BOOL2236 pub unsafe fn GetSecurityDescriptorControl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, pcontrol: *mut u16, lpdwrevision: *mut u32) -> super::Foundation::BOOL {
2237 #[cfg(windows)]
2238 {
2239 #[link(name = "windows")]
2240 extern "system" {
2241 fn GetSecurityDescriptorControl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, pcontrol: *mut u16, lpdwrevision: *mut u32) -> super::Foundation::BOOL;
2242 }
2243 ::std::mem::transmute(GetSecurityDescriptorControl(::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(pcontrol), ::std::mem::transmute(lpdwrevision)))
2244 }
2245 #[cfg(not(windows))]
2246 unimplemented!("Unsupported target OS");
2247 }
2248 #[cfg(feature = "Win32_Foundation")]
2249 #[inline]
GetSecurityDescriptorDacl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, lpbdaclpresent: *mut i32, pdacl: *mut *mut ACL, lpbdacldefaulted: *mut i32) -> super::Foundation::BOOL2250 pub unsafe fn GetSecurityDescriptorDacl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, lpbdaclpresent: *mut i32, pdacl: *mut *mut ACL, lpbdacldefaulted: *mut i32) -> super::Foundation::BOOL {
2251 #[cfg(windows)]
2252 {
2253 #[link(name = "windows")]
2254 extern "system" {
2255 fn GetSecurityDescriptorDacl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, lpbdaclpresent: *mut i32, pdacl: *mut *mut ACL, lpbdacldefaulted: *mut i32) -> super::Foundation::BOOL;
2256 }
2257 ::std::mem::transmute(GetSecurityDescriptorDacl(::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(lpbdaclpresent), ::std::mem::transmute(pdacl), ::std::mem::transmute(lpbdacldefaulted)))
2258 }
2259 #[cfg(not(windows))]
2260 unimplemented!("Unsupported target OS");
2261 }
2262 #[cfg(feature = "Win32_Foundation")]
2263 #[inline]
GetSecurityDescriptorGroup(psecuritydescriptor: *const SECURITY_DESCRIPTOR, pgroup: *mut super::Foundation::PSID, lpbgroupdefaulted: *mut i32) -> super::Foundation::BOOL2264 pub unsafe fn GetSecurityDescriptorGroup(psecuritydescriptor: *const SECURITY_DESCRIPTOR, pgroup: *mut super::Foundation::PSID, lpbgroupdefaulted: *mut i32) -> super::Foundation::BOOL {
2265 #[cfg(windows)]
2266 {
2267 #[link(name = "windows")]
2268 extern "system" {
2269 fn GetSecurityDescriptorGroup(psecuritydescriptor: *const SECURITY_DESCRIPTOR, pgroup: *mut super::Foundation::PSID, lpbgroupdefaulted: *mut i32) -> super::Foundation::BOOL;
2270 }
2271 ::std::mem::transmute(GetSecurityDescriptorGroup(::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(pgroup), ::std::mem::transmute(lpbgroupdefaulted)))
2272 }
2273 #[cfg(not(windows))]
2274 unimplemented!("Unsupported target OS");
2275 }
2276 #[cfg(feature = "Win32_Foundation")]
2277 #[inline]
GetSecurityDescriptorLength(psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> u322278 pub unsafe fn GetSecurityDescriptorLength(psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> u32 {
2279 #[cfg(windows)]
2280 {
2281 #[link(name = "windows")]
2282 extern "system" {
2283 fn GetSecurityDescriptorLength(psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> u32;
2284 }
2285 ::std::mem::transmute(GetSecurityDescriptorLength(::std::mem::transmute(psecuritydescriptor)))
2286 }
2287 #[cfg(not(windows))]
2288 unimplemented!("Unsupported target OS");
2289 }
2290 #[cfg(feature = "Win32_Foundation")]
2291 #[inline]
GetSecurityDescriptorOwner(psecuritydescriptor: *const SECURITY_DESCRIPTOR, powner: *mut super::Foundation::PSID, lpbownerdefaulted: *mut i32) -> super::Foundation::BOOL2292 pub unsafe fn GetSecurityDescriptorOwner(psecuritydescriptor: *const SECURITY_DESCRIPTOR, powner: *mut super::Foundation::PSID, lpbownerdefaulted: *mut i32) -> super::Foundation::BOOL {
2293 #[cfg(windows)]
2294 {
2295 #[link(name = "windows")]
2296 extern "system" {
2297 fn GetSecurityDescriptorOwner(psecuritydescriptor: *const SECURITY_DESCRIPTOR, powner: *mut super::Foundation::PSID, lpbownerdefaulted: *mut i32) -> super::Foundation::BOOL;
2298 }
2299 ::std::mem::transmute(GetSecurityDescriptorOwner(::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(powner), ::std::mem::transmute(lpbownerdefaulted)))
2300 }
2301 #[cfg(not(windows))]
2302 unimplemented!("Unsupported target OS");
2303 }
2304 #[cfg(feature = "Win32_Foundation")]
2305 #[inline]
GetSecurityDescriptorRMControl(securitydescriptor: *const SECURITY_DESCRIPTOR, rmcontrol: *mut u8) -> u322306 pub unsafe fn GetSecurityDescriptorRMControl(securitydescriptor: *const SECURITY_DESCRIPTOR, rmcontrol: *mut u8) -> u32 {
2307 #[cfg(windows)]
2308 {
2309 #[link(name = "windows")]
2310 extern "system" {
2311 fn GetSecurityDescriptorRMControl(securitydescriptor: *const SECURITY_DESCRIPTOR, rmcontrol: *mut u8) -> u32;
2312 }
2313 ::std::mem::transmute(GetSecurityDescriptorRMControl(::std::mem::transmute(securitydescriptor), ::std::mem::transmute(rmcontrol)))
2314 }
2315 #[cfg(not(windows))]
2316 unimplemented!("Unsupported target OS");
2317 }
2318 #[cfg(feature = "Win32_Foundation")]
2319 #[inline]
GetSecurityDescriptorSacl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, lpbsaclpresent: *mut i32, psacl: *mut *mut ACL, lpbsacldefaulted: *mut i32) -> super::Foundation::BOOL2320 pub unsafe fn GetSecurityDescriptorSacl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, lpbsaclpresent: *mut i32, psacl: *mut *mut ACL, lpbsacldefaulted: *mut i32) -> super::Foundation::BOOL {
2321 #[cfg(windows)]
2322 {
2323 #[link(name = "windows")]
2324 extern "system" {
2325 fn GetSecurityDescriptorSacl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, lpbsaclpresent: *mut i32, psacl: *mut *mut ACL, lpbsacldefaulted: *mut i32) -> super::Foundation::BOOL;
2326 }
2327 ::std::mem::transmute(GetSecurityDescriptorSacl(::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(lpbsaclpresent), ::std::mem::transmute(psacl), ::std::mem::transmute(lpbsacldefaulted)))
2328 }
2329 #[cfg(not(windows))]
2330 unimplemented!("Unsupported target OS");
2331 }
2332 #[cfg(feature = "Win32_Foundation")]
2333 #[inline]
GetSidIdentifierAuthority<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> *mut SID_IDENTIFIER_AUTHORITY2334 pub unsafe fn GetSidIdentifierAuthority<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> *mut SID_IDENTIFIER_AUTHORITY {
2335 #[cfg(windows)]
2336 {
2337 #[link(name = "windows")]
2338 extern "system" {
2339 fn GetSidIdentifierAuthority(psid: super::Foundation::PSID) -> *mut SID_IDENTIFIER_AUTHORITY;
2340 }
2341 ::std::mem::transmute(GetSidIdentifierAuthority(psid.into_param().abi()))
2342 }
2343 #[cfg(not(windows))]
2344 unimplemented!("Unsupported target OS");
2345 }
2346 #[inline]
GetSidLengthRequired(nsubauthoritycount: u8) -> u322347 pub unsafe fn GetSidLengthRequired(nsubauthoritycount: u8) -> u32 {
2348 #[cfg(windows)]
2349 {
2350 #[link(name = "windows")]
2351 extern "system" {
2352 fn GetSidLengthRequired(nsubauthoritycount: u8) -> u32;
2353 }
2354 ::std::mem::transmute(GetSidLengthRequired(::std::mem::transmute(nsubauthoritycount)))
2355 }
2356 #[cfg(not(windows))]
2357 unimplemented!("Unsupported target OS");
2358 }
2359 #[cfg(feature = "Win32_Foundation")]
2360 #[inline]
GetSidSubAuthority<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0, nsubauthority: u32) -> *mut u322361 pub unsafe fn GetSidSubAuthority<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0, nsubauthority: u32) -> *mut u32 {
2362 #[cfg(windows)]
2363 {
2364 #[link(name = "windows")]
2365 extern "system" {
2366 fn GetSidSubAuthority(psid: super::Foundation::PSID, nsubauthority: u32) -> *mut u32;
2367 }
2368 ::std::mem::transmute(GetSidSubAuthority(psid.into_param().abi(), ::std::mem::transmute(nsubauthority)))
2369 }
2370 #[cfg(not(windows))]
2371 unimplemented!("Unsupported target OS");
2372 }
2373 #[cfg(feature = "Win32_Foundation")]
2374 #[inline]
GetSidSubAuthorityCount<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> *mut u82375 pub unsafe fn GetSidSubAuthorityCount<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> *mut u8 {
2376 #[cfg(windows)]
2377 {
2378 #[link(name = "windows")]
2379 extern "system" {
2380 fn GetSidSubAuthorityCount(psid: super::Foundation::PSID) -> *mut u8;
2381 }
2382 ::std::mem::transmute(GetSidSubAuthorityCount(psid.into_param().abi()))
2383 }
2384 #[cfg(not(windows))]
2385 unimplemented!("Unsupported target OS");
2386 }
2387 #[cfg(feature = "Win32_Foundation")]
2388 #[inline]
GetTokenInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(tokenhandle: Param0, tokeninformationclass: TOKEN_INFORMATION_CLASS, tokeninformation: *mut ::std::ffi::c_void, tokeninformationlength: u32, returnlength: *mut u32) -> super::Foundation::BOOL2389 pub unsafe fn GetTokenInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(tokenhandle: Param0, tokeninformationclass: TOKEN_INFORMATION_CLASS, tokeninformation: *mut ::std::ffi::c_void, tokeninformationlength: u32, returnlength: *mut u32) -> super::Foundation::BOOL {
2390 #[cfg(windows)]
2391 {
2392 #[link(name = "windows")]
2393 extern "system" {
2394 fn GetTokenInformation(tokenhandle: super::Foundation::HANDLE, tokeninformationclass: TOKEN_INFORMATION_CLASS, tokeninformation: *mut ::std::ffi::c_void, tokeninformationlength: u32, returnlength: *mut u32) -> super::Foundation::BOOL;
2395 }
2396 ::std::mem::transmute(GetTokenInformation(tokenhandle.into_param().abi(), ::std::mem::transmute(tokeninformationclass), ::std::mem::transmute(tokeninformation), ::std::mem::transmute(tokeninformationlength), ::std::mem::transmute(returnlength)))
2397 }
2398 #[cfg(not(windows))]
2399 unimplemented!("Unsupported target OS");
2400 }
2401 #[cfg(feature = "Win32_Foundation")]
2402 #[inline]
GetUserObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(hobj: Param0, psirequested: *const u32, psid: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL2403 pub unsafe fn GetUserObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(hobj: Param0, psirequested: *const u32, psid: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL {
2404 #[cfg(windows)]
2405 {
2406 #[link(name = "windows")]
2407 extern "system" {
2408 fn GetUserObjectSecurity(hobj: super::Foundation::HANDLE, psirequested: *const u32, psid: *mut SECURITY_DESCRIPTOR, nlength: u32, lpnlengthneeded: *mut u32) -> super::Foundation::BOOL;
2409 }
2410 ::std::mem::transmute(GetUserObjectSecurity(hobj.into_param().abi(), ::std::mem::transmute(psirequested), ::std::mem::transmute(psid), ::std::mem::transmute(nlength), ::std::mem::transmute(lpnlengthneeded)))
2411 }
2412 #[cfg(not(windows))]
2413 unimplemented!("Unsupported target OS");
2414 }
2415 #[cfg(feature = "Win32_Foundation")]
2416 #[inline]
GetWindowsAccountDomainSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0, pdomainsid: super::Foundation::PSID, cbdomainsid: *mut u32) -> super::Foundation::BOOL2417 pub unsafe fn GetWindowsAccountDomainSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0, pdomainsid: super::Foundation::PSID, cbdomainsid: *mut u32) -> super::Foundation::BOOL {
2418 #[cfg(windows)]
2419 {
2420 #[link(name = "windows")]
2421 extern "system" {
2422 fn GetWindowsAccountDomainSid(psid: super::Foundation::PSID, pdomainsid: super::Foundation::PSID, cbdomainsid: *mut u32) -> super::Foundation::BOOL;
2423 }
2424 ::std::mem::transmute(GetWindowsAccountDomainSid(psid.into_param().abi(), ::std::mem::transmute(pdomainsid), ::std::mem::transmute(cbdomainsid)))
2425 }
2426 #[cfg(not(windows))]
2427 unimplemented!("Unsupported target OS");
2428 }
2429 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2430 #[repr(transparent)]
2431 pub struct HDIAGNOSTIC_DATA_QUERY_SESSION(pub isize);
2432 impl ::std::default::Default for HDIAGNOSTIC_DATA_QUERY_SESSION {
default() -> Self2433 fn default() -> Self {
2434 unsafe { ::std::mem::zeroed() }
2435 }
2436 }
2437 unsafe impl ::windows::runtime::Handle for HDIAGNOSTIC_DATA_QUERY_SESSION {}
2438 unsafe impl ::windows::runtime::Abi for HDIAGNOSTIC_DATA_QUERY_SESSION {
2439 type Abi = Self;
2440 type DefaultType = Self;
2441 }
2442 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2443 #[repr(transparent)]
2444 pub struct HDIAGNOSTIC_EVENT_CATEGORY_DESCRIPTION(pub isize);
2445 impl ::std::default::Default for HDIAGNOSTIC_EVENT_CATEGORY_DESCRIPTION {
default() -> Self2446 fn default() -> Self {
2447 unsafe { ::std::mem::zeroed() }
2448 }
2449 }
2450 unsafe impl ::windows::runtime::Handle for HDIAGNOSTIC_EVENT_CATEGORY_DESCRIPTION {}
2451 unsafe impl ::windows::runtime::Abi for HDIAGNOSTIC_EVENT_CATEGORY_DESCRIPTION {
2452 type Abi = Self;
2453 type DefaultType = Self;
2454 }
2455 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2456 #[repr(transparent)]
2457 pub struct HDIAGNOSTIC_EVENT_PRODUCER_DESCRIPTION(pub isize);
2458 impl ::std::default::Default for HDIAGNOSTIC_EVENT_PRODUCER_DESCRIPTION {
default() -> Self2459 fn default() -> Self {
2460 unsafe { ::std::mem::zeroed() }
2461 }
2462 }
2463 unsafe impl ::windows::runtime::Handle for HDIAGNOSTIC_EVENT_PRODUCER_DESCRIPTION {}
2464 unsafe impl ::windows::runtime::Abi for HDIAGNOSTIC_EVENT_PRODUCER_DESCRIPTION {
2465 type Abi = Self;
2466 type DefaultType = Self;
2467 }
2468 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2469 #[repr(transparent)]
2470 pub struct HDIAGNOSTIC_EVENT_TAG_DESCRIPTION(pub isize);
2471 impl ::std::default::Default for HDIAGNOSTIC_EVENT_TAG_DESCRIPTION {
default() -> Self2472 fn default() -> Self {
2473 unsafe { ::std::mem::zeroed() }
2474 }
2475 }
2476 unsafe impl ::windows::runtime::Handle for HDIAGNOSTIC_EVENT_TAG_DESCRIPTION {}
2477 unsafe impl ::windows::runtime::Abi for HDIAGNOSTIC_EVENT_TAG_DESCRIPTION {
2478 type Abi = Self;
2479 type DefaultType = Self;
2480 }
2481 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2482 #[repr(transparent)]
2483 pub struct HDIAGNOSTIC_RECORD(pub isize);
2484 impl ::std::default::Default for HDIAGNOSTIC_RECORD {
default() -> Self2485 fn default() -> Self {
2486 unsafe { ::std::mem::zeroed() }
2487 }
2488 }
2489 unsafe impl ::windows::runtime::Handle for HDIAGNOSTIC_RECORD {}
2490 unsafe impl ::windows::runtime::Abi for HDIAGNOSTIC_RECORD {
2491 type Abi = Self;
2492 type DefaultType = Self;
2493 }
2494 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2495 #[repr(transparent)]
2496 pub struct HDIAGNOSTIC_REPORT(pub isize);
2497 impl ::std::default::Default for HDIAGNOSTIC_REPORT {
default() -> Self2498 fn default() -> Self {
2499 unsafe { ::std::mem::zeroed() }
2500 }
2501 }
2502 unsafe impl ::windows::runtime::Handle for HDIAGNOSTIC_REPORT {}
2503 unsafe impl ::windows::runtime::Abi for HDIAGNOSTIC_REPORT {
2504 type Abi = Self;
2505 type DefaultType = Self;
2506 }
2507 #[cfg(feature = "Win32_Foundation")]
2508 #[inline]
ImpersonateAnonymousToken<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(threadhandle: Param0) -> super::Foundation::BOOL2509 pub unsafe fn ImpersonateAnonymousToken<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(threadhandle: Param0) -> super::Foundation::BOOL {
2510 #[cfg(windows)]
2511 {
2512 #[link(name = "windows")]
2513 extern "system" {
2514 fn ImpersonateAnonymousToken(threadhandle: super::Foundation::HANDLE) -> super::Foundation::BOOL;
2515 }
2516 ::std::mem::transmute(ImpersonateAnonymousToken(threadhandle.into_param().abi()))
2517 }
2518 #[cfg(not(windows))]
2519 unimplemented!("Unsupported target OS");
2520 }
2521 #[cfg(feature = "Win32_Foundation")]
2522 #[inline]
ImpersonateLoggedOnUser<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(htoken: Param0) -> super::Foundation::BOOL2523 pub unsafe fn ImpersonateLoggedOnUser<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(htoken: Param0) -> super::Foundation::BOOL {
2524 #[cfg(windows)]
2525 {
2526 #[link(name = "windows")]
2527 extern "system" {
2528 fn ImpersonateLoggedOnUser(htoken: super::Foundation::HANDLE) -> super::Foundation::BOOL;
2529 }
2530 ::std::mem::transmute(ImpersonateLoggedOnUser(htoken.into_param().abi()))
2531 }
2532 #[cfg(not(windows))]
2533 unimplemented!("Unsupported target OS");
2534 }
2535 #[cfg(feature = "Win32_Foundation")]
2536 #[inline]
ImpersonateSelf(impersonationlevel: SECURITY_IMPERSONATION_LEVEL) -> super::Foundation::BOOL2537 pub unsafe fn ImpersonateSelf(impersonationlevel: SECURITY_IMPERSONATION_LEVEL) -> super::Foundation::BOOL {
2538 #[cfg(windows)]
2539 {
2540 #[link(name = "windows")]
2541 extern "system" {
2542 fn ImpersonateSelf(impersonationlevel: SECURITY_IMPERSONATION_LEVEL) -> super::Foundation::BOOL;
2543 }
2544 ::std::mem::transmute(ImpersonateSelf(::std::mem::transmute(impersonationlevel)))
2545 }
2546 #[cfg(not(windows))]
2547 unimplemented!("Unsupported target OS");
2548 }
2549 #[cfg(feature = "Win32_Foundation")]
2550 #[inline]
InitializeAcl(pacl: *mut ACL, nacllength: u32, dwaclrevision: u32) -> super::Foundation::BOOL2551 pub unsafe fn InitializeAcl(pacl: *mut ACL, nacllength: u32, dwaclrevision: u32) -> super::Foundation::BOOL {
2552 #[cfg(windows)]
2553 {
2554 #[link(name = "windows")]
2555 extern "system" {
2556 fn InitializeAcl(pacl: *mut ACL, nacllength: u32, dwaclrevision: u32) -> super::Foundation::BOOL;
2557 }
2558 ::std::mem::transmute(InitializeAcl(::std::mem::transmute(pacl), ::std::mem::transmute(nacllength), ::std::mem::transmute(dwaclrevision)))
2559 }
2560 #[cfg(not(windows))]
2561 unimplemented!("Unsupported target OS");
2562 }
2563 #[cfg(feature = "Win32_Foundation")]
2564 #[inline]
InitializeSecurityDescriptor(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, dwrevision: u32) -> super::Foundation::BOOL2565 pub unsafe fn InitializeSecurityDescriptor(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, dwrevision: u32) -> super::Foundation::BOOL {
2566 #[cfg(windows)]
2567 {
2568 #[link(name = "windows")]
2569 extern "system" {
2570 fn InitializeSecurityDescriptor(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, dwrevision: u32) -> super::Foundation::BOOL;
2571 }
2572 ::std::mem::transmute(InitializeSecurityDescriptor(::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(dwrevision)))
2573 }
2574 #[cfg(not(windows))]
2575 unimplemented!("Unsupported target OS");
2576 }
2577 #[cfg(feature = "Win32_Foundation")]
2578 #[inline]
InitializeSid(sid: super::Foundation::PSID, pidentifierauthority: *const SID_IDENTIFIER_AUTHORITY, nsubauthoritycount: u8) -> super::Foundation::BOOL2579 pub unsafe fn InitializeSid(sid: super::Foundation::PSID, pidentifierauthority: *const SID_IDENTIFIER_AUTHORITY, nsubauthoritycount: u8) -> super::Foundation::BOOL {
2580 #[cfg(windows)]
2581 {
2582 #[link(name = "windows")]
2583 extern "system" {
2584 fn InitializeSid(sid: super::Foundation::PSID, pidentifierauthority: *const SID_IDENTIFIER_AUTHORITY, nsubauthoritycount: u8) -> super::Foundation::BOOL;
2585 }
2586 ::std::mem::transmute(InitializeSid(::std::mem::transmute(sid), ::std::mem::transmute(pidentifierauthority), ::std::mem::transmute(nsubauthoritycount)))
2587 }
2588 #[cfg(not(windows))]
2589 unimplemented!("Unsupported target OS");
2590 }
2591 #[cfg(feature = "Win32_Foundation")]
2592 #[inline]
IsTokenRestricted<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(tokenhandle: Param0) -> super::Foundation::BOOL2593 pub unsafe fn IsTokenRestricted<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(tokenhandle: Param0) -> super::Foundation::BOOL {
2594 #[cfg(windows)]
2595 {
2596 #[link(name = "windows")]
2597 extern "system" {
2598 fn IsTokenRestricted(tokenhandle: super::Foundation::HANDLE) -> super::Foundation::BOOL;
2599 }
2600 ::std::mem::transmute(IsTokenRestricted(tokenhandle.into_param().abi()))
2601 }
2602 #[cfg(not(windows))]
2603 unimplemented!("Unsupported target OS");
2604 }
2605 #[cfg(feature = "Win32_Foundation")]
2606 #[inline]
IsValidAcl(pacl: *const ACL) -> super::Foundation::BOOL2607 pub unsafe fn IsValidAcl(pacl: *const ACL) -> super::Foundation::BOOL {
2608 #[cfg(windows)]
2609 {
2610 #[link(name = "windows")]
2611 extern "system" {
2612 fn IsValidAcl(pacl: *const ACL) -> super::Foundation::BOOL;
2613 }
2614 ::std::mem::transmute(IsValidAcl(::std::mem::transmute(pacl)))
2615 }
2616 #[cfg(not(windows))]
2617 unimplemented!("Unsupported target OS");
2618 }
2619 #[cfg(feature = "Win32_Foundation")]
2620 #[inline]
IsValidSecurityDescriptor(psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL2621 pub unsafe fn IsValidSecurityDescriptor(psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL {
2622 #[cfg(windows)]
2623 {
2624 #[link(name = "windows")]
2625 extern "system" {
2626 fn IsValidSecurityDescriptor(psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL;
2627 }
2628 ::std::mem::transmute(IsValidSecurityDescriptor(::std::mem::transmute(psecuritydescriptor)))
2629 }
2630 #[cfg(not(windows))]
2631 unimplemented!("Unsupported target OS");
2632 }
2633 #[cfg(feature = "Win32_Foundation")]
2634 #[inline]
IsValidSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> super::Foundation::BOOL2635 pub unsafe fn IsValidSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0) -> super::Foundation::BOOL {
2636 #[cfg(windows)]
2637 {
2638 #[link(name = "windows")]
2639 extern "system" {
2640 fn IsValidSid(psid: super::Foundation::PSID) -> super::Foundation::BOOL;
2641 }
2642 ::std::mem::transmute(IsValidSid(psid.into_param().abi()))
2643 }
2644 #[cfg(not(windows))]
2645 unimplemented!("Unsupported target OS");
2646 }
2647 #[cfg(feature = "Win32_Foundation")]
2648 #[inline]
IsWellKnownSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0, wellknownsidtype: WELL_KNOWN_SID_TYPE) -> super::Foundation::BOOL2649 pub unsafe fn IsWellKnownSid<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(psid: Param0, wellknownsidtype: WELL_KNOWN_SID_TYPE) -> super::Foundation::BOOL {
2650 #[cfg(windows)]
2651 {
2652 #[link(name = "windows")]
2653 extern "system" {
2654 fn IsWellKnownSid(psid: super::Foundation::PSID, wellknownsidtype: WELL_KNOWN_SID_TYPE) -> super::Foundation::BOOL;
2655 }
2656 ::std::mem::transmute(IsWellKnownSid(psid.into_param().abi(), ::std::mem::transmute(wellknownsidtype)))
2657 }
2658 #[cfg(not(windows))]
2659 unimplemented!("Unsupported target OS");
2660 }
2661 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2662 #[repr(C)]
2663 #[cfg(feature = "Win32_Foundation")]
2664 pub struct LLFILETIME {
2665 pub Anonymous: LLFILETIME_0,
2666 }
2667 #[cfg(feature = "Win32_Foundation")]
2668 impl LLFILETIME {}
2669 #[cfg(feature = "Win32_Foundation")]
2670 impl ::std::default::Default for LLFILETIME {
default() -> Self2671 fn default() -> Self {
2672 unsafe { ::std::mem::zeroed() }
2673 }
2674 }
2675 #[cfg(feature = "Win32_Foundation")]
2676 impl ::std::cmp::PartialEq for LLFILETIME {
eq(&self, _other: &Self) -> bool2677 fn eq(&self, _other: &Self) -> bool {
2678 unimplemented!()
2679 }
2680 }
2681 #[cfg(feature = "Win32_Foundation")]
2682 impl ::std::cmp::Eq for LLFILETIME {}
2683 #[cfg(feature = "Win32_Foundation")]
2684 unsafe impl ::windows::runtime::Abi for LLFILETIME {
2685 type Abi = Self;
2686 type DefaultType = Self;
2687 }
2688 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2689 #[repr(C)]
2690 #[cfg(feature = "Win32_Foundation")]
2691 pub union LLFILETIME_0 {
2692 pub ll: i64,
2693 pub ft: super::Foundation::FILETIME,
2694 }
2695 #[cfg(feature = "Win32_Foundation")]
2696 impl LLFILETIME_0 {}
2697 #[cfg(feature = "Win32_Foundation")]
2698 impl ::std::default::Default for LLFILETIME_0 {
default() -> Self2699 fn default() -> Self {
2700 unsafe { ::std::mem::zeroed() }
2701 }
2702 }
2703 #[cfg(feature = "Win32_Foundation")]
2704 impl ::std::cmp::PartialEq for LLFILETIME_0 {
eq(&self, _other: &Self) -> bool2705 fn eq(&self, _other: &Self) -> bool {
2706 unimplemented!()
2707 }
2708 }
2709 #[cfg(feature = "Win32_Foundation")]
2710 impl ::std::cmp::Eq for LLFILETIME_0 {}
2711 #[cfg(feature = "Win32_Foundation")]
2712 unsafe impl ::windows::runtime::Abi for LLFILETIME_0 {
2713 type Abi = Self;
2714 type DefaultType = Self;
2715 }
2716 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2717 #[repr(transparent)]
2718 pub struct LOGON32_LOGON(pub u32);
2719 pub const LOGON32_LOGON_BATCH: LOGON32_LOGON = LOGON32_LOGON(4u32);
2720 pub const LOGON32_LOGON_INTERACTIVE: LOGON32_LOGON = LOGON32_LOGON(2u32);
2721 pub const LOGON32_LOGON_NETWORK: LOGON32_LOGON = LOGON32_LOGON(3u32);
2722 pub const LOGON32_LOGON_NETWORK_CLEARTEXT: LOGON32_LOGON = LOGON32_LOGON(8u32);
2723 pub const LOGON32_LOGON_NEW_CREDENTIALS: LOGON32_LOGON = LOGON32_LOGON(9u32);
2724 pub const LOGON32_LOGON_SERVICE: LOGON32_LOGON = LOGON32_LOGON(5u32);
2725 pub const LOGON32_LOGON_UNLOCK: LOGON32_LOGON = LOGON32_LOGON(7u32);
2726 impl ::std::convert::From<u32> for LOGON32_LOGON {
from(value: u32) -> Self2727 fn from(value: u32) -> Self {
2728 Self(value)
2729 }
2730 }
2731 unsafe impl ::windows::runtime::Abi for LOGON32_LOGON {
2732 type Abi = Self;
2733 type DefaultType = Self;
2734 }
2735 impl ::std::ops::BitOr for LOGON32_LOGON {
2736 type Output = Self;
bitor(self, rhs: Self) -> Self2737 fn bitor(self, rhs: Self) -> Self {
2738 Self(self.0 | rhs.0)
2739 }
2740 }
2741 impl ::std::ops::BitAnd for LOGON32_LOGON {
2742 type Output = Self;
bitand(self, rhs: Self) -> Self2743 fn bitand(self, rhs: Self) -> Self {
2744 Self(self.0 & rhs.0)
2745 }
2746 }
2747 impl ::std::ops::BitOrAssign for LOGON32_LOGON {
bitor_assign(&mut self, rhs: Self)2748 fn bitor_assign(&mut self, rhs: Self) {
2749 self.0.bitor_assign(rhs.0)
2750 }
2751 }
2752 impl ::std::ops::BitAndAssign for LOGON32_LOGON {
bitand_assign(&mut self, rhs: Self)2753 fn bitand_assign(&mut self, rhs: Self) {
2754 self.0.bitand_assign(rhs.0)
2755 }
2756 }
2757 impl ::std::ops::Not for LOGON32_LOGON {
2758 type Output = Self;
not(self) -> Self2759 fn not(self) -> Self {
2760 Self(self.0.not())
2761 }
2762 }
2763 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2764 #[repr(transparent)]
2765 pub struct LOGON32_PROVIDER(pub u32);
2766 pub const LOGON32_PROVIDER_DEFAULT: LOGON32_PROVIDER = LOGON32_PROVIDER(0u32);
2767 pub const LOGON32_PROVIDER_WINNT50: LOGON32_PROVIDER = LOGON32_PROVIDER(3u32);
2768 pub const LOGON32_PROVIDER_WINNT40: LOGON32_PROVIDER = LOGON32_PROVIDER(2u32);
2769 impl ::std::convert::From<u32> for LOGON32_PROVIDER {
from(value: u32) -> Self2770 fn from(value: u32) -> Self {
2771 Self(value)
2772 }
2773 }
2774 unsafe impl ::windows::runtime::Abi for LOGON32_PROVIDER {
2775 type Abi = Self;
2776 type DefaultType = Self;
2777 }
2778 impl ::std::ops::BitOr for LOGON32_PROVIDER {
2779 type Output = Self;
bitor(self, rhs: Self) -> Self2780 fn bitor(self, rhs: Self) -> Self {
2781 Self(self.0 | rhs.0)
2782 }
2783 }
2784 impl ::std::ops::BitAnd for LOGON32_PROVIDER {
2785 type Output = Self;
bitand(self, rhs: Self) -> Self2786 fn bitand(self, rhs: Self) -> Self {
2787 Self(self.0 & rhs.0)
2788 }
2789 }
2790 impl ::std::ops::BitOrAssign for LOGON32_PROVIDER {
bitor_assign(&mut self, rhs: Self)2791 fn bitor_assign(&mut self, rhs: Self) {
2792 self.0.bitor_assign(rhs.0)
2793 }
2794 }
2795 impl ::std::ops::BitAndAssign for LOGON32_PROVIDER {
bitand_assign(&mut self, rhs: Self)2796 fn bitand_assign(&mut self, rhs: Self) {
2797 self.0.bitand_assign(rhs.0)
2798 }
2799 }
2800 impl ::std::ops::Not for LOGON32_PROVIDER {
2801 type Output = Self;
not(self) -> Self2802 fn not(self) -> Self {
2803 Self(self.0.not())
2804 }
2805 }
2806 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2807 #[repr(C)]
2808 #[cfg(feature = "Win32_Foundation")]
2809 pub struct LUID_AND_ATTRIBUTES {
2810 pub Luid: super::Foundation::LUID,
2811 pub Attributes: TOKEN_PRIVILEGES_ATTRIBUTES,
2812 }
2813 #[cfg(feature = "Win32_Foundation")]
2814 impl LUID_AND_ATTRIBUTES {}
2815 #[cfg(feature = "Win32_Foundation")]
2816 impl ::std::default::Default for LUID_AND_ATTRIBUTES {
default() -> Self2817 fn default() -> Self {
2818 unsafe { ::std::mem::zeroed() }
2819 }
2820 }
2821 #[cfg(feature = "Win32_Foundation")]
2822 impl ::std::fmt::Debug for LUID_AND_ATTRIBUTES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2823 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2824 fmt.debug_struct("LUID_AND_ATTRIBUTES").field("Luid", &self.Luid).field("Attributes", &self.Attributes).finish()
2825 }
2826 }
2827 #[cfg(feature = "Win32_Foundation")]
2828 impl ::std::cmp::PartialEq for LUID_AND_ATTRIBUTES {
eq(&self, other: &Self) -> bool2829 fn eq(&self, other: &Self) -> bool {
2830 self.Luid == other.Luid && self.Attributes == other.Attributes
2831 }
2832 }
2833 #[cfg(feature = "Win32_Foundation")]
2834 impl ::std::cmp::Eq for LUID_AND_ATTRIBUTES {}
2835 #[cfg(feature = "Win32_Foundation")]
2836 unsafe impl ::windows::runtime::Abi for LUID_AND_ATTRIBUTES {
2837 type Abi = Self;
2838 type DefaultType = Self;
2839 }
2840 #[cfg(feature = "Win32_Foundation")]
2841 #[inline]
LogonUserA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpszusername: Param0, lpszdomain: Param1, lpszpassword: Param2, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL2842 pub unsafe fn LogonUserA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpszusername: Param0, lpszdomain: Param1, lpszpassword: Param2, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL {
2843 #[cfg(windows)]
2844 {
2845 #[link(name = "windows")]
2846 extern "system" {
2847 fn LogonUserA(lpszusername: super::Foundation::PSTR, lpszdomain: super::Foundation::PSTR, lpszpassword: super::Foundation::PSTR, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL;
2848 }
2849 ::std::mem::transmute(LogonUserA(lpszusername.into_param().abi(), lpszdomain.into_param().abi(), lpszpassword.into_param().abi(), ::std::mem::transmute(dwlogontype), ::std::mem::transmute(dwlogonprovider), ::std::mem::transmute(phtoken)))
2850 }
2851 #[cfg(not(windows))]
2852 unimplemented!("Unsupported target OS");
2853 }
2854 #[cfg(feature = "Win32_Foundation")]
2855 #[inline]
LogonUserExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>( lpszusername: Param0, lpszdomain: Param1, lpszpassword: Param2, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE, pplogonsid: *mut super::Foundation::PSID, ppprofilebuffer: *mut *mut ::std::ffi::c_void, pdwprofilelength: *mut u32, pquotalimits: *mut QUOTA_LIMITS, ) -> super::Foundation::BOOL2856 pub unsafe fn LogonUserExA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(
2857 lpszusername: Param0,
2858 lpszdomain: Param1,
2859 lpszpassword: Param2,
2860 dwlogontype: LOGON32_LOGON,
2861 dwlogonprovider: LOGON32_PROVIDER,
2862 phtoken: *mut super::Foundation::HANDLE,
2863 pplogonsid: *mut super::Foundation::PSID,
2864 ppprofilebuffer: *mut *mut ::std::ffi::c_void,
2865 pdwprofilelength: *mut u32,
2866 pquotalimits: *mut QUOTA_LIMITS,
2867 ) -> super::Foundation::BOOL {
2868 #[cfg(windows)]
2869 {
2870 #[link(name = "windows")]
2871 extern "system" {
2872 fn LogonUserExA(lpszusername: super::Foundation::PSTR, lpszdomain: super::Foundation::PSTR, lpszpassword: super::Foundation::PSTR, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE, pplogonsid: *mut super::Foundation::PSID, ppprofilebuffer: *mut *mut ::std::ffi::c_void, pdwprofilelength: *mut u32, pquotalimits: *mut QUOTA_LIMITS) -> super::Foundation::BOOL;
2873 }
2874 ::std::mem::transmute(LogonUserExA(
2875 lpszusername.into_param().abi(),
2876 lpszdomain.into_param().abi(),
2877 lpszpassword.into_param().abi(),
2878 ::std::mem::transmute(dwlogontype),
2879 ::std::mem::transmute(dwlogonprovider),
2880 ::std::mem::transmute(phtoken),
2881 ::std::mem::transmute(pplogonsid),
2882 ::std::mem::transmute(ppprofilebuffer),
2883 ::std::mem::transmute(pdwprofilelength),
2884 ::std::mem::transmute(pquotalimits),
2885 ))
2886 }
2887 #[cfg(not(windows))]
2888 unimplemented!("Unsupported target OS");
2889 }
2890 #[cfg(feature = "Win32_Foundation")]
2891 #[inline]
LogonUserExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>( lpszusername: Param0, lpszdomain: Param1, lpszpassword: Param2, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE, pplogonsid: *mut super::Foundation::PSID, ppprofilebuffer: *mut *mut ::std::ffi::c_void, pdwprofilelength: *mut u32, pquotalimits: *mut QUOTA_LIMITS, ) -> super::Foundation::BOOL2892 pub unsafe fn LogonUserExW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(
2893 lpszusername: Param0,
2894 lpszdomain: Param1,
2895 lpszpassword: Param2,
2896 dwlogontype: LOGON32_LOGON,
2897 dwlogonprovider: LOGON32_PROVIDER,
2898 phtoken: *mut super::Foundation::HANDLE,
2899 pplogonsid: *mut super::Foundation::PSID,
2900 ppprofilebuffer: *mut *mut ::std::ffi::c_void,
2901 pdwprofilelength: *mut u32,
2902 pquotalimits: *mut QUOTA_LIMITS,
2903 ) -> super::Foundation::BOOL {
2904 #[cfg(windows)]
2905 {
2906 #[link(name = "windows")]
2907 extern "system" {
2908 fn LogonUserExW(lpszusername: super::Foundation::PWSTR, lpszdomain: super::Foundation::PWSTR, lpszpassword: super::Foundation::PWSTR, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE, pplogonsid: *mut super::Foundation::PSID, ppprofilebuffer: *mut *mut ::std::ffi::c_void, pdwprofilelength: *mut u32, pquotalimits: *mut QUOTA_LIMITS) -> super::Foundation::BOOL;
2909 }
2910 ::std::mem::transmute(LogonUserExW(
2911 lpszusername.into_param().abi(),
2912 lpszdomain.into_param().abi(),
2913 lpszpassword.into_param().abi(),
2914 ::std::mem::transmute(dwlogontype),
2915 ::std::mem::transmute(dwlogonprovider),
2916 ::std::mem::transmute(phtoken),
2917 ::std::mem::transmute(pplogonsid),
2918 ::std::mem::transmute(ppprofilebuffer),
2919 ::std::mem::transmute(pdwprofilelength),
2920 ::std::mem::transmute(pquotalimits),
2921 ))
2922 }
2923 #[cfg(not(windows))]
2924 unimplemented!("Unsupported target OS");
2925 }
2926 #[cfg(feature = "Win32_Foundation")]
2927 #[inline]
LogonUserW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpszusername: Param0, lpszdomain: Param1, lpszpassword: Param2, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL2928 pub unsafe fn LogonUserW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpszusername: Param0, lpszdomain: Param1, lpszpassword: Param2, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL {
2929 #[cfg(windows)]
2930 {
2931 #[link(name = "windows")]
2932 extern "system" {
2933 fn LogonUserW(lpszusername: super::Foundation::PWSTR, lpszdomain: super::Foundation::PWSTR, lpszpassword: super::Foundation::PWSTR, dwlogontype: LOGON32_LOGON, dwlogonprovider: LOGON32_PROVIDER, phtoken: *mut super::Foundation::HANDLE) -> super::Foundation::BOOL;
2934 }
2935 ::std::mem::transmute(LogonUserW(lpszusername.into_param().abi(), lpszdomain.into_param().abi(), lpszpassword.into_param().abi(), ::std::mem::transmute(dwlogontype), ::std::mem::transmute(dwlogonprovider), ::std::mem::transmute(phtoken)))
2936 }
2937 #[cfg(not(windows))]
2938 unimplemented!("Unsupported target OS");
2939 }
2940 #[cfg(feature = "Win32_Foundation")]
2941 #[inline]
LookupAccountNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpaccountname: Param1, sid: super::Foundation::PSID, cbsid: *mut u32, referenceddomainname: super::Foundation::PSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL2942 pub unsafe fn LookupAccountNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpaccountname: Param1, sid: super::Foundation::PSID, cbsid: *mut u32, referenceddomainname: super::Foundation::PSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL {
2943 #[cfg(windows)]
2944 {
2945 #[link(name = "windows")]
2946 extern "system" {
2947 fn LookupAccountNameA(lpsystemname: super::Foundation::PSTR, lpaccountname: super::Foundation::PSTR, sid: super::Foundation::PSID, cbsid: *mut u32, referenceddomainname: super::Foundation::PSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL;
2948 }
2949 ::std::mem::transmute(LookupAccountNameA(lpsystemname.into_param().abi(), lpaccountname.into_param().abi(), ::std::mem::transmute(sid), ::std::mem::transmute(cbsid), ::std::mem::transmute(referenceddomainname), ::std::mem::transmute(cchreferenceddomainname), ::std::mem::transmute(peuse)))
2950 }
2951 #[cfg(not(windows))]
2952 unimplemented!("Unsupported target OS");
2953 }
2954 #[cfg(feature = "Win32_Foundation")]
2955 #[inline]
LookupAccountNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpaccountname: Param1, sid: super::Foundation::PSID, cbsid: *mut u32, referenceddomainname: super::Foundation::PWSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL2956 pub unsafe fn LookupAccountNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpaccountname: Param1, sid: super::Foundation::PSID, cbsid: *mut u32, referenceddomainname: super::Foundation::PWSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL {
2957 #[cfg(windows)]
2958 {
2959 #[link(name = "windows")]
2960 extern "system" {
2961 fn LookupAccountNameW(lpsystemname: super::Foundation::PWSTR, lpaccountname: super::Foundation::PWSTR, sid: super::Foundation::PSID, cbsid: *mut u32, referenceddomainname: super::Foundation::PWSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL;
2962 }
2963 ::std::mem::transmute(LookupAccountNameW(lpsystemname.into_param().abi(), lpaccountname.into_param().abi(), ::std::mem::transmute(sid), ::std::mem::transmute(cbsid), ::std::mem::transmute(referenceddomainname), ::std::mem::transmute(cchreferenceddomainname), ::std::mem::transmute(peuse)))
2964 }
2965 #[cfg(not(windows))]
2966 unimplemented!("Unsupported target OS");
2967 }
2968 #[cfg(feature = "Win32_Foundation")]
2969 #[inline]
LookupAccountSidA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(lpsystemname: Param0, sid: Param1, name: super::Foundation::PSTR, cchname: *mut u32, referenceddomainname: super::Foundation::PSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL2970 pub unsafe fn LookupAccountSidA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(lpsystemname: Param0, sid: Param1, name: super::Foundation::PSTR, cchname: *mut u32, referenceddomainname: super::Foundation::PSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL {
2971 #[cfg(windows)]
2972 {
2973 #[link(name = "windows")]
2974 extern "system" {
2975 fn LookupAccountSidA(lpsystemname: super::Foundation::PSTR, sid: super::Foundation::PSID, name: super::Foundation::PSTR, cchname: *mut u32, referenceddomainname: super::Foundation::PSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL;
2976 }
2977 ::std::mem::transmute(LookupAccountSidA(lpsystemname.into_param().abi(), sid.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(cchname), ::std::mem::transmute(referenceddomainname), ::std::mem::transmute(cchreferenceddomainname), ::std::mem::transmute(peuse)))
2978 }
2979 #[cfg(not(windows))]
2980 unimplemented!("Unsupported target OS");
2981 }
2982 #[cfg(feature = "Win32_Foundation")]
2983 #[inline]
LookupAccountSidW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(lpsystemname: Param0, sid: Param1, name: super::Foundation::PWSTR, cchname: *mut u32, referenceddomainname: super::Foundation::PWSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL2984 pub unsafe fn LookupAccountSidW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>>(lpsystemname: Param0, sid: Param1, name: super::Foundation::PWSTR, cchname: *mut u32, referenceddomainname: super::Foundation::PWSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL {
2985 #[cfg(windows)]
2986 {
2987 #[link(name = "windows")]
2988 extern "system" {
2989 fn LookupAccountSidW(lpsystemname: super::Foundation::PWSTR, sid: super::Foundation::PSID, name: super::Foundation::PWSTR, cchname: *mut u32, referenceddomainname: super::Foundation::PWSTR, cchreferenceddomainname: *mut u32, peuse: *mut SID_NAME_USE) -> super::Foundation::BOOL;
2990 }
2991 ::std::mem::transmute(LookupAccountSidW(lpsystemname.into_param().abi(), sid.into_param().abi(), ::std::mem::transmute(name), ::std::mem::transmute(cchname), ::std::mem::transmute(referenceddomainname), ::std::mem::transmute(cchreferenceddomainname), ::std::mem::transmute(peuse)))
2992 }
2993 #[cfg(not(windows))]
2994 unimplemented!("Unsupported target OS");
2995 }
2996 #[cfg(feature = "Win32_Foundation")]
2997 #[inline]
LookupPrivilegeDisplayNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpname: Param1, lpdisplayname: super::Foundation::PSTR, cchdisplayname: *mut u32, lplanguageid: *mut u32) -> super::Foundation::BOOL2998 pub unsafe fn LookupPrivilegeDisplayNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpname: Param1, lpdisplayname: super::Foundation::PSTR, cchdisplayname: *mut u32, lplanguageid: *mut u32) -> super::Foundation::BOOL {
2999 #[cfg(windows)]
3000 {
3001 #[link(name = "windows")]
3002 extern "system" {
3003 fn LookupPrivilegeDisplayNameA(lpsystemname: super::Foundation::PSTR, lpname: super::Foundation::PSTR, lpdisplayname: super::Foundation::PSTR, cchdisplayname: *mut u32, lplanguageid: *mut u32) -> super::Foundation::BOOL;
3004 }
3005 ::std::mem::transmute(LookupPrivilegeDisplayNameA(lpsystemname.into_param().abi(), lpname.into_param().abi(), ::std::mem::transmute(lpdisplayname), ::std::mem::transmute(cchdisplayname), ::std::mem::transmute(lplanguageid)))
3006 }
3007 #[cfg(not(windows))]
3008 unimplemented!("Unsupported target OS");
3009 }
3010 #[cfg(feature = "Win32_Foundation")]
3011 #[inline]
LookupPrivilegeDisplayNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpname: Param1, lpdisplayname: super::Foundation::PWSTR, cchdisplayname: *mut u32, lplanguageid: *mut u32) -> super::Foundation::BOOL3012 pub unsafe fn LookupPrivilegeDisplayNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpname: Param1, lpdisplayname: super::Foundation::PWSTR, cchdisplayname: *mut u32, lplanguageid: *mut u32) -> super::Foundation::BOOL {
3013 #[cfg(windows)]
3014 {
3015 #[link(name = "windows")]
3016 extern "system" {
3017 fn LookupPrivilegeDisplayNameW(lpsystemname: super::Foundation::PWSTR, lpname: super::Foundation::PWSTR, lpdisplayname: super::Foundation::PWSTR, cchdisplayname: *mut u32, lplanguageid: *mut u32) -> super::Foundation::BOOL;
3018 }
3019 ::std::mem::transmute(LookupPrivilegeDisplayNameW(lpsystemname.into_param().abi(), lpname.into_param().abi(), ::std::mem::transmute(lpdisplayname), ::std::mem::transmute(cchdisplayname), ::std::mem::transmute(lplanguageid)))
3020 }
3021 #[cfg(not(windows))]
3022 unimplemented!("Unsupported target OS");
3023 }
3024 #[cfg(feature = "Win32_Foundation")]
3025 #[inline]
LookupPrivilegeNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpluid: *const super::Foundation::LUID, lpname: super::Foundation::PSTR, cchname: *mut u32) -> super::Foundation::BOOL3026 pub unsafe fn LookupPrivilegeNameA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpluid: *const super::Foundation::LUID, lpname: super::Foundation::PSTR, cchname: *mut u32) -> super::Foundation::BOOL {
3027 #[cfg(windows)]
3028 {
3029 #[link(name = "windows")]
3030 extern "system" {
3031 fn LookupPrivilegeNameA(lpsystemname: super::Foundation::PSTR, lpluid: *const super::Foundation::LUID, lpname: super::Foundation::PSTR, cchname: *mut u32) -> super::Foundation::BOOL;
3032 }
3033 ::std::mem::transmute(LookupPrivilegeNameA(lpsystemname.into_param().abi(), ::std::mem::transmute(lpluid), ::std::mem::transmute(lpname), ::std::mem::transmute(cchname)))
3034 }
3035 #[cfg(not(windows))]
3036 unimplemented!("Unsupported target OS");
3037 }
3038 #[cfg(feature = "Win32_Foundation")]
3039 #[inline]
LookupPrivilegeNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpluid: *const super::Foundation::LUID, lpname: super::Foundation::PWSTR, cchname: *mut u32) -> super::Foundation::BOOL3040 pub unsafe fn LookupPrivilegeNameW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpluid: *const super::Foundation::LUID, lpname: super::Foundation::PWSTR, cchname: *mut u32) -> super::Foundation::BOOL {
3041 #[cfg(windows)]
3042 {
3043 #[link(name = "windows")]
3044 extern "system" {
3045 fn LookupPrivilegeNameW(lpsystemname: super::Foundation::PWSTR, lpluid: *const super::Foundation::LUID, lpname: super::Foundation::PWSTR, cchname: *mut u32) -> super::Foundation::BOOL;
3046 }
3047 ::std::mem::transmute(LookupPrivilegeNameW(lpsystemname.into_param().abi(), ::std::mem::transmute(lpluid), ::std::mem::transmute(lpname), ::std::mem::transmute(cchname)))
3048 }
3049 #[cfg(not(windows))]
3050 unimplemented!("Unsupported target OS");
3051 }
3052 #[cfg(feature = "Win32_Foundation")]
3053 #[inline]
LookupPrivilegeValueA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpname: Param1, lpluid: *mut super::Foundation::LUID) -> super::Foundation::BOOL3054 pub unsafe fn LookupPrivilegeValueA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpsystemname: Param0, lpname: Param1, lpluid: *mut super::Foundation::LUID) -> super::Foundation::BOOL {
3055 #[cfg(windows)]
3056 {
3057 #[link(name = "windows")]
3058 extern "system" {
3059 fn LookupPrivilegeValueA(lpsystemname: super::Foundation::PSTR, lpname: super::Foundation::PSTR, lpluid: *mut super::Foundation::LUID) -> super::Foundation::BOOL;
3060 }
3061 ::std::mem::transmute(LookupPrivilegeValueA(lpsystemname.into_param().abi(), lpname.into_param().abi(), ::std::mem::transmute(lpluid)))
3062 }
3063 #[cfg(not(windows))]
3064 unimplemented!("Unsupported target OS");
3065 }
3066 #[cfg(feature = "Win32_Foundation")]
3067 #[inline]
LookupPrivilegeValueW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpname: Param1, lpluid: *mut super::Foundation::LUID) -> super::Foundation::BOOL3068 pub unsafe fn LookupPrivilegeValueW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpsystemname: Param0, lpname: Param1, lpluid: *mut super::Foundation::LUID) -> super::Foundation::BOOL {
3069 #[cfg(windows)]
3070 {
3071 #[link(name = "windows")]
3072 extern "system" {
3073 fn LookupPrivilegeValueW(lpsystemname: super::Foundation::PWSTR, lpname: super::Foundation::PWSTR, lpluid: *mut super::Foundation::LUID) -> super::Foundation::BOOL;
3074 }
3075 ::std::mem::transmute(LookupPrivilegeValueW(lpsystemname.into_param().abi(), lpname.into_param().abi(), ::std::mem::transmute(lpluid)))
3076 }
3077 #[cfg(not(windows))]
3078 unimplemented!("Unsupported target OS");
3079 }
3080 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3081 #[repr(transparent)]
3082 pub struct MANDATORY_LEVEL(pub i32);
3083 pub const MandatoryLevelUntrusted: MANDATORY_LEVEL = MANDATORY_LEVEL(0i32);
3084 pub const MandatoryLevelLow: MANDATORY_LEVEL = MANDATORY_LEVEL(1i32);
3085 pub const MandatoryLevelMedium: MANDATORY_LEVEL = MANDATORY_LEVEL(2i32);
3086 pub const MandatoryLevelHigh: MANDATORY_LEVEL = MANDATORY_LEVEL(3i32);
3087 pub const MandatoryLevelSystem: MANDATORY_LEVEL = MANDATORY_LEVEL(4i32);
3088 pub const MandatoryLevelSecureProcess: MANDATORY_LEVEL = MANDATORY_LEVEL(5i32);
3089 pub const MandatoryLevelCount: MANDATORY_LEVEL = MANDATORY_LEVEL(6i32);
3090 impl ::std::convert::From<i32> for MANDATORY_LEVEL {
from(value: i32) -> Self3091 fn from(value: i32) -> Self {
3092 Self(value)
3093 }
3094 }
3095 unsafe impl ::windows::runtime::Abi for MANDATORY_LEVEL {
3096 type Abi = Self;
3097 type DefaultType = Self;
3098 }
3099 #[cfg(feature = "Win32_Foundation")]
3100 #[inline]
MakeAbsoluteSD(pselfrelativesecuritydescriptor: *const SECURITY_DESCRIPTOR, pabsolutesecuritydescriptor: *mut SECURITY_DESCRIPTOR, lpdwabsolutesecuritydescriptorsize: *mut u32, pdacl: *mut ACL, lpdwdaclsize: *mut u32, psacl: *mut ACL, lpdwsaclsize: *mut u32, powner: super::Foundation::PSID, lpdwownersize: *mut u32, pprimarygroup: super::Foundation::PSID, lpdwprimarygroupsize: *mut u32) -> super::Foundation::BOOL3101 pub unsafe fn MakeAbsoluteSD(pselfrelativesecuritydescriptor: *const SECURITY_DESCRIPTOR, pabsolutesecuritydescriptor: *mut SECURITY_DESCRIPTOR, lpdwabsolutesecuritydescriptorsize: *mut u32, pdacl: *mut ACL, lpdwdaclsize: *mut u32, psacl: *mut ACL, lpdwsaclsize: *mut u32, powner: super::Foundation::PSID, lpdwownersize: *mut u32, pprimarygroup: super::Foundation::PSID, lpdwprimarygroupsize: *mut u32) -> super::Foundation::BOOL {
3102 #[cfg(windows)]
3103 {
3104 #[link(name = "windows")]
3105 extern "system" {
3106 fn MakeAbsoluteSD(pselfrelativesecuritydescriptor: *const SECURITY_DESCRIPTOR, pabsolutesecuritydescriptor: *mut SECURITY_DESCRIPTOR, lpdwabsolutesecuritydescriptorsize: *mut u32, pdacl: *mut ACL, lpdwdaclsize: *mut u32, psacl: *mut ACL, lpdwsaclsize: *mut u32, powner: super::Foundation::PSID, lpdwownersize: *mut u32, pprimarygroup: super::Foundation::PSID, lpdwprimarygroupsize: *mut u32) -> super::Foundation::BOOL;
3107 }
3108 ::std::mem::transmute(MakeAbsoluteSD(
3109 ::std::mem::transmute(pselfrelativesecuritydescriptor),
3110 ::std::mem::transmute(pabsolutesecuritydescriptor),
3111 ::std::mem::transmute(lpdwabsolutesecuritydescriptorsize),
3112 ::std::mem::transmute(pdacl),
3113 ::std::mem::transmute(lpdwdaclsize),
3114 ::std::mem::transmute(psacl),
3115 ::std::mem::transmute(lpdwsaclsize),
3116 ::std::mem::transmute(powner),
3117 ::std::mem::transmute(lpdwownersize),
3118 ::std::mem::transmute(pprimarygroup),
3119 ::std::mem::transmute(lpdwprimarygroupsize),
3120 ))
3121 }
3122 #[cfg(not(windows))]
3123 unimplemented!("Unsupported target OS");
3124 }
3125 #[cfg(feature = "Win32_Foundation")]
3126 #[inline]
MakeSelfRelativeSD(pabsolutesecuritydescriptor: *const SECURITY_DESCRIPTOR, pselfrelativesecuritydescriptor: *mut SECURITY_DESCRIPTOR, lpdwbufferlength: *mut u32) -> super::Foundation::BOOL3127 pub unsafe fn MakeSelfRelativeSD(pabsolutesecuritydescriptor: *const SECURITY_DESCRIPTOR, pselfrelativesecuritydescriptor: *mut SECURITY_DESCRIPTOR, lpdwbufferlength: *mut u32) -> super::Foundation::BOOL {
3128 #[cfg(windows)]
3129 {
3130 #[link(name = "windows")]
3131 extern "system" {
3132 fn MakeSelfRelativeSD(pabsolutesecuritydescriptor: *const SECURITY_DESCRIPTOR, pselfrelativesecuritydescriptor: *mut SECURITY_DESCRIPTOR, lpdwbufferlength: *mut u32) -> super::Foundation::BOOL;
3133 }
3134 ::std::mem::transmute(MakeSelfRelativeSD(::std::mem::transmute(pabsolutesecuritydescriptor), ::std::mem::transmute(pselfrelativesecuritydescriptor), ::std::mem::transmute(lpdwbufferlength)))
3135 }
3136 #[cfg(not(windows))]
3137 unimplemented!("Unsupported target OS");
3138 }
3139 #[inline]
MapGenericMask(accessmask: *mut u32, genericmapping: *const GENERIC_MAPPING)3140 pub unsafe fn MapGenericMask(accessmask: *mut u32, genericmapping: *const GENERIC_MAPPING) {
3141 #[cfg(windows)]
3142 {
3143 #[link(name = "windows")]
3144 extern "system" {
3145 fn MapGenericMask(accessmask: *mut u32, genericmapping: *const GENERIC_MAPPING);
3146 }
3147 ::std::mem::transmute(MapGenericMask(::std::mem::transmute(accessmask), ::std::mem::transmute(genericmapping)))
3148 }
3149 #[cfg(not(windows))]
3150 unimplemented!("Unsupported target OS");
3151 }
3152 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
3153 #[repr(transparent)]
3154 pub struct NCRYPT_DESCRIPTOR_HANDLE(pub isize);
3155 impl ::std::default::Default for NCRYPT_DESCRIPTOR_HANDLE {
default() -> Self3156 fn default() -> Self {
3157 unsafe { ::std::mem::zeroed() }
3158 }
3159 }
3160 unsafe impl ::windows::runtime::Handle for NCRYPT_DESCRIPTOR_HANDLE {}
3161 unsafe impl ::windows::runtime::Abi for NCRYPT_DESCRIPTOR_HANDLE {
3162 type Abi = Self;
3163 type DefaultType = Self;
3164 }
3165 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
3166 #[repr(transparent)]
3167 pub struct NCRYPT_STREAM_HANDLE(pub isize);
3168 impl ::std::default::Default for NCRYPT_STREAM_HANDLE {
default() -> Self3169 fn default() -> Self {
3170 unsafe { ::std::mem::zeroed() }
3171 }
3172 }
3173 unsafe impl ::windows::runtime::Handle for NCRYPT_STREAM_HANDLE {}
3174 unsafe impl ::windows::runtime::Abi for NCRYPT_STREAM_HANDLE {
3175 type Abi = Self;
3176 type DefaultType = Self;
3177 }
3178 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3179 #[repr(transparent)]
3180 pub struct OBJECT_SECURITY_INFORMATION(pub u32);
3181 pub const ATTRIBUTE_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(32u32);
3182 pub const BACKUP_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(65536u32);
3183 pub const DACL_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(4u32);
3184 pub const GROUP_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(2u32);
3185 pub const LABEL_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(16u32);
3186 pub const OWNER_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(1u32);
3187 pub const PROTECTED_DACL_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(2147483648u32);
3188 pub const PROTECTED_SACL_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(1073741824u32);
3189 pub const SACL_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(8u32);
3190 pub const SCOPE_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(64u32);
3191 pub const UNPROTECTED_DACL_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(536870912u32);
3192 pub const UNPROTECTED_SACL_SECURITY_INFORMATION: OBJECT_SECURITY_INFORMATION = OBJECT_SECURITY_INFORMATION(268435456u32);
3193 impl ::std::convert::From<u32> for OBJECT_SECURITY_INFORMATION {
from(value: u32) -> Self3194 fn from(value: u32) -> Self {
3195 Self(value)
3196 }
3197 }
3198 unsafe impl ::windows::runtime::Abi for OBJECT_SECURITY_INFORMATION {
3199 type Abi = Self;
3200 type DefaultType = Self;
3201 }
3202 impl ::std::ops::BitOr for OBJECT_SECURITY_INFORMATION {
3203 type Output = Self;
bitor(self, rhs: Self) -> Self3204 fn bitor(self, rhs: Self) -> Self {
3205 Self(self.0 | rhs.0)
3206 }
3207 }
3208 impl ::std::ops::BitAnd for OBJECT_SECURITY_INFORMATION {
3209 type Output = Self;
bitand(self, rhs: Self) -> Self3210 fn bitand(self, rhs: Self) -> Self {
3211 Self(self.0 & rhs.0)
3212 }
3213 }
3214 impl ::std::ops::BitOrAssign for OBJECT_SECURITY_INFORMATION {
bitor_assign(&mut self, rhs: Self)3215 fn bitor_assign(&mut self, rhs: Self) {
3216 self.0.bitor_assign(rhs.0)
3217 }
3218 }
3219 impl ::std::ops::BitAndAssign for OBJECT_SECURITY_INFORMATION {
bitand_assign(&mut self, rhs: Self)3220 fn bitand_assign(&mut self, rhs: Self) {
3221 self.0.bitand_assign(rhs.0)
3222 }
3223 }
3224 impl ::std::ops::Not for OBJECT_SECURITY_INFORMATION {
3225 type Output = Self;
not(self) -> Self3226 fn not(self) -> Self {
3227 Self(self.0.not())
3228 }
3229 }
3230 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3231 #[repr(C)]
3232 pub struct OBJECT_TYPE_LIST {
3233 pub Level: u16,
3234 pub Sbz: u16,
3235 pub ObjectType: *mut ::windows::runtime::GUID,
3236 }
3237 impl OBJECT_TYPE_LIST {}
3238 impl ::std::default::Default for OBJECT_TYPE_LIST {
default() -> Self3239 fn default() -> Self {
3240 unsafe { ::std::mem::zeroed() }
3241 }
3242 }
3243 impl ::std::fmt::Debug for OBJECT_TYPE_LIST {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3244 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3245 fmt.debug_struct("OBJECT_TYPE_LIST").field("Level", &self.Level).field("Sbz", &self.Sbz).field("ObjectType", &self.ObjectType).finish()
3246 }
3247 }
3248 impl ::std::cmp::PartialEq for OBJECT_TYPE_LIST {
eq(&self, other: &Self) -> bool3249 fn eq(&self, other: &Self) -> bool {
3250 self.Level == other.Level && self.Sbz == other.Sbz && self.ObjectType == other.ObjectType
3251 }
3252 }
3253 impl ::std::cmp::Eq for OBJECT_TYPE_LIST {}
3254 unsafe impl ::windows::runtime::Abi for OBJECT_TYPE_LIST {
3255 type Abi = Self;
3256 type DefaultType = Self;
3257 }
3258 #[cfg(feature = "Win32_Foundation")]
3259 #[inline]
ObjectCloseAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL3260 pub unsafe fn ObjectCloseAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL {
3261 #[cfg(windows)]
3262 {
3263 #[link(name = "windows")]
3264 extern "system" {
3265 fn ObjectCloseAuditAlarmA(subsystemname: super::Foundation::PSTR, handleid: *const ::std::ffi::c_void, generateonclose: super::Foundation::BOOL) -> super::Foundation::BOOL;
3266 }
3267 ::std::mem::transmute(ObjectCloseAuditAlarmA(subsystemname.into_param().abi(), ::std::mem::transmute(handleid), generateonclose.into_param().abi()))
3268 }
3269 #[cfg(not(windows))]
3270 unimplemented!("Unsupported target OS");
3271 }
3272 #[cfg(feature = "Win32_Foundation")]
3273 #[inline]
ObjectCloseAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL3274 pub unsafe fn ObjectCloseAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL {
3275 #[cfg(windows)]
3276 {
3277 #[link(name = "windows")]
3278 extern "system" {
3279 fn ObjectCloseAuditAlarmW(subsystemname: super::Foundation::PWSTR, handleid: *const ::std::ffi::c_void, generateonclose: super::Foundation::BOOL) -> super::Foundation::BOOL;
3280 }
3281 ::std::mem::transmute(ObjectCloseAuditAlarmW(subsystemname.into_param().abi(), ::std::mem::transmute(handleid), generateonclose.into_param().abi()))
3282 }
3283 #[cfg(not(windows))]
3284 unimplemented!("Unsupported target OS");
3285 }
3286 #[cfg(feature = "Win32_Foundation")]
3287 #[inline]
ObjectDeleteAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL3288 pub unsafe fn ObjectDeleteAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL {
3289 #[cfg(windows)]
3290 {
3291 #[link(name = "windows")]
3292 extern "system" {
3293 fn ObjectDeleteAuditAlarmA(subsystemname: super::Foundation::PSTR, handleid: *const ::std::ffi::c_void, generateonclose: super::Foundation::BOOL) -> super::Foundation::BOOL;
3294 }
3295 ::std::mem::transmute(ObjectDeleteAuditAlarmA(subsystemname.into_param().abi(), ::std::mem::transmute(handleid), generateonclose.into_param().abi()))
3296 }
3297 #[cfg(not(windows))]
3298 unimplemented!("Unsupported target OS");
3299 }
3300 #[cfg(feature = "Win32_Foundation")]
3301 #[inline]
ObjectDeleteAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL3302 pub unsafe fn ObjectDeleteAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, generateonclose: Param2) -> super::Foundation::BOOL {
3303 #[cfg(windows)]
3304 {
3305 #[link(name = "windows")]
3306 extern "system" {
3307 fn ObjectDeleteAuditAlarmW(subsystemname: super::Foundation::PWSTR, handleid: *const ::std::ffi::c_void, generateonclose: super::Foundation::BOOL) -> super::Foundation::BOOL;
3308 }
3309 ::std::mem::transmute(ObjectDeleteAuditAlarmW(subsystemname.into_param().abi(), ::std::mem::transmute(handleid), generateonclose.into_param().abi()))
3310 }
3311 #[cfg(not(windows))]
3312 unimplemented!("Unsupported target OS");
3313 }
3314 #[cfg(feature = "Win32_Foundation")]
3315 #[inline]
ObjectOpenAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param9: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param10: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, psecuritydescriptor: *const SECURITY_DESCRIPTOR, clienttoken: Param5, desiredaccess: u32, grantedaccess: u32, privileges: *const PRIVILEGE_SET, objectcreation: Param9, accessgranted: Param10, generateonclose: *mut i32, ) -> super::Foundation::BOOL3316 pub unsafe fn ObjectOpenAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param9: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param10: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
3317 subsystemname: Param0,
3318 handleid: *const ::std::ffi::c_void,
3319 objecttypename: Param2,
3320 objectname: Param3,
3321 psecuritydescriptor: *const SECURITY_DESCRIPTOR,
3322 clienttoken: Param5,
3323 desiredaccess: u32,
3324 grantedaccess: u32,
3325 privileges: *const PRIVILEGE_SET,
3326 objectcreation: Param9,
3327 accessgranted: Param10,
3328 generateonclose: *mut i32,
3329 ) -> super::Foundation::BOOL {
3330 #[cfg(windows)]
3331 {
3332 #[link(name = "windows")]
3333 extern "system" {
3334 fn ObjectOpenAuditAlarmA(subsystemname: super::Foundation::PSTR, handleid: *const ::std::ffi::c_void, objecttypename: super::Foundation::PSTR, objectname: super::Foundation::PSTR, psecuritydescriptor: *const SECURITY_DESCRIPTOR, clienttoken: super::Foundation::HANDLE, desiredaccess: u32, grantedaccess: u32, privileges: *const PRIVILEGE_SET, objectcreation: super::Foundation::BOOL, accessgranted: super::Foundation::BOOL, generateonclose: *mut i32) -> super::Foundation::BOOL;
3335 }
3336 ::std::mem::transmute(ObjectOpenAuditAlarmA(
3337 subsystemname.into_param().abi(),
3338 ::std::mem::transmute(handleid),
3339 objecttypename.into_param().abi(),
3340 objectname.into_param().abi(),
3341 ::std::mem::transmute(psecuritydescriptor),
3342 clienttoken.into_param().abi(),
3343 ::std::mem::transmute(desiredaccess),
3344 ::std::mem::transmute(grantedaccess),
3345 ::std::mem::transmute(privileges),
3346 objectcreation.into_param().abi(),
3347 accessgranted.into_param().abi(),
3348 ::std::mem::transmute(generateonclose),
3349 ))
3350 }
3351 #[cfg(not(windows))]
3352 unimplemented!("Unsupported target OS");
3353 }
3354 #[cfg(feature = "Win32_Foundation")]
3355 #[inline]
ObjectOpenAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param9: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param10: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>( subsystemname: Param0, handleid: *const ::std::ffi::c_void, objecttypename: Param2, objectname: Param3, psecuritydescriptor: *const SECURITY_DESCRIPTOR, clienttoken: Param5, desiredaccess: u32, grantedaccess: u32, privileges: *const PRIVILEGE_SET, objectcreation: Param9, accessgranted: Param10, generateonclose: *mut i32, ) -> super::Foundation::BOOL3356 pub unsafe fn ObjectOpenAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param9: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param10: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(
3357 subsystemname: Param0,
3358 handleid: *const ::std::ffi::c_void,
3359 objecttypename: Param2,
3360 objectname: Param3,
3361 psecuritydescriptor: *const SECURITY_DESCRIPTOR,
3362 clienttoken: Param5,
3363 desiredaccess: u32,
3364 grantedaccess: u32,
3365 privileges: *const PRIVILEGE_SET,
3366 objectcreation: Param9,
3367 accessgranted: Param10,
3368 generateonclose: *mut i32,
3369 ) -> super::Foundation::BOOL {
3370 #[cfg(windows)]
3371 {
3372 #[link(name = "windows")]
3373 extern "system" {
3374 fn ObjectOpenAuditAlarmW(subsystemname: super::Foundation::PWSTR, handleid: *const ::std::ffi::c_void, objecttypename: super::Foundation::PWSTR, objectname: super::Foundation::PWSTR, psecuritydescriptor: *const SECURITY_DESCRIPTOR, clienttoken: super::Foundation::HANDLE, desiredaccess: u32, grantedaccess: u32, privileges: *const PRIVILEGE_SET, objectcreation: super::Foundation::BOOL, accessgranted: super::Foundation::BOOL, generateonclose: *mut i32) -> super::Foundation::BOOL;
3375 }
3376 ::std::mem::transmute(ObjectOpenAuditAlarmW(
3377 subsystemname.into_param().abi(),
3378 ::std::mem::transmute(handleid),
3379 objecttypename.into_param().abi(),
3380 objectname.into_param().abi(),
3381 ::std::mem::transmute(psecuritydescriptor),
3382 clienttoken.into_param().abi(),
3383 ::std::mem::transmute(desiredaccess),
3384 ::std::mem::transmute(grantedaccess),
3385 ::std::mem::transmute(privileges),
3386 objectcreation.into_param().abi(),
3387 accessgranted.into_param().abi(),
3388 ::std::mem::transmute(generateonclose),
3389 ))
3390 }
3391 #[cfg(not(windows))]
3392 unimplemented!("Unsupported target OS");
3393 }
3394 #[cfg(feature = "Win32_Foundation")]
3395 #[inline]
ObjectPrivilegeAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, clienttoken: Param2, desiredaccess: u32, privileges: *const PRIVILEGE_SET, accessgranted: Param5) -> super::Foundation::BOOL3396 pub unsafe fn ObjectPrivilegeAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, clienttoken: Param2, desiredaccess: u32, privileges: *const PRIVILEGE_SET, accessgranted: Param5) -> super::Foundation::BOOL {
3397 #[cfg(windows)]
3398 {
3399 #[link(name = "windows")]
3400 extern "system" {
3401 fn ObjectPrivilegeAuditAlarmA(subsystemname: super::Foundation::PSTR, handleid: *const ::std::ffi::c_void, clienttoken: super::Foundation::HANDLE, desiredaccess: u32, privileges: *const PRIVILEGE_SET, accessgranted: super::Foundation::BOOL) -> super::Foundation::BOOL;
3402 }
3403 ::std::mem::transmute(ObjectPrivilegeAuditAlarmA(subsystemname.into_param().abi(), ::std::mem::transmute(handleid), clienttoken.into_param().abi(), ::std::mem::transmute(desiredaccess), ::std::mem::transmute(privileges), accessgranted.into_param().abi()))
3404 }
3405 #[cfg(not(windows))]
3406 unimplemented!("Unsupported target OS");
3407 }
3408 #[cfg(feature = "Win32_Foundation")]
3409 #[inline]
ObjectPrivilegeAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, clienttoken: Param2, desiredaccess: u32, privileges: *const PRIVILEGE_SET, accessgranted: Param5) -> super::Foundation::BOOL3410 pub unsafe fn ObjectPrivilegeAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, handleid: *const ::std::ffi::c_void, clienttoken: Param2, desiredaccess: u32, privileges: *const PRIVILEGE_SET, accessgranted: Param5) -> super::Foundation::BOOL {
3411 #[cfg(windows)]
3412 {
3413 #[link(name = "windows")]
3414 extern "system" {
3415 fn ObjectPrivilegeAuditAlarmW(subsystemname: super::Foundation::PWSTR, handleid: *const ::std::ffi::c_void, clienttoken: super::Foundation::HANDLE, desiredaccess: u32, privileges: *const PRIVILEGE_SET, accessgranted: super::Foundation::BOOL) -> super::Foundation::BOOL;
3416 }
3417 ::std::mem::transmute(ObjectPrivilegeAuditAlarmW(subsystemname.into_param().abi(), ::std::mem::transmute(handleid), clienttoken.into_param().abi(), ::std::mem::transmute(desiredaccess), ::std::mem::transmute(privileges), accessgranted.into_param().abi()))
3418 }
3419 #[cfg(not(windows))]
3420 unimplemented!("Unsupported target OS");
3421 }
3422 #[cfg(feature = "Win32_Foundation")]
3423 pub type PLSA_AP_CALL_PACKAGE_UNTRUSTED = unsafe extern "system" fn(clientrequest: *const *const ::std::ffi::c_void, protocolsubmitbuffer: *const ::std::ffi::c_void, clientbufferbase: *const ::std::ffi::c_void, submitbufferlength: u32, protocolreturnbuffer: *mut *mut ::std::ffi::c_void, returnbufferlength: *mut u32, protocolstatus: *mut i32) -> super::Foundation::NTSTATUS;
3424 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3425 #[repr(C)]
3426 #[cfg(feature = "Win32_Foundation")]
3427 pub struct PRIVILEGE_SET {
3428 pub PrivilegeCount: u32,
3429 pub Control: u32,
3430 pub Privilege: [LUID_AND_ATTRIBUTES; 1],
3431 }
3432 #[cfg(feature = "Win32_Foundation")]
3433 impl PRIVILEGE_SET {}
3434 #[cfg(feature = "Win32_Foundation")]
3435 impl ::std::default::Default for PRIVILEGE_SET {
default() -> Self3436 fn default() -> Self {
3437 unsafe { ::std::mem::zeroed() }
3438 }
3439 }
3440 #[cfg(feature = "Win32_Foundation")]
3441 impl ::std::fmt::Debug for PRIVILEGE_SET {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3442 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3443 fmt.debug_struct("PRIVILEGE_SET").field("PrivilegeCount", &self.PrivilegeCount).field("Control", &self.Control).field("Privilege", &self.Privilege).finish()
3444 }
3445 }
3446 #[cfg(feature = "Win32_Foundation")]
3447 impl ::std::cmp::PartialEq for PRIVILEGE_SET {
eq(&self, other: &Self) -> bool3448 fn eq(&self, other: &Self) -> bool {
3449 self.PrivilegeCount == other.PrivilegeCount && self.Control == other.Control && self.Privilege == other.Privilege
3450 }
3451 }
3452 #[cfg(feature = "Win32_Foundation")]
3453 impl ::std::cmp::Eq for PRIVILEGE_SET {}
3454 #[cfg(feature = "Win32_Foundation")]
3455 unsafe impl ::windows::runtime::Abi for PRIVILEGE_SET {
3456 type Abi = Self;
3457 type DefaultType = Self;
3458 }
3459 #[cfg(feature = "Win32_Foundation")]
3460 #[inline]
PrivilegeCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(clienttoken: Param0, requiredprivileges: *mut PRIVILEGE_SET, pfresult: *mut i32) -> super::Foundation::BOOL3461 pub unsafe fn PrivilegeCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(clienttoken: Param0, requiredprivileges: *mut PRIVILEGE_SET, pfresult: *mut i32) -> super::Foundation::BOOL {
3462 #[cfg(windows)]
3463 {
3464 #[link(name = "windows")]
3465 extern "system" {
3466 fn PrivilegeCheck(clienttoken: super::Foundation::HANDLE, requiredprivileges: *mut PRIVILEGE_SET, pfresult: *mut i32) -> super::Foundation::BOOL;
3467 }
3468 ::std::mem::transmute(PrivilegeCheck(clienttoken.into_param().abi(), ::std::mem::transmute(requiredprivileges), ::std::mem::transmute(pfresult)))
3469 }
3470 #[cfg(not(windows))]
3471 unimplemented!("Unsupported target OS");
3472 }
3473 #[cfg(feature = "Win32_Foundation")]
3474 #[inline]
PrivilegedServiceAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, servicename: Param1, clienttoken: Param2, privileges: *const PRIVILEGE_SET, accessgranted: Param4) -> super::Foundation::BOOL3475 pub unsafe fn PrivilegedServiceAuditAlarmA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, servicename: Param1, clienttoken: Param2, privileges: *const PRIVILEGE_SET, accessgranted: Param4) -> super::Foundation::BOOL {
3476 #[cfg(windows)]
3477 {
3478 #[link(name = "windows")]
3479 extern "system" {
3480 fn PrivilegedServiceAuditAlarmA(subsystemname: super::Foundation::PSTR, servicename: super::Foundation::PSTR, clienttoken: super::Foundation::HANDLE, privileges: *const PRIVILEGE_SET, accessgranted: super::Foundation::BOOL) -> super::Foundation::BOOL;
3481 }
3482 ::std::mem::transmute(PrivilegedServiceAuditAlarmA(subsystemname.into_param().abi(), servicename.into_param().abi(), clienttoken.into_param().abi(), ::std::mem::transmute(privileges), accessgranted.into_param().abi()))
3483 }
3484 #[cfg(not(windows))]
3485 unimplemented!("Unsupported target OS");
3486 }
3487 #[cfg(feature = "Win32_Foundation")]
3488 #[inline]
PrivilegedServiceAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, servicename: Param1, clienttoken: Param2, privileges: *const PRIVILEGE_SET, accessgranted: Param4) -> super::Foundation::BOOL3489 pub unsafe fn PrivilegedServiceAuditAlarmW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(subsystemname: Param0, servicename: Param1, clienttoken: Param2, privileges: *const PRIVILEGE_SET, accessgranted: Param4) -> super::Foundation::BOOL {
3490 #[cfg(windows)]
3491 {
3492 #[link(name = "windows")]
3493 extern "system" {
3494 fn PrivilegedServiceAuditAlarmW(subsystemname: super::Foundation::PWSTR, servicename: super::Foundation::PWSTR, clienttoken: super::Foundation::HANDLE, privileges: *const PRIVILEGE_SET, accessgranted: super::Foundation::BOOL) -> super::Foundation::BOOL;
3495 }
3496 ::std::mem::transmute(PrivilegedServiceAuditAlarmW(subsystemname.into_param().abi(), servicename.into_param().abi(), clienttoken.into_param().abi(), ::std::mem::transmute(privileges), accessgranted.into_param().abi()))
3497 }
3498 #[cfg(not(windows))]
3499 unimplemented!("Unsupported target OS");
3500 }
3501 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3502 #[repr(C)]
3503 pub struct QUOTA_LIMITS {
3504 pub PagedPoolLimit: usize,
3505 pub NonPagedPoolLimit: usize,
3506 pub MinimumWorkingSetSize: usize,
3507 pub MaximumWorkingSetSize: usize,
3508 pub PagefileLimit: usize,
3509 pub TimeLimit: i64,
3510 }
3511 impl QUOTA_LIMITS {}
3512 impl ::std::default::Default for QUOTA_LIMITS {
default() -> Self3513 fn default() -> Self {
3514 unsafe { ::std::mem::zeroed() }
3515 }
3516 }
3517 impl ::std::fmt::Debug for QUOTA_LIMITS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3518 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3519 fmt.debug_struct("QUOTA_LIMITS")
3520 .field("PagedPoolLimit", &self.PagedPoolLimit)
3521 .field("NonPagedPoolLimit", &self.NonPagedPoolLimit)
3522 .field("MinimumWorkingSetSize", &self.MinimumWorkingSetSize)
3523 .field("MaximumWorkingSetSize", &self.MaximumWorkingSetSize)
3524 .field("PagefileLimit", &self.PagefileLimit)
3525 .field("TimeLimit", &self.TimeLimit)
3526 .finish()
3527 }
3528 }
3529 impl ::std::cmp::PartialEq for QUOTA_LIMITS {
eq(&self, other: &Self) -> bool3530 fn eq(&self, other: &Self) -> bool {
3531 self.PagedPoolLimit == other.PagedPoolLimit && self.NonPagedPoolLimit == other.NonPagedPoolLimit && self.MinimumWorkingSetSize == other.MinimumWorkingSetSize && self.MaximumWorkingSetSize == other.MaximumWorkingSetSize && self.PagefileLimit == other.PagefileLimit && self.TimeLimit == other.TimeLimit
3532 }
3533 }
3534 impl ::std::cmp::Eq for QUOTA_LIMITS {}
3535 unsafe impl ::windows::runtime::Abi for QUOTA_LIMITS {
3536 type Abi = Self;
3537 type DefaultType = Self;
3538 }
3539 #[inline]
QuerySecurityAccessMask(securityinformation: u32, desiredaccess: *mut u32)3540 pub unsafe fn QuerySecurityAccessMask(securityinformation: u32, desiredaccess: *mut u32) {
3541 #[cfg(windows)]
3542 {
3543 #[link(name = "windows")]
3544 extern "system" {
3545 fn QuerySecurityAccessMask(securityinformation: u32, desiredaccess: *mut u32);
3546 }
3547 ::std::mem::transmute(QuerySecurityAccessMask(::std::mem::transmute(securityinformation), ::std::mem::transmute(desiredaccess)))
3548 }
3549 #[cfg(not(windows))]
3550 unimplemented!("Unsupported target OS");
3551 }
3552 #[cfg(feature = "Win32_Foundation")]
3553 #[inline]
RevertToSelf() -> super::Foundation::BOOL3554 pub unsafe fn RevertToSelf() -> super::Foundation::BOOL {
3555 #[cfg(windows)]
3556 {
3557 #[link(name = "windows")]
3558 extern "system" {
3559 fn RevertToSelf() -> super::Foundation::BOOL;
3560 }
3561 ::std::mem::transmute(RevertToSelf())
3562 }
3563 #[cfg(not(windows))]
3564 unimplemented!("Unsupported target OS");
3565 }
3566 #[cfg(feature = "Win32_Foundation")]
3567 #[inline]
RtlConvertSidToUnicodeString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOLEAN>>(unicodestring: *mut super::Foundation::UNICODE_STRING, sid: Param1, allocatedestinationstring: Param2) -> ::windows::runtime::Result<()>3568 pub unsafe fn RtlConvertSidToUnicodeString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOLEAN>>(unicodestring: *mut super::Foundation::UNICODE_STRING, sid: Param1, allocatedestinationstring: Param2) -> ::windows::runtime::Result<()> {
3569 #[cfg(windows)]
3570 {
3571 #[link(name = "windows")]
3572 extern "system" {
3573 fn RtlConvertSidToUnicodeString(unicodestring: *mut super::Foundation::UNICODE_STRING, sid: super::Foundation::PSID, allocatedestinationstring: super::Foundation::BOOLEAN) -> super::Foundation::NTSTATUS;
3574 }
3575 RtlConvertSidToUnicodeString(::std::mem::transmute(unicodestring), sid.into_param().abi(), allocatedestinationstring.into_param().abi()).ok()
3576 }
3577 #[cfg(not(windows))]
3578 unimplemented!("Unsupported target OS");
3579 }
3580 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
3581 #[repr(transparent)]
3582 pub struct SAFER_LEVEL_HANDLE(pub isize);
3583 impl ::std::default::Default for SAFER_LEVEL_HANDLE {
default() -> Self3584 fn default() -> Self {
3585 unsafe { ::std::mem::zeroed() }
3586 }
3587 }
3588 unsafe impl ::windows::runtime::Handle for SAFER_LEVEL_HANDLE {}
3589 unsafe impl ::windows::runtime::Abi for SAFER_LEVEL_HANDLE {
3590 type Abi = Self;
3591 type DefaultType = Self;
3592 }
3593 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
3594 #[repr(transparent)]
3595 pub struct SC_HANDLE(pub isize);
3596 impl ::std::default::Default for SC_HANDLE {
default() -> Self3597 fn default() -> Self {
3598 unsafe { ::std::mem::zeroed() }
3599 }
3600 }
3601 unsafe impl ::windows::runtime::Handle for SC_HANDLE {}
3602 unsafe impl ::windows::runtime::Abi for SC_HANDLE {
3603 type Abi = Self;
3604 type DefaultType = Self;
3605 }
3606 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3607 #[repr(C)]
3608 #[cfg(feature = "Win32_Foundation")]
3609 pub struct SECURITY_ATTRIBUTES {
3610 pub nLength: u32,
3611 pub lpSecurityDescriptor: *mut ::std::ffi::c_void,
3612 pub bInheritHandle: super::Foundation::BOOL,
3613 }
3614 #[cfg(feature = "Win32_Foundation")]
3615 impl SECURITY_ATTRIBUTES {}
3616 #[cfg(feature = "Win32_Foundation")]
3617 impl ::std::default::Default for SECURITY_ATTRIBUTES {
default() -> Self3618 fn default() -> Self {
3619 unsafe { ::std::mem::zeroed() }
3620 }
3621 }
3622 #[cfg(feature = "Win32_Foundation")]
3623 impl ::std::fmt::Debug for SECURITY_ATTRIBUTES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3624 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3625 fmt.debug_struct("SECURITY_ATTRIBUTES").field("nLength", &self.nLength).field("lpSecurityDescriptor", &self.lpSecurityDescriptor).field("bInheritHandle", &self.bInheritHandle).finish()
3626 }
3627 }
3628 #[cfg(feature = "Win32_Foundation")]
3629 impl ::std::cmp::PartialEq for SECURITY_ATTRIBUTES {
eq(&self, other: &Self) -> bool3630 fn eq(&self, other: &Self) -> bool {
3631 self.nLength == other.nLength && self.lpSecurityDescriptor == other.lpSecurityDescriptor && self.bInheritHandle == other.bInheritHandle
3632 }
3633 }
3634 #[cfg(feature = "Win32_Foundation")]
3635 impl ::std::cmp::Eq for SECURITY_ATTRIBUTES {}
3636 #[cfg(feature = "Win32_Foundation")]
3637 unsafe impl ::windows::runtime::Abi for SECURITY_ATTRIBUTES {
3638 type Abi = Self;
3639 type DefaultType = Self;
3640 }
3641 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3642 #[repr(transparent)]
3643 pub struct SECURITY_AUTO_INHERIT_FLAGS(pub u32);
3644 pub const SEF_AVOID_OWNER_CHECK: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(16u32);
3645 pub const SEF_AVOID_OWNER_RESTRICTION: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(4096u32);
3646 pub const SEF_AVOID_PRIVILEGE_CHECK: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(8u32);
3647 pub const SEF_DACL_AUTO_INHERIT: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(1u32);
3648 pub const SEF_DEFAULT_DESCRIPTOR_FOR_OBJECT: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(4u32);
3649 pub const SEF_DEFAULT_GROUP_FROM_PARENT: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(64u32);
3650 pub const SEF_DEFAULT_OWNER_FROM_PARENT: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(32u32);
3651 pub const SEF_MACL_NO_EXECUTE_UP: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(1024u32);
3652 pub const SEF_MACL_NO_READ_UP: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(512u32);
3653 pub const SEF_MACL_NO_WRITE_UP: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(256u32);
3654 pub const SEF_SACL_AUTO_INHERIT: SECURITY_AUTO_INHERIT_FLAGS = SECURITY_AUTO_INHERIT_FLAGS(2u32);
3655 impl ::std::convert::From<u32> for SECURITY_AUTO_INHERIT_FLAGS {
from(value: u32) -> Self3656 fn from(value: u32) -> Self {
3657 Self(value)
3658 }
3659 }
3660 unsafe impl ::windows::runtime::Abi for SECURITY_AUTO_INHERIT_FLAGS {
3661 type Abi = Self;
3662 type DefaultType = Self;
3663 }
3664 impl ::std::ops::BitOr for SECURITY_AUTO_INHERIT_FLAGS {
3665 type Output = Self;
bitor(self, rhs: Self) -> Self3666 fn bitor(self, rhs: Self) -> Self {
3667 Self(self.0 | rhs.0)
3668 }
3669 }
3670 impl ::std::ops::BitAnd for SECURITY_AUTO_INHERIT_FLAGS {
3671 type Output = Self;
bitand(self, rhs: Self) -> Self3672 fn bitand(self, rhs: Self) -> Self {
3673 Self(self.0 & rhs.0)
3674 }
3675 }
3676 impl ::std::ops::BitOrAssign for SECURITY_AUTO_INHERIT_FLAGS {
bitor_assign(&mut self, rhs: Self)3677 fn bitor_assign(&mut self, rhs: Self) {
3678 self.0.bitor_assign(rhs.0)
3679 }
3680 }
3681 impl ::std::ops::BitAndAssign for SECURITY_AUTO_INHERIT_FLAGS {
bitand_assign(&mut self, rhs: Self)3682 fn bitand_assign(&mut self, rhs: Self) {
3683 self.0.bitand_assign(rhs.0)
3684 }
3685 }
3686 impl ::std::ops::Not for SECURITY_AUTO_INHERIT_FLAGS {
3687 type Output = Self;
not(self) -> Self3688 fn not(self) -> Self {
3689 Self(self.0.not())
3690 }
3691 }
3692 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3693 #[repr(C)]
3694 #[cfg(feature = "Win32_Foundation")]
3695 pub struct SECURITY_CAPABILITIES {
3696 pub AppContainerSid: super::Foundation::PSID,
3697 pub Capabilities: *mut SID_AND_ATTRIBUTES,
3698 pub CapabilityCount: u32,
3699 pub Reserved: u32,
3700 }
3701 #[cfg(feature = "Win32_Foundation")]
3702 impl SECURITY_CAPABILITIES {}
3703 #[cfg(feature = "Win32_Foundation")]
3704 impl ::std::default::Default for SECURITY_CAPABILITIES {
default() -> Self3705 fn default() -> Self {
3706 unsafe { ::std::mem::zeroed() }
3707 }
3708 }
3709 #[cfg(feature = "Win32_Foundation")]
3710 impl ::std::fmt::Debug for SECURITY_CAPABILITIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3711 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3712 fmt.debug_struct("SECURITY_CAPABILITIES").field("AppContainerSid", &self.AppContainerSid).field("Capabilities", &self.Capabilities).field("CapabilityCount", &self.CapabilityCount).field("Reserved", &self.Reserved).finish()
3713 }
3714 }
3715 #[cfg(feature = "Win32_Foundation")]
3716 impl ::std::cmp::PartialEq for SECURITY_CAPABILITIES {
eq(&self, other: &Self) -> bool3717 fn eq(&self, other: &Self) -> bool {
3718 self.AppContainerSid == other.AppContainerSid && self.Capabilities == other.Capabilities && self.CapabilityCount == other.CapabilityCount && self.Reserved == other.Reserved
3719 }
3720 }
3721 #[cfg(feature = "Win32_Foundation")]
3722 impl ::std::cmp::Eq for SECURITY_CAPABILITIES {}
3723 #[cfg(feature = "Win32_Foundation")]
3724 unsafe impl ::windows::runtime::Abi for SECURITY_CAPABILITIES {
3725 type Abi = Self;
3726 type DefaultType = Self;
3727 }
3728 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3729 #[repr(C)]
3730 #[cfg(feature = "Win32_Foundation")]
3731 pub struct SECURITY_DESCRIPTOR {
3732 pub Revision: u8,
3733 pub Sbz1: u8,
3734 pub Control: u16,
3735 pub Owner: super::Foundation::PSID,
3736 pub Group: super::Foundation::PSID,
3737 pub Sacl: *mut ACL,
3738 pub Dacl: *mut ACL,
3739 }
3740 #[cfg(feature = "Win32_Foundation")]
3741 impl SECURITY_DESCRIPTOR {}
3742 #[cfg(feature = "Win32_Foundation")]
3743 impl ::std::default::Default for SECURITY_DESCRIPTOR {
default() -> Self3744 fn default() -> Self {
3745 unsafe { ::std::mem::zeroed() }
3746 }
3747 }
3748 #[cfg(feature = "Win32_Foundation")]
3749 impl ::std::fmt::Debug for SECURITY_DESCRIPTOR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3750 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3751 fmt.debug_struct("SECURITY_DESCRIPTOR").field("Revision", &self.Revision).field("Sbz1", &self.Sbz1).field("Control", &self.Control).field("Owner", &self.Owner).field("Group", &self.Group).field("Sacl", &self.Sacl).field("Dacl", &self.Dacl).finish()
3752 }
3753 }
3754 #[cfg(feature = "Win32_Foundation")]
3755 impl ::std::cmp::PartialEq for SECURITY_DESCRIPTOR {
eq(&self, other: &Self) -> bool3756 fn eq(&self, other: &Self) -> bool {
3757 self.Revision == other.Revision && self.Sbz1 == other.Sbz1 && self.Control == other.Control && self.Owner == other.Owner && self.Group == other.Group && self.Sacl == other.Sacl && self.Dacl == other.Dacl
3758 }
3759 }
3760 #[cfg(feature = "Win32_Foundation")]
3761 impl ::std::cmp::Eq for SECURITY_DESCRIPTOR {}
3762 #[cfg(feature = "Win32_Foundation")]
3763 unsafe impl ::windows::runtime::Abi for SECURITY_DESCRIPTOR {
3764 type Abi = Self;
3765 type DefaultType = Self;
3766 }
3767 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3768 #[repr(transparent)]
3769 pub struct SECURITY_IMPERSONATION_LEVEL(pub i32);
3770 pub const SecurityAnonymous: SECURITY_IMPERSONATION_LEVEL = SECURITY_IMPERSONATION_LEVEL(0i32);
3771 pub const SecurityIdentification: SECURITY_IMPERSONATION_LEVEL = SECURITY_IMPERSONATION_LEVEL(1i32);
3772 pub const SecurityImpersonation: SECURITY_IMPERSONATION_LEVEL = SECURITY_IMPERSONATION_LEVEL(2i32);
3773 pub const SecurityDelegation: SECURITY_IMPERSONATION_LEVEL = SECURITY_IMPERSONATION_LEVEL(3i32);
3774 impl ::std::convert::From<i32> for SECURITY_IMPERSONATION_LEVEL {
from(value: i32) -> Self3775 fn from(value: i32) -> Self {
3776 Self(value)
3777 }
3778 }
3779 unsafe impl ::windows::runtime::Abi for SECURITY_IMPERSONATION_LEVEL {
3780 type Abi = Self;
3781 type DefaultType = Self;
3782 }
3783 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3784 #[repr(C)]
3785 #[cfg(feature = "Win32_Foundation")]
3786 pub struct SECURITY_QUALITY_OF_SERVICE {
3787 pub Length: u32,
3788 pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
3789 pub ContextTrackingMode: u8,
3790 pub EffectiveOnly: super::Foundation::BOOLEAN,
3791 }
3792 #[cfg(feature = "Win32_Foundation")]
3793 impl SECURITY_QUALITY_OF_SERVICE {}
3794 #[cfg(feature = "Win32_Foundation")]
3795 impl ::std::default::Default for SECURITY_QUALITY_OF_SERVICE {
default() -> Self3796 fn default() -> Self {
3797 unsafe { ::std::mem::zeroed() }
3798 }
3799 }
3800 #[cfg(feature = "Win32_Foundation")]
3801 impl ::std::fmt::Debug for SECURITY_QUALITY_OF_SERVICE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3802 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3803 fmt.debug_struct("SECURITY_QUALITY_OF_SERVICE").field("Length", &self.Length).field("ImpersonationLevel", &self.ImpersonationLevel).field("ContextTrackingMode", &self.ContextTrackingMode).field("EffectiveOnly", &self.EffectiveOnly).finish()
3804 }
3805 }
3806 #[cfg(feature = "Win32_Foundation")]
3807 impl ::std::cmp::PartialEq for SECURITY_QUALITY_OF_SERVICE {
eq(&self, other: &Self) -> bool3808 fn eq(&self, other: &Self) -> bool {
3809 self.Length == other.Length && self.ImpersonationLevel == other.ImpersonationLevel && self.ContextTrackingMode == other.ContextTrackingMode && self.EffectiveOnly == other.EffectiveOnly
3810 }
3811 }
3812 #[cfg(feature = "Win32_Foundation")]
3813 impl ::std::cmp::Eq for SECURITY_QUALITY_OF_SERVICE {}
3814 #[cfg(feature = "Win32_Foundation")]
3815 unsafe impl ::windows::runtime::Abi for SECURITY_QUALITY_OF_SERVICE {
3816 type Abi = Self;
3817 type DefaultType = Self;
3818 }
3819 pub type SEC_THREAD_START = unsafe extern "system" fn(lpthreadparameter: *mut ::std::ffi::c_void) -> u32;
3820 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3821 #[repr(C)]
3822 pub struct SID {
3823 pub Revision: u8,
3824 pub SubAuthorityCount: u8,
3825 pub IdentifierAuthority: SID_IDENTIFIER_AUTHORITY,
3826 pub SubAuthority: [u32; 1],
3827 }
3828 impl SID {}
3829 impl ::std::default::Default for SID {
default() -> Self3830 fn default() -> Self {
3831 unsafe { ::std::mem::zeroed() }
3832 }
3833 }
3834 impl ::std::fmt::Debug for SID {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3835 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3836 fmt.debug_struct("SID").field("Revision", &self.Revision).field("SubAuthorityCount", &self.SubAuthorityCount).field("IdentifierAuthority", &self.IdentifierAuthority).field("SubAuthority", &self.SubAuthority).finish()
3837 }
3838 }
3839 impl ::std::cmp::PartialEq for SID {
eq(&self, other: &Self) -> bool3840 fn eq(&self, other: &Self) -> bool {
3841 self.Revision == other.Revision && self.SubAuthorityCount == other.SubAuthorityCount && self.IdentifierAuthority == other.IdentifierAuthority && self.SubAuthority == other.SubAuthority
3842 }
3843 }
3844 impl ::std::cmp::Eq for SID {}
3845 unsafe impl ::windows::runtime::Abi for SID {
3846 type Abi = Self;
3847 type DefaultType = Self;
3848 }
3849 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3850 #[repr(C)]
3851 #[cfg(feature = "Win32_Foundation")]
3852 pub struct SID_AND_ATTRIBUTES {
3853 pub Sid: super::Foundation::PSID,
3854 pub Attributes: u32,
3855 }
3856 #[cfg(feature = "Win32_Foundation")]
3857 impl SID_AND_ATTRIBUTES {}
3858 #[cfg(feature = "Win32_Foundation")]
3859 impl ::std::default::Default for SID_AND_ATTRIBUTES {
default() -> Self3860 fn default() -> Self {
3861 unsafe { ::std::mem::zeroed() }
3862 }
3863 }
3864 #[cfg(feature = "Win32_Foundation")]
3865 impl ::std::fmt::Debug for SID_AND_ATTRIBUTES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3866 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3867 fmt.debug_struct("SID_AND_ATTRIBUTES").field("Sid", &self.Sid).field("Attributes", &self.Attributes).finish()
3868 }
3869 }
3870 #[cfg(feature = "Win32_Foundation")]
3871 impl ::std::cmp::PartialEq for SID_AND_ATTRIBUTES {
eq(&self, other: &Self) -> bool3872 fn eq(&self, other: &Self) -> bool {
3873 self.Sid == other.Sid && self.Attributes == other.Attributes
3874 }
3875 }
3876 #[cfg(feature = "Win32_Foundation")]
3877 impl ::std::cmp::Eq for SID_AND_ATTRIBUTES {}
3878 #[cfg(feature = "Win32_Foundation")]
3879 unsafe impl ::windows::runtime::Abi for SID_AND_ATTRIBUTES {
3880 type Abi = Self;
3881 type DefaultType = Self;
3882 }
3883 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3884 #[repr(C)]
3885 #[cfg(feature = "Win32_Foundation")]
3886 pub struct SID_AND_ATTRIBUTES_HASH {
3887 pub SidCount: u32,
3888 pub SidAttr: *mut SID_AND_ATTRIBUTES,
3889 pub Hash: [usize; 32],
3890 }
3891 #[cfg(feature = "Win32_Foundation")]
3892 impl SID_AND_ATTRIBUTES_HASH {}
3893 #[cfg(feature = "Win32_Foundation")]
3894 impl ::std::default::Default for SID_AND_ATTRIBUTES_HASH {
default() -> Self3895 fn default() -> Self {
3896 unsafe { ::std::mem::zeroed() }
3897 }
3898 }
3899 #[cfg(feature = "Win32_Foundation")]
3900 impl ::std::fmt::Debug for SID_AND_ATTRIBUTES_HASH {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3901 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3902 fmt.debug_struct("SID_AND_ATTRIBUTES_HASH").field("SidCount", &self.SidCount).field("SidAttr", &self.SidAttr).field("Hash", &self.Hash).finish()
3903 }
3904 }
3905 #[cfg(feature = "Win32_Foundation")]
3906 impl ::std::cmp::PartialEq for SID_AND_ATTRIBUTES_HASH {
eq(&self, other: &Self) -> bool3907 fn eq(&self, other: &Self) -> bool {
3908 self.SidCount == other.SidCount && self.SidAttr == other.SidAttr && self.Hash == other.Hash
3909 }
3910 }
3911 #[cfg(feature = "Win32_Foundation")]
3912 impl ::std::cmp::Eq for SID_AND_ATTRIBUTES_HASH {}
3913 #[cfg(feature = "Win32_Foundation")]
3914 unsafe impl ::windows::runtime::Abi for SID_AND_ATTRIBUTES_HASH {
3915 type Abi = Self;
3916 type DefaultType = Self;
3917 }
3918 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3919 #[repr(C)]
3920 pub struct SID_IDENTIFIER_AUTHORITY {
3921 pub Value: [u8; 6],
3922 }
3923 impl SID_IDENTIFIER_AUTHORITY {}
3924 impl ::std::default::Default for SID_IDENTIFIER_AUTHORITY {
default() -> Self3925 fn default() -> Self {
3926 unsafe { ::std::mem::zeroed() }
3927 }
3928 }
3929 impl ::std::fmt::Debug for SID_IDENTIFIER_AUTHORITY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3930 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3931 fmt.debug_struct("SID_IDENTIFIER_AUTHORITY").field("Value", &self.Value).finish()
3932 }
3933 }
3934 impl ::std::cmp::PartialEq for SID_IDENTIFIER_AUTHORITY {
eq(&self, other: &Self) -> bool3935 fn eq(&self, other: &Self) -> bool {
3936 self.Value == other.Value
3937 }
3938 }
3939 impl ::std::cmp::Eq for SID_IDENTIFIER_AUTHORITY {}
3940 unsafe impl ::windows::runtime::Abi for SID_IDENTIFIER_AUTHORITY {
3941 type Abi = Self;
3942 type DefaultType = Self;
3943 }
3944 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3945 #[repr(transparent)]
3946 pub struct SID_NAME_USE(pub i32);
3947 pub const SidTypeUser: SID_NAME_USE = SID_NAME_USE(1i32);
3948 pub const SidTypeGroup: SID_NAME_USE = SID_NAME_USE(2i32);
3949 pub const SidTypeDomain: SID_NAME_USE = SID_NAME_USE(3i32);
3950 pub const SidTypeAlias: SID_NAME_USE = SID_NAME_USE(4i32);
3951 pub const SidTypeWellKnownGroup: SID_NAME_USE = SID_NAME_USE(5i32);
3952 pub const SidTypeDeletedAccount: SID_NAME_USE = SID_NAME_USE(6i32);
3953 pub const SidTypeInvalid: SID_NAME_USE = SID_NAME_USE(7i32);
3954 pub const SidTypeUnknown: SID_NAME_USE = SID_NAME_USE(8i32);
3955 pub const SidTypeComputer: SID_NAME_USE = SID_NAME_USE(9i32);
3956 pub const SidTypeLabel: SID_NAME_USE = SID_NAME_USE(10i32);
3957 pub const SidTypeLogonSession: SID_NAME_USE = SID_NAME_USE(11i32);
3958 impl ::std::convert::From<i32> for SID_NAME_USE {
from(value: i32) -> Self3959 fn from(value: i32) -> Self {
3960 Self(value)
3961 }
3962 }
3963 unsafe impl ::windows::runtime::Abi for SID_NAME_USE {
3964 type Abi = Self;
3965 type DefaultType = Self;
3966 }
3967 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3968 #[repr(C)]
3969 pub struct SYSTEM_ALARM_ACE {
3970 pub Header: ACE_HEADER,
3971 pub Mask: u32,
3972 pub SidStart: u32,
3973 }
3974 impl SYSTEM_ALARM_ACE {}
3975 impl ::std::default::Default for SYSTEM_ALARM_ACE {
default() -> Self3976 fn default() -> Self {
3977 unsafe { ::std::mem::zeroed() }
3978 }
3979 }
3980 impl ::std::fmt::Debug for SYSTEM_ALARM_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3981 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3982 fmt.debug_struct("SYSTEM_ALARM_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
3983 }
3984 }
3985 impl ::std::cmp::PartialEq for SYSTEM_ALARM_ACE {
eq(&self, other: &Self) -> bool3986 fn eq(&self, other: &Self) -> bool {
3987 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
3988 }
3989 }
3990 impl ::std::cmp::Eq for SYSTEM_ALARM_ACE {}
3991 unsafe impl ::windows::runtime::Abi for SYSTEM_ALARM_ACE {
3992 type Abi = Self;
3993 type DefaultType = Self;
3994 }
3995 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3996 #[repr(C)]
3997 pub struct SYSTEM_ALARM_CALLBACK_ACE {
3998 pub Header: ACE_HEADER,
3999 pub Mask: u32,
4000 pub SidStart: u32,
4001 }
4002 impl SYSTEM_ALARM_CALLBACK_ACE {}
4003 impl ::std::default::Default for SYSTEM_ALARM_CALLBACK_ACE {
default() -> Self4004 fn default() -> Self {
4005 unsafe { ::std::mem::zeroed() }
4006 }
4007 }
4008 impl ::std::fmt::Debug for SYSTEM_ALARM_CALLBACK_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4009 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4010 fmt.debug_struct("SYSTEM_ALARM_CALLBACK_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
4011 }
4012 }
4013 impl ::std::cmp::PartialEq for SYSTEM_ALARM_CALLBACK_ACE {
eq(&self, other: &Self) -> bool4014 fn eq(&self, other: &Self) -> bool {
4015 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
4016 }
4017 }
4018 impl ::std::cmp::Eq for SYSTEM_ALARM_CALLBACK_ACE {}
4019 unsafe impl ::windows::runtime::Abi for SYSTEM_ALARM_CALLBACK_ACE {
4020 type Abi = Self;
4021 type DefaultType = Self;
4022 }
4023 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4024 #[repr(C)]
4025 pub struct SYSTEM_ALARM_CALLBACK_OBJECT_ACE {
4026 pub Header: ACE_HEADER,
4027 pub Mask: u32,
4028 pub Flags: SYSTEM_AUDIT_OBJECT_ACE_FLAGS,
4029 pub ObjectType: ::windows::runtime::GUID,
4030 pub InheritedObjectType: ::windows::runtime::GUID,
4031 pub SidStart: u32,
4032 }
4033 impl SYSTEM_ALARM_CALLBACK_OBJECT_ACE {}
4034 impl ::std::default::Default for SYSTEM_ALARM_CALLBACK_OBJECT_ACE {
default() -> Self4035 fn default() -> Self {
4036 unsafe { ::std::mem::zeroed() }
4037 }
4038 }
4039 impl ::std::fmt::Debug for SYSTEM_ALARM_CALLBACK_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4040 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4041 fmt.debug_struct("SYSTEM_ALARM_CALLBACK_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
4042 }
4043 }
4044 impl ::std::cmp::PartialEq for SYSTEM_ALARM_CALLBACK_OBJECT_ACE {
eq(&self, other: &Self) -> bool4045 fn eq(&self, other: &Self) -> bool {
4046 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
4047 }
4048 }
4049 impl ::std::cmp::Eq for SYSTEM_ALARM_CALLBACK_OBJECT_ACE {}
4050 unsafe impl ::windows::runtime::Abi for SYSTEM_ALARM_CALLBACK_OBJECT_ACE {
4051 type Abi = Self;
4052 type DefaultType = Self;
4053 }
4054 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4055 #[repr(C)]
4056 pub struct SYSTEM_ALARM_OBJECT_ACE {
4057 pub Header: ACE_HEADER,
4058 pub Mask: u32,
4059 pub Flags: u32,
4060 pub ObjectType: ::windows::runtime::GUID,
4061 pub InheritedObjectType: ::windows::runtime::GUID,
4062 pub SidStart: u32,
4063 }
4064 impl SYSTEM_ALARM_OBJECT_ACE {}
4065 impl ::std::default::Default for SYSTEM_ALARM_OBJECT_ACE {
default() -> Self4066 fn default() -> Self {
4067 unsafe { ::std::mem::zeroed() }
4068 }
4069 }
4070 impl ::std::fmt::Debug for SYSTEM_ALARM_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4071 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4072 fmt.debug_struct("SYSTEM_ALARM_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
4073 }
4074 }
4075 impl ::std::cmp::PartialEq for SYSTEM_ALARM_OBJECT_ACE {
eq(&self, other: &Self) -> bool4076 fn eq(&self, other: &Self) -> bool {
4077 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
4078 }
4079 }
4080 impl ::std::cmp::Eq for SYSTEM_ALARM_OBJECT_ACE {}
4081 unsafe impl ::windows::runtime::Abi for SYSTEM_ALARM_OBJECT_ACE {
4082 type Abi = Self;
4083 type DefaultType = Self;
4084 }
4085 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4086 #[repr(C)]
4087 pub struct SYSTEM_AUDIT_ACE {
4088 pub Header: ACE_HEADER,
4089 pub Mask: u32,
4090 pub SidStart: u32,
4091 }
4092 impl SYSTEM_AUDIT_ACE {}
4093 impl ::std::default::Default for SYSTEM_AUDIT_ACE {
default() -> Self4094 fn default() -> Self {
4095 unsafe { ::std::mem::zeroed() }
4096 }
4097 }
4098 impl ::std::fmt::Debug for SYSTEM_AUDIT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4099 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4100 fmt.debug_struct("SYSTEM_AUDIT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
4101 }
4102 }
4103 impl ::std::cmp::PartialEq for SYSTEM_AUDIT_ACE {
eq(&self, other: &Self) -> bool4104 fn eq(&self, other: &Self) -> bool {
4105 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
4106 }
4107 }
4108 impl ::std::cmp::Eq for SYSTEM_AUDIT_ACE {}
4109 unsafe impl ::windows::runtime::Abi for SYSTEM_AUDIT_ACE {
4110 type Abi = Self;
4111 type DefaultType = Self;
4112 }
4113 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4114 #[repr(C)]
4115 pub struct SYSTEM_AUDIT_CALLBACK_ACE {
4116 pub Header: ACE_HEADER,
4117 pub Mask: u32,
4118 pub SidStart: u32,
4119 }
4120 impl SYSTEM_AUDIT_CALLBACK_ACE {}
4121 impl ::std::default::Default for SYSTEM_AUDIT_CALLBACK_ACE {
default() -> Self4122 fn default() -> Self {
4123 unsafe { ::std::mem::zeroed() }
4124 }
4125 }
4126 impl ::std::fmt::Debug for SYSTEM_AUDIT_CALLBACK_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4127 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4128 fmt.debug_struct("SYSTEM_AUDIT_CALLBACK_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
4129 }
4130 }
4131 impl ::std::cmp::PartialEq for SYSTEM_AUDIT_CALLBACK_ACE {
eq(&self, other: &Self) -> bool4132 fn eq(&self, other: &Self) -> bool {
4133 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
4134 }
4135 }
4136 impl ::std::cmp::Eq for SYSTEM_AUDIT_CALLBACK_ACE {}
4137 unsafe impl ::windows::runtime::Abi for SYSTEM_AUDIT_CALLBACK_ACE {
4138 type Abi = Self;
4139 type DefaultType = Self;
4140 }
4141 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4142 #[repr(C)]
4143 pub struct SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {
4144 pub Header: ACE_HEADER,
4145 pub Mask: u32,
4146 pub Flags: SYSTEM_AUDIT_OBJECT_ACE_FLAGS,
4147 pub ObjectType: ::windows::runtime::GUID,
4148 pub InheritedObjectType: ::windows::runtime::GUID,
4149 pub SidStart: u32,
4150 }
4151 impl SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {}
4152 impl ::std::default::Default for SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {
default() -> Self4153 fn default() -> Self {
4154 unsafe { ::std::mem::zeroed() }
4155 }
4156 }
4157 impl ::std::fmt::Debug for SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4158 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4159 fmt.debug_struct("SYSTEM_AUDIT_CALLBACK_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
4160 }
4161 }
4162 impl ::std::cmp::PartialEq for SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {
eq(&self, other: &Self) -> bool4163 fn eq(&self, other: &Self) -> bool {
4164 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
4165 }
4166 }
4167 impl ::std::cmp::Eq for SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {}
4168 unsafe impl ::windows::runtime::Abi for SYSTEM_AUDIT_CALLBACK_OBJECT_ACE {
4169 type Abi = Self;
4170 type DefaultType = Self;
4171 }
4172 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4173 #[repr(C)]
4174 pub struct SYSTEM_AUDIT_OBJECT_ACE {
4175 pub Header: ACE_HEADER,
4176 pub Mask: u32,
4177 pub Flags: SYSTEM_AUDIT_OBJECT_ACE_FLAGS,
4178 pub ObjectType: ::windows::runtime::GUID,
4179 pub InheritedObjectType: ::windows::runtime::GUID,
4180 pub SidStart: u32,
4181 }
4182 impl SYSTEM_AUDIT_OBJECT_ACE {}
4183 impl ::std::default::Default for SYSTEM_AUDIT_OBJECT_ACE {
default() -> Self4184 fn default() -> Self {
4185 unsafe { ::std::mem::zeroed() }
4186 }
4187 }
4188 impl ::std::fmt::Debug for SYSTEM_AUDIT_OBJECT_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4189 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4190 fmt.debug_struct("SYSTEM_AUDIT_OBJECT_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("Flags", &self.Flags).field("ObjectType", &self.ObjectType).field("InheritedObjectType", &self.InheritedObjectType).field("SidStart", &self.SidStart).finish()
4191 }
4192 }
4193 impl ::std::cmp::PartialEq for SYSTEM_AUDIT_OBJECT_ACE {
eq(&self, other: &Self) -> bool4194 fn eq(&self, other: &Self) -> bool {
4195 self.Header == other.Header && self.Mask == other.Mask && self.Flags == other.Flags && self.ObjectType == other.ObjectType && self.InheritedObjectType == other.InheritedObjectType && self.SidStart == other.SidStart
4196 }
4197 }
4198 impl ::std::cmp::Eq for SYSTEM_AUDIT_OBJECT_ACE {}
4199 unsafe impl ::windows::runtime::Abi for SYSTEM_AUDIT_OBJECT_ACE {
4200 type Abi = Self;
4201 type DefaultType = Self;
4202 }
4203 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4204 #[repr(transparent)]
4205 pub struct SYSTEM_AUDIT_OBJECT_ACE_FLAGS(pub u32);
4206 pub const ACE_OBJECT_TYPE_PRESENT: SYSTEM_AUDIT_OBJECT_ACE_FLAGS = SYSTEM_AUDIT_OBJECT_ACE_FLAGS(1u32);
4207 pub const ACE_INHERITED_OBJECT_TYPE_PRESENT: SYSTEM_AUDIT_OBJECT_ACE_FLAGS = SYSTEM_AUDIT_OBJECT_ACE_FLAGS(2u32);
4208 impl ::std::convert::From<u32> for SYSTEM_AUDIT_OBJECT_ACE_FLAGS {
from(value: u32) -> Self4209 fn from(value: u32) -> Self {
4210 Self(value)
4211 }
4212 }
4213 unsafe impl ::windows::runtime::Abi for SYSTEM_AUDIT_OBJECT_ACE_FLAGS {
4214 type Abi = Self;
4215 type DefaultType = Self;
4216 }
4217 impl ::std::ops::BitOr for SYSTEM_AUDIT_OBJECT_ACE_FLAGS {
4218 type Output = Self;
bitor(self, rhs: Self) -> Self4219 fn bitor(self, rhs: Self) -> Self {
4220 Self(self.0 | rhs.0)
4221 }
4222 }
4223 impl ::std::ops::BitAnd for SYSTEM_AUDIT_OBJECT_ACE_FLAGS {
4224 type Output = Self;
bitand(self, rhs: Self) -> Self4225 fn bitand(self, rhs: Self) -> Self {
4226 Self(self.0 & rhs.0)
4227 }
4228 }
4229 impl ::std::ops::BitOrAssign for SYSTEM_AUDIT_OBJECT_ACE_FLAGS {
bitor_assign(&mut self, rhs: Self)4230 fn bitor_assign(&mut self, rhs: Self) {
4231 self.0.bitor_assign(rhs.0)
4232 }
4233 }
4234 impl ::std::ops::BitAndAssign for SYSTEM_AUDIT_OBJECT_ACE_FLAGS {
bitand_assign(&mut self, rhs: Self)4235 fn bitand_assign(&mut self, rhs: Self) {
4236 self.0.bitand_assign(rhs.0)
4237 }
4238 }
4239 impl ::std::ops::Not for SYSTEM_AUDIT_OBJECT_ACE_FLAGS {
4240 type Output = Self;
not(self) -> Self4241 fn not(self) -> Self {
4242 Self(self.0.not())
4243 }
4244 }
4245 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4246 #[repr(C)]
4247 pub struct SYSTEM_MANDATORY_LABEL_ACE {
4248 pub Header: ACE_HEADER,
4249 pub Mask: u32,
4250 pub SidStart: u32,
4251 }
4252 impl SYSTEM_MANDATORY_LABEL_ACE {}
4253 impl ::std::default::Default for SYSTEM_MANDATORY_LABEL_ACE {
default() -> Self4254 fn default() -> Self {
4255 unsafe { ::std::mem::zeroed() }
4256 }
4257 }
4258 impl ::std::fmt::Debug for SYSTEM_MANDATORY_LABEL_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4259 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4260 fmt.debug_struct("SYSTEM_MANDATORY_LABEL_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
4261 }
4262 }
4263 impl ::std::cmp::PartialEq for SYSTEM_MANDATORY_LABEL_ACE {
eq(&self, other: &Self) -> bool4264 fn eq(&self, other: &Self) -> bool {
4265 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
4266 }
4267 }
4268 impl ::std::cmp::Eq for SYSTEM_MANDATORY_LABEL_ACE {}
4269 unsafe impl ::windows::runtime::Abi for SYSTEM_MANDATORY_LABEL_ACE {
4270 type Abi = Self;
4271 type DefaultType = Self;
4272 }
4273 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4274 #[repr(C)]
4275 pub struct SYSTEM_RESOURCE_ATTRIBUTE_ACE {
4276 pub Header: ACE_HEADER,
4277 pub Mask: u32,
4278 pub SidStart: u32,
4279 }
4280 impl SYSTEM_RESOURCE_ATTRIBUTE_ACE {}
4281 impl ::std::default::Default for SYSTEM_RESOURCE_ATTRIBUTE_ACE {
default() -> Self4282 fn default() -> Self {
4283 unsafe { ::std::mem::zeroed() }
4284 }
4285 }
4286 impl ::std::fmt::Debug for SYSTEM_RESOURCE_ATTRIBUTE_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4287 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4288 fmt.debug_struct("SYSTEM_RESOURCE_ATTRIBUTE_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
4289 }
4290 }
4291 impl ::std::cmp::PartialEq for SYSTEM_RESOURCE_ATTRIBUTE_ACE {
eq(&self, other: &Self) -> bool4292 fn eq(&self, other: &Self) -> bool {
4293 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
4294 }
4295 }
4296 impl ::std::cmp::Eq for SYSTEM_RESOURCE_ATTRIBUTE_ACE {}
4297 unsafe impl ::windows::runtime::Abi for SYSTEM_RESOURCE_ATTRIBUTE_ACE {
4298 type Abi = Self;
4299 type DefaultType = Self;
4300 }
4301 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4302 #[repr(C)]
4303 pub struct SYSTEM_SCOPED_POLICY_ID_ACE {
4304 pub Header: ACE_HEADER,
4305 pub Mask: u32,
4306 pub SidStart: u32,
4307 }
4308 impl SYSTEM_SCOPED_POLICY_ID_ACE {}
4309 impl ::std::default::Default for SYSTEM_SCOPED_POLICY_ID_ACE {
default() -> Self4310 fn default() -> Self {
4311 unsafe { ::std::mem::zeroed() }
4312 }
4313 }
4314 impl ::std::fmt::Debug for SYSTEM_SCOPED_POLICY_ID_ACE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4315 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4316 fmt.debug_struct("SYSTEM_SCOPED_POLICY_ID_ACE").field("Header", &self.Header).field("Mask", &self.Mask).field("SidStart", &self.SidStart).finish()
4317 }
4318 }
4319 impl ::std::cmp::PartialEq for SYSTEM_SCOPED_POLICY_ID_ACE {
eq(&self, other: &Self) -> bool4320 fn eq(&self, other: &Self) -> bool {
4321 self.Header == other.Header && self.Mask == other.Mask && self.SidStart == other.SidStart
4322 }
4323 }
4324 impl ::std::cmp::Eq for SYSTEM_SCOPED_POLICY_ID_ACE {}
4325 unsafe impl ::windows::runtime::Abi for SYSTEM_SCOPED_POLICY_ID_ACE {
4326 type Abi = Self;
4327 type DefaultType = Self;
4328 }
4329 #[cfg(feature = "Win32_Foundation")]
4330 #[inline]
SetAclInformation(pacl: *mut ACL, paclinformation: *const ::std::ffi::c_void, naclinformationlength: u32, dwaclinformationclass: ACL_INFORMATION_CLASS) -> super::Foundation::BOOL4331 pub unsafe fn SetAclInformation(pacl: *mut ACL, paclinformation: *const ::std::ffi::c_void, naclinformationlength: u32, dwaclinformationclass: ACL_INFORMATION_CLASS) -> super::Foundation::BOOL {
4332 #[cfg(windows)]
4333 {
4334 #[link(name = "windows")]
4335 extern "system" {
4336 fn SetAclInformation(pacl: *mut ACL, paclinformation: *const ::std::ffi::c_void, naclinformationlength: u32, dwaclinformationclass: ACL_INFORMATION_CLASS) -> super::Foundation::BOOL;
4337 }
4338 ::std::mem::transmute(SetAclInformation(::std::mem::transmute(pacl), ::std::mem::transmute(paclinformation), ::std::mem::transmute(naclinformationlength), ::std::mem::transmute(dwaclinformationclass)))
4339 }
4340 #[cfg(not(windows))]
4341 unimplemented!("Unsupported target OS");
4342 }
4343 #[cfg(feature = "Win32_Foundation")]
4344 #[inline]
SetCachedSigningLevel<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(sourcefiles: *const super::Foundation::HANDLE, sourcefilecount: u32, flags: u32, targetfile: Param3) -> super::Foundation::BOOL4345 pub unsafe fn SetCachedSigningLevel<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(sourcefiles: *const super::Foundation::HANDLE, sourcefilecount: u32, flags: u32, targetfile: Param3) -> super::Foundation::BOOL {
4346 #[cfg(windows)]
4347 {
4348 #[link(name = "windows")]
4349 extern "system" {
4350 fn SetCachedSigningLevel(sourcefiles: *const super::Foundation::HANDLE, sourcefilecount: u32, flags: u32, targetfile: super::Foundation::HANDLE) -> super::Foundation::BOOL;
4351 }
4352 ::std::mem::transmute(SetCachedSigningLevel(::std::mem::transmute(sourcefiles), ::std::mem::transmute(sourcefilecount), ::std::mem::transmute(flags), targetfile.into_param().abi()))
4353 }
4354 #[cfg(not(windows))]
4355 unimplemented!("Unsupported target OS");
4356 }
4357 #[cfg(feature = "Win32_Foundation")]
4358 #[inline]
SetFileSecurityA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpfilename: Param0, securityinformation: u32, psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL4359 pub unsafe fn SetFileSecurityA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpfilename: Param0, securityinformation: u32, psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL {
4360 #[cfg(windows)]
4361 {
4362 #[link(name = "windows")]
4363 extern "system" {
4364 fn SetFileSecurityA(lpfilename: super::Foundation::PSTR, securityinformation: u32, psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL;
4365 }
4366 ::std::mem::transmute(SetFileSecurityA(lpfilename.into_param().abi(), ::std::mem::transmute(securityinformation), ::std::mem::transmute(psecuritydescriptor)))
4367 }
4368 #[cfg(not(windows))]
4369 unimplemented!("Unsupported target OS");
4370 }
4371 #[cfg(feature = "Win32_Foundation")]
4372 #[inline]
SetFileSecurityW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpfilename: Param0, securityinformation: u32, psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL4373 pub unsafe fn SetFileSecurityW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpfilename: Param0, securityinformation: u32, psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL {
4374 #[cfg(windows)]
4375 {
4376 #[link(name = "windows")]
4377 extern "system" {
4378 fn SetFileSecurityW(lpfilename: super::Foundation::PWSTR, securityinformation: u32, psecuritydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL;
4379 }
4380 ::std::mem::transmute(SetFileSecurityW(lpfilename.into_param().abi(), ::std::mem::transmute(securityinformation), ::std::mem::transmute(psecuritydescriptor)))
4381 }
4382 #[cfg(not(windows))]
4383 unimplemented!("Unsupported target OS");
4384 }
4385 #[cfg(feature = "Win32_Foundation")]
4386 #[inline]
SetKernelObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(handle: Param0, securityinformation: u32, securitydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL4387 pub unsafe fn SetKernelObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(handle: Param0, securityinformation: u32, securitydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL {
4388 #[cfg(windows)]
4389 {
4390 #[link(name = "windows")]
4391 extern "system" {
4392 fn SetKernelObjectSecurity(handle: super::Foundation::HANDLE, securityinformation: u32, securitydescriptor: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL;
4393 }
4394 ::std::mem::transmute(SetKernelObjectSecurity(handle.into_param().abi(), ::std::mem::transmute(securityinformation), ::std::mem::transmute(securitydescriptor)))
4395 }
4396 #[cfg(not(windows))]
4397 unimplemented!("Unsupported target OS");
4398 }
4399 #[cfg(feature = "Win32_Foundation")]
4400 #[inline]
SetPrivateObjectSecurity<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(securityinformation: u32, modificationdescriptor: *const SECURITY_DESCRIPTOR, objectssecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, genericmapping: *const GENERIC_MAPPING, token: Param4) -> super::Foundation::BOOL4401 pub unsafe fn SetPrivateObjectSecurity<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(securityinformation: u32, modificationdescriptor: *const SECURITY_DESCRIPTOR, objectssecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, genericmapping: *const GENERIC_MAPPING, token: Param4) -> super::Foundation::BOOL {
4402 #[cfg(windows)]
4403 {
4404 #[link(name = "windows")]
4405 extern "system" {
4406 fn SetPrivateObjectSecurity(securityinformation: u32, modificationdescriptor: *const SECURITY_DESCRIPTOR, objectssecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, genericmapping: *const GENERIC_MAPPING, token: super::Foundation::HANDLE) -> super::Foundation::BOOL;
4407 }
4408 ::std::mem::transmute(SetPrivateObjectSecurity(::std::mem::transmute(securityinformation), ::std::mem::transmute(modificationdescriptor), ::std::mem::transmute(objectssecuritydescriptor), ::std::mem::transmute(genericmapping), token.into_param().abi()))
4409 }
4410 #[cfg(not(windows))]
4411 unimplemented!("Unsupported target OS");
4412 }
4413 #[cfg(feature = "Win32_Foundation")]
4414 #[inline]
SetPrivateObjectSecurityEx<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(securityinformation: u32, modificationdescriptor: *const SECURITY_DESCRIPTOR, objectssecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS, genericmapping: *const GENERIC_MAPPING, token: Param5) -> super::Foundation::BOOL4415 pub unsafe fn SetPrivateObjectSecurityEx<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(securityinformation: u32, modificationdescriptor: *const SECURITY_DESCRIPTOR, objectssecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS, genericmapping: *const GENERIC_MAPPING, token: Param5) -> super::Foundation::BOOL {
4416 #[cfg(windows)]
4417 {
4418 #[link(name = "windows")]
4419 extern "system" {
4420 fn SetPrivateObjectSecurityEx(securityinformation: u32, modificationdescriptor: *const SECURITY_DESCRIPTOR, objectssecuritydescriptor: *mut *mut SECURITY_DESCRIPTOR, autoinheritflags: SECURITY_AUTO_INHERIT_FLAGS, genericmapping: *const GENERIC_MAPPING, token: super::Foundation::HANDLE) -> super::Foundation::BOOL;
4421 }
4422 ::std::mem::transmute(SetPrivateObjectSecurityEx(::std::mem::transmute(securityinformation), ::std::mem::transmute(modificationdescriptor), ::std::mem::transmute(objectssecuritydescriptor), ::std::mem::transmute(autoinheritflags), ::std::mem::transmute(genericmapping), token.into_param().abi()))
4423 }
4424 #[cfg(not(windows))]
4425 unimplemented!("Unsupported target OS");
4426 }
4427 #[inline]
SetSecurityAccessMask(securityinformation: u32, desiredaccess: *mut u32)4428 pub unsafe fn SetSecurityAccessMask(securityinformation: u32, desiredaccess: *mut u32) {
4429 #[cfg(windows)]
4430 {
4431 #[link(name = "windows")]
4432 extern "system" {
4433 fn SetSecurityAccessMask(securityinformation: u32, desiredaccess: *mut u32);
4434 }
4435 ::std::mem::transmute(SetSecurityAccessMask(::std::mem::transmute(securityinformation), ::std::mem::transmute(desiredaccess)))
4436 }
4437 #[cfg(not(windows))]
4438 unimplemented!("Unsupported target OS");
4439 }
4440 #[cfg(feature = "Win32_Foundation")]
4441 #[inline]
SetSecurityDescriptorControl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, controlbitsofinterest: u16, controlbitstoset: u16) -> super::Foundation::BOOL4442 pub unsafe fn SetSecurityDescriptorControl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, controlbitsofinterest: u16, controlbitstoset: u16) -> super::Foundation::BOOL {
4443 #[cfg(windows)]
4444 {
4445 #[link(name = "windows")]
4446 extern "system" {
4447 fn SetSecurityDescriptorControl(psecuritydescriptor: *const SECURITY_DESCRIPTOR, controlbitsofinterest: u16, controlbitstoset: u16) -> super::Foundation::BOOL;
4448 }
4449 ::std::mem::transmute(SetSecurityDescriptorControl(::std::mem::transmute(psecuritydescriptor), ::std::mem::transmute(controlbitsofinterest), ::std::mem::transmute(controlbitstoset)))
4450 }
4451 #[cfg(not(windows))]
4452 unimplemented!("Unsupported target OS");
4453 }
4454 #[cfg(feature = "Win32_Foundation")]
4455 #[inline]
SetSecurityDescriptorDacl<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, bdaclpresent: Param1, pdacl: *const ACL, bdacldefaulted: Param3) -> super::Foundation::BOOL4456 pub unsafe fn SetSecurityDescriptorDacl<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, bdaclpresent: Param1, pdacl: *const ACL, bdacldefaulted: Param3) -> super::Foundation::BOOL {
4457 #[cfg(windows)]
4458 {
4459 #[link(name = "windows")]
4460 extern "system" {
4461 fn SetSecurityDescriptorDacl(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, bdaclpresent: super::Foundation::BOOL, pdacl: *const ACL, bdacldefaulted: super::Foundation::BOOL) -> super::Foundation::BOOL;
4462 }
4463 ::std::mem::transmute(SetSecurityDescriptorDacl(::std::mem::transmute(psecuritydescriptor), bdaclpresent.into_param().abi(), ::std::mem::transmute(pdacl), bdacldefaulted.into_param().abi()))
4464 }
4465 #[cfg(not(windows))]
4466 unimplemented!("Unsupported target OS");
4467 }
4468 #[cfg(feature = "Win32_Foundation")]
4469 #[inline]
SetSecurityDescriptorGroup<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, pgroup: Param1, bgroupdefaulted: Param2) -> super::Foundation::BOOL4470 pub unsafe fn SetSecurityDescriptorGroup<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, pgroup: Param1, bgroupdefaulted: Param2) -> super::Foundation::BOOL {
4471 #[cfg(windows)]
4472 {
4473 #[link(name = "windows")]
4474 extern "system" {
4475 fn SetSecurityDescriptorGroup(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, pgroup: super::Foundation::PSID, bgroupdefaulted: super::Foundation::BOOL) -> super::Foundation::BOOL;
4476 }
4477 ::std::mem::transmute(SetSecurityDescriptorGroup(::std::mem::transmute(psecuritydescriptor), pgroup.into_param().abi(), bgroupdefaulted.into_param().abi()))
4478 }
4479 #[cfg(not(windows))]
4480 unimplemented!("Unsupported target OS");
4481 }
4482 #[cfg(feature = "Win32_Foundation")]
4483 #[inline]
SetSecurityDescriptorOwner<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, powner: Param1, bownerdefaulted: Param2) -> super::Foundation::BOOL4484 pub unsafe fn SetSecurityDescriptorOwner<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSID>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, powner: Param1, bownerdefaulted: Param2) -> super::Foundation::BOOL {
4485 #[cfg(windows)]
4486 {
4487 #[link(name = "windows")]
4488 extern "system" {
4489 fn SetSecurityDescriptorOwner(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, powner: super::Foundation::PSID, bownerdefaulted: super::Foundation::BOOL) -> super::Foundation::BOOL;
4490 }
4491 ::std::mem::transmute(SetSecurityDescriptorOwner(::std::mem::transmute(psecuritydescriptor), powner.into_param().abi(), bownerdefaulted.into_param().abi()))
4492 }
4493 #[cfg(not(windows))]
4494 unimplemented!("Unsupported target OS");
4495 }
4496 #[cfg(feature = "Win32_Foundation")]
4497 #[inline]
SetSecurityDescriptorRMControl(securitydescriptor: *mut SECURITY_DESCRIPTOR, rmcontrol: *const u8) -> u324498 pub unsafe fn SetSecurityDescriptorRMControl(securitydescriptor: *mut SECURITY_DESCRIPTOR, rmcontrol: *const u8) -> u32 {
4499 #[cfg(windows)]
4500 {
4501 #[link(name = "windows")]
4502 extern "system" {
4503 fn SetSecurityDescriptorRMControl(securitydescriptor: *mut SECURITY_DESCRIPTOR, rmcontrol: *const u8) -> u32;
4504 }
4505 ::std::mem::transmute(SetSecurityDescriptorRMControl(::std::mem::transmute(securitydescriptor), ::std::mem::transmute(rmcontrol)))
4506 }
4507 #[cfg(not(windows))]
4508 unimplemented!("Unsupported target OS");
4509 }
4510 #[cfg(feature = "Win32_Foundation")]
4511 #[inline]
SetSecurityDescriptorSacl<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, bsaclpresent: Param1, psacl: *const ACL, bsacldefaulted: Param3) -> super::Foundation::BOOL4512 pub unsafe fn SetSecurityDescriptorSacl<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, bsaclpresent: Param1, psacl: *const ACL, bsacldefaulted: Param3) -> super::Foundation::BOOL {
4513 #[cfg(windows)]
4514 {
4515 #[link(name = "windows")]
4516 extern "system" {
4517 fn SetSecurityDescriptorSacl(psecuritydescriptor: *mut SECURITY_DESCRIPTOR, bsaclpresent: super::Foundation::BOOL, psacl: *const ACL, bsacldefaulted: super::Foundation::BOOL) -> super::Foundation::BOOL;
4518 }
4519 ::std::mem::transmute(SetSecurityDescriptorSacl(::std::mem::transmute(psecuritydescriptor), bsaclpresent.into_param().abi(), ::std::mem::transmute(psacl), bsacldefaulted.into_param().abi()))
4520 }
4521 #[cfg(not(windows))]
4522 unimplemented!("Unsupported target OS");
4523 }
4524 #[cfg(feature = "Win32_Foundation")]
4525 #[inline]
SetTokenInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(tokenhandle: Param0, tokeninformationclass: TOKEN_INFORMATION_CLASS, tokeninformation: *const ::std::ffi::c_void, tokeninformationlength: u32) -> super::Foundation::BOOL4526 pub unsafe fn SetTokenInformation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(tokenhandle: Param0, tokeninformationclass: TOKEN_INFORMATION_CLASS, tokeninformation: *const ::std::ffi::c_void, tokeninformationlength: u32) -> super::Foundation::BOOL {
4527 #[cfg(windows)]
4528 {
4529 #[link(name = "windows")]
4530 extern "system" {
4531 fn SetTokenInformation(tokenhandle: super::Foundation::HANDLE, tokeninformationclass: TOKEN_INFORMATION_CLASS, tokeninformation: *const ::std::ffi::c_void, tokeninformationlength: u32) -> super::Foundation::BOOL;
4532 }
4533 ::std::mem::transmute(SetTokenInformation(tokenhandle.into_param().abi(), ::std::mem::transmute(tokeninformationclass), ::std::mem::transmute(tokeninformation), ::std::mem::transmute(tokeninformationlength)))
4534 }
4535 #[cfg(not(windows))]
4536 unimplemented!("Unsupported target OS");
4537 }
4538 #[cfg(feature = "Win32_Foundation")]
4539 #[inline]
SetUserObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(hobj: Param0, psirequested: *const OBJECT_SECURITY_INFORMATION, psid: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL4540 pub unsafe fn SetUserObjectSecurity<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::HANDLE>>(hobj: Param0, psirequested: *const OBJECT_SECURITY_INFORMATION, psid: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL {
4541 #[cfg(windows)]
4542 {
4543 #[link(name = "windows")]
4544 extern "system" {
4545 fn SetUserObjectSecurity(hobj: super::Foundation::HANDLE, psirequested: *const OBJECT_SECURITY_INFORMATION, psid: *const SECURITY_DESCRIPTOR) -> super::Foundation::BOOL;
4546 }
4547 ::std::mem::transmute(SetUserObjectSecurity(hobj.into_param().abi(), ::std::mem::transmute(psirequested), ::std::mem::transmute(psid)))
4548 }
4549 #[cfg(not(windows))]
4550 unimplemented!("Unsupported target OS");
4551 }
4552 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4553 #[repr(C)]
4554 #[cfg(feature = "Win32_Foundation")]
4555 pub struct TOKEN_ACCESS_INFORMATION {
4556 pub SidHash: *mut SID_AND_ATTRIBUTES_HASH,
4557 pub RestrictedSidHash: *mut SID_AND_ATTRIBUTES_HASH,
4558 pub Privileges: *mut TOKEN_PRIVILEGES,
4559 pub AuthenticationId: super::Foundation::LUID,
4560 pub TokenType: TOKEN_TYPE,
4561 pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
4562 pub MandatoryPolicy: TOKEN_MANDATORY_POLICY,
4563 pub Flags: u32,
4564 pub AppContainerNumber: u32,
4565 pub PackageSid: super::Foundation::PSID,
4566 pub CapabilitiesHash: *mut SID_AND_ATTRIBUTES_HASH,
4567 pub TrustLevelSid: super::Foundation::PSID,
4568 pub SecurityAttributes: *mut ::std::ffi::c_void,
4569 }
4570 #[cfg(feature = "Win32_Foundation")]
4571 impl TOKEN_ACCESS_INFORMATION {}
4572 #[cfg(feature = "Win32_Foundation")]
4573 impl ::std::default::Default for TOKEN_ACCESS_INFORMATION {
default() -> Self4574 fn default() -> Self {
4575 unsafe { ::std::mem::zeroed() }
4576 }
4577 }
4578 #[cfg(feature = "Win32_Foundation")]
4579 impl ::std::fmt::Debug for TOKEN_ACCESS_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4580 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4581 fmt.debug_struct("TOKEN_ACCESS_INFORMATION")
4582 .field("SidHash", &self.SidHash)
4583 .field("RestrictedSidHash", &self.RestrictedSidHash)
4584 .field("Privileges", &self.Privileges)
4585 .field("AuthenticationId", &self.AuthenticationId)
4586 .field("TokenType", &self.TokenType)
4587 .field("ImpersonationLevel", &self.ImpersonationLevel)
4588 .field("MandatoryPolicy", &self.MandatoryPolicy)
4589 .field("Flags", &self.Flags)
4590 .field("AppContainerNumber", &self.AppContainerNumber)
4591 .field("PackageSid", &self.PackageSid)
4592 .field("CapabilitiesHash", &self.CapabilitiesHash)
4593 .field("TrustLevelSid", &self.TrustLevelSid)
4594 .field("SecurityAttributes", &self.SecurityAttributes)
4595 .finish()
4596 }
4597 }
4598 #[cfg(feature = "Win32_Foundation")]
4599 impl ::std::cmp::PartialEq for TOKEN_ACCESS_INFORMATION {
eq(&self, other: &Self) -> bool4600 fn eq(&self, other: &Self) -> bool {
4601 self.SidHash == other.SidHash
4602 && self.RestrictedSidHash == other.RestrictedSidHash
4603 && self.Privileges == other.Privileges
4604 && self.AuthenticationId == other.AuthenticationId
4605 && self.TokenType == other.TokenType
4606 && self.ImpersonationLevel == other.ImpersonationLevel
4607 && self.MandatoryPolicy == other.MandatoryPolicy
4608 && self.Flags == other.Flags
4609 && self.AppContainerNumber == other.AppContainerNumber
4610 && self.PackageSid == other.PackageSid
4611 && self.CapabilitiesHash == other.CapabilitiesHash
4612 && self.TrustLevelSid == other.TrustLevelSid
4613 && self.SecurityAttributes == other.SecurityAttributes
4614 }
4615 }
4616 #[cfg(feature = "Win32_Foundation")]
4617 impl ::std::cmp::Eq for TOKEN_ACCESS_INFORMATION {}
4618 #[cfg(feature = "Win32_Foundation")]
4619 unsafe impl ::windows::runtime::Abi for TOKEN_ACCESS_INFORMATION {
4620 type Abi = Self;
4621 type DefaultType = Self;
4622 }
4623 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4624 #[repr(transparent)]
4625 pub struct TOKEN_ACCESS_MASK(pub u32);
4626 pub const TOKEN_DELETE: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(65536u32);
4627 pub const TOKEN_READ_CONTROL: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(131072u32);
4628 pub const TOKEN_WRITE_DAC: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(262144u32);
4629 pub const TOKEN_WRITE_OWNER: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(524288u32);
4630 pub const TOKEN_ACCESS_SYSTEM_SECURITY: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(16777216u32);
4631 pub const TOKEN_ASSIGN_PRIMARY: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(1u32);
4632 pub const TOKEN_DUPLICATE: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(2u32);
4633 pub const TOKEN_IMPERSONATE: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(4u32);
4634 pub const TOKEN_QUERY: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(8u32);
4635 pub const TOKEN_QUERY_SOURCE: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(16u32);
4636 pub const TOKEN_ADJUST_PRIVILEGES: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(32u32);
4637 pub const TOKEN_ADJUST_GROUPS: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(64u32);
4638 pub const TOKEN_ADJUST_DEFAULT: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(128u32);
4639 pub const TOKEN_ADJUST_SESSIONID: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(256u32);
4640 pub const TOKEN_ALL_ACCESS: TOKEN_ACCESS_MASK = TOKEN_ACCESS_MASK(983295u32);
4641 impl ::std::convert::From<u32> for TOKEN_ACCESS_MASK {
from(value: u32) -> Self4642 fn from(value: u32) -> Self {
4643 Self(value)
4644 }
4645 }
4646 unsafe impl ::windows::runtime::Abi for TOKEN_ACCESS_MASK {
4647 type Abi = Self;
4648 type DefaultType = Self;
4649 }
4650 impl ::std::ops::BitOr for TOKEN_ACCESS_MASK {
4651 type Output = Self;
bitor(self, rhs: Self) -> Self4652 fn bitor(self, rhs: Self) -> Self {
4653 Self(self.0 | rhs.0)
4654 }
4655 }
4656 impl ::std::ops::BitAnd for TOKEN_ACCESS_MASK {
4657 type Output = Self;
bitand(self, rhs: Self) -> Self4658 fn bitand(self, rhs: Self) -> Self {
4659 Self(self.0 & rhs.0)
4660 }
4661 }
4662 impl ::std::ops::BitOrAssign for TOKEN_ACCESS_MASK {
bitor_assign(&mut self, rhs: Self)4663 fn bitor_assign(&mut self, rhs: Self) {
4664 self.0.bitor_assign(rhs.0)
4665 }
4666 }
4667 impl ::std::ops::BitAndAssign for TOKEN_ACCESS_MASK {
bitand_assign(&mut self, rhs: Self)4668 fn bitand_assign(&mut self, rhs: Self) {
4669 self.0.bitand_assign(rhs.0)
4670 }
4671 }
4672 impl ::std::ops::Not for TOKEN_ACCESS_MASK {
4673 type Output = Self;
not(self) -> Self4674 fn not(self) -> Self {
4675 Self(self.0.not())
4676 }
4677 }
4678 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4679 #[repr(C)]
4680 #[cfg(feature = "Win32_Foundation")]
4681 pub struct TOKEN_APPCONTAINER_INFORMATION {
4682 pub TokenAppContainer: super::Foundation::PSID,
4683 }
4684 #[cfg(feature = "Win32_Foundation")]
4685 impl TOKEN_APPCONTAINER_INFORMATION {}
4686 #[cfg(feature = "Win32_Foundation")]
4687 impl ::std::default::Default for TOKEN_APPCONTAINER_INFORMATION {
default() -> Self4688 fn default() -> Self {
4689 unsafe { ::std::mem::zeroed() }
4690 }
4691 }
4692 #[cfg(feature = "Win32_Foundation")]
4693 impl ::std::fmt::Debug for TOKEN_APPCONTAINER_INFORMATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4694 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4695 fmt.debug_struct("TOKEN_APPCONTAINER_INFORMATION").field("TokenAppContainer", &self.TokenAppContainer).finish()
4696 }
4697 }
4698 #[cfg(feature = "Win32_Foundation")]
4699 impl ::std::cmp::PartialEq for TOKEN_APPCONTAINER_INFORMATION {
eq(&self, other: &Self) -> bool4700 fn eq(&self, other: &Self) -> bool {
4701 self.TokenAppContainer == other.TokenAppContainer
4702 }
4703 }
4704 #[cfg(feature = "Win32_Foundation")]
4705 impl ::std::cmp::Eq for TOKEN_APPCONTAINER_INFORMATION {}
4706 #[cfg(feature = "Win32_Foundation")]
4707 unsafe impl ::windows::runtime::Abi for TOKEN_APPCONTAINER_INFORMATION {
4708 type Abi = Self;
4709 type DefaultType = Self;
4710 }
4711 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4712 #[repr(C)]
4713 pub struct TOKEN_AUDIT_POLICY {
4714 pub PerUserPolicy: [u8; 30],
4715 }
4716 impl TOKEN_AUDIT_POLICY {}
4717 impl ::std::default::Default for TOKEN_AUDIT_POLICY {
default() -> Self4718 fn default() -> Self {
4719 unsafe { ::std::mem::zeroed() }
4720 }
4721 }
4722 impl ::std::fmt::Debug for TOKEN_AUDIT_POLICY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4723 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4724 fmt.debug_struct("TOKEN_AUDIT_POLICY").field("PerUserPolicy", &self.PerUserPolicy).finish()
4725 }
4726 }
4727 impl ::std::cmp::PartialEq for TOKEN_AUDIT_POLICY {
eq(&self, other: &Self) -> bool4728 fn eq(&self, other: &Self) -> bool {
4729 self.PerUserPolicy == other.PerUserPolicy
4730 }
4731 }
4732 impl ::std::cmp::Eq for TOKEN_AUDIT_POLICY {}
4733 unsafe impl ::windows::runtime::Abi for TOKEN_AUDIT_POLICY {
4734 type Abi = Self;
4735 type DefaultType = Self;
4736 }
4737 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4738 #[repr(C)]
4739 #[cfg(feature = "Win32_Foundation")]
4740 pub struct TOKEN_CONTROL {
4741 pub TokenId: super::Foundation::LUID,
4742 pub AuthenticationId: super::Foundation::LUID,
4743 pub ModifiedId: super::Foundation::LUID,
4744 pub TokenSource: TOKEN_SOURCE,
4745 }
4746 #[cfg(feature = "Win32_Foundation")]
4747 impl TOKEN_CONTROL {}
4748 #[cfg(feature = "Win32_Foundation")]
4749 impl ::std::default::Default for TOKEN_CONTROL {
default() -> Self4750 fn default() -> Self {
4751 unsafe { ::std::mem::zeroed() }
4752 }
4753 }
4754 #[cfg(feature = "Win32_Foundation")]
4755 impl ::std::fmt::Debug for TOKEN_CONTROL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4756 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4757 fmt.debug_struct("TOKEN_CONTROL").field("TokenId", &self.TokenId).field("AuthenticationId", &self.AuthenticationId).field("ModifiedId", &self.ModifiedId).field("TokenSource", &self.TokenSource).finish()
4758 }
4759 }
4760 #[cfg(feature = "Win32_Foundation")]
4761 impl ::std::cmp::PartialEq for TOKEN_CONTROL {
eq(&self, other: &Self) -> bool4762 fn eq(&self, other: &Self) -> bool {
4763 self.TokenId == other.TokenId && self.AuthenticationId == other.AuthenticationId && self.ModifiedId == other.ModifiedId && self.TokenSource == other.TokenSource
4764 }
4765 }
4766 #[cfg(feature = "Win32_Foundation")]
4767 impl ::std::cmp::Eq for TOKEN_CONTROL {}
4768 #[cfg(feature = "Win32_Foundation")]
4769 unsafe impl ::windows::runtime::Abi for TOKEN_CONTROL {
4770 type Abi = Self;
4771 type DefaultType = Self;
4772 }
4773 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4774 #[repr(C)]
4775 pub struct TOKEN_DEFAULT_DACL {
4776 pub DefaultDacl: *mut ACL,
4777 }
4778 impl TOKEN_DEFAULT_DACL {}
4779 impl ::std::default::Default for TOKEN_DEFAULT_DACL {
default() -> Self4780 fn default() -> Self {
4781 unsafe { ::std::mem::zeroed() }
4782 }
4783 }
4784 impl ::std::fmt::Debug for TOKEN_DEFAULT_DACL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4785 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4786 fmt.debug_struct("TOKEN_DEFAULT_DACL").field("DefaultDacl", &self.DefaultDacl).finish()
4787 }
4788 }
4789 impl ::std::cmp::PartialEq for TOKEN_DEFAULT_DACL {
eq(&self, other: &Self) -> bool4790 fn eq(&self, other: &Self) -> bool {
4791 self.DefaultDacl == other.DefaultDacl
4792 }
4793 }
4794 impl ::std::cmp::Eq for TOKEN_DEFAULT_DACL {}
4795 unsafe impl ::windows::runtime::Abi for TOKEN_DEFAULT_DACL {
4796 type Abi = Self;
4797 type DefaultType = Self;
4798 }
4799 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4800 #[repr(C)]
4801 pub struct TOKEN_DEVICE_CLAIMS {
4802 pub DeviceClaims: *mut ::std::ffi::c_void,
4803 }
4804 impl TOKEN_DEVICE_CLAIMS {}
4805 impl ::std::default::Default for TOKEN_DEVICE_CLAIMS {
default() -> Self4806 fn default() -> Self {
4807 unsafe { ::std::mem::zeroed() }
4808 }
4809 }
4810 impl ::std::fmt::Debug for TOKEN_DEVICE_CLAIMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4811 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4812 fmt.debug_struct("TOKEN_DEVICE_CLAIMS").field("DeviceClaims", &self.DeviceClaims).finish()
4813 }
4814 }
4815 impl ::std::cmp::PartialEq for TOKEN_DEVICE_CLAIMS {
eq(&self, other: &Self) -> bool4816 fn eq(&self, other: &Self) -> bool {
4817 self.DeviceClaims == other.DeviceClaims
4818 }
4819 }
4820 impl ::std::cmp::Eq for TOKEN_DEVICE_CLAIMS {}
4821 unsafe impl ::windows::runtime::Abi for TOKEN_DEVICE_CLAIMS {
4822 type Abi = Self;
4823 type DefaultType = Self;
4824 }
4825 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4826 #[repr(C)]
4827 pub struct TOKEN_ELEVATION {
4828 pub TokenIsElevated: u32,
4829 }
4830 impl TOKEN_ELEVATION {}
4831 impl ::std::default::Default for TOKEN_ELEVATION {
default() -> Self4832 fn default() -> Self {
4833 unsafe { ::std::mem::zeroed() }
4834 }
4835 }
4836 impl ::std::fmt::Debug for TOKEN_ELEVATION {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4837 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4838 fmt.debug_struct("TOKEN_ELEVATION").field("TokenIsElevated", &self.TokenIsElevated).finish()
4839 }
4840 }
4841 impl ::std::cmp::PartialEq for TOKEN_ELEVATION {
eq(&self, other: &Self) -> bool4842 fn eq(&self, other: &Self) -> bool {
4843 self.TokenIsElevated == other.TokenIsElevated
4844 }
4845 }
4846 impl ::std::cmp::Eq for TOKEN_ELEVATION {}
4847 unsafe impl ::windows::runtime::Abi for TOKEN_ELEVATION {
4848 type Abi = Self;
4849 type DefaultType = Self;
4850 }
4851 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4852 #[repr(transparent)]
4853 pub struct TOKEN_ELEVATION_TYPE(pub i32);
4854 pub const TokenElevationTypeDefault: TOKEN_ELEVATION_TYPE = TOKEN_ELEVATION_TYPE(1i32);
4855 pub const TokenElevationTypeFull: TOKEN_ELEVATION_TYPE = TOKEN_ELEVATION_TYPE(2i32);
4856 pub const TokenElevationTypeLimited: TOKEN_ELEVATION_TYPE = TOKEN_ELEVATION_TYPE(3i32);
4857 impl ::std::convert::From<i32> for TOKEN_ELEVATION_TYPE {
from(value: i32) -> Self4858 fn from(value: i32) -> Self {
4859 Self(value)
4860 }
4861 }
4862 unsafe impl ::windows::runtime::Abi for TOKEN_ELEVATION_TYPE {
4863 type Abi = Self;
4864 type DefaultType = Self;
4865 }
4866 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4867 #[repr(C)]
4868 #[cfg(feature = "Win32_Foundation")]
4869 pub struct TOKEN_GROUPS {
4870 pub GroupCount: u32,
4871 pub Groups: [SID_AND_ATTRIBUTES; 1],
4872 }
4873 #[cfg(feature = "Win32_Foundation")]
4874 impl TOKEN_GROUPS {}
4875 #[cfg(feature = "Win32_Foundation")]
4876 impl ::std::default::Default for TOKEN_GROUPS {
default() -> Self4877 fn default() -> Self {
4878 unsafe { ::std::mem::zeroed() }
4879 }
4880 }
4881 #[cfg(feature = "Win32_Foundation")]
4882 impl ::std::fmt::Debug for TOKEN_GROUPS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4883 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4884 fmt.debug_struct("TOKEN_GROUPS").field("GroupCount", &self.GroupCount).field("Groups", &self.Groups).finish()
4885 }
4886 }
4887 #[cfg(feature = "Win32_Foundation")]
4888 impl ::std::cmp::PartialEq for TOKEN_GROUPS {
eq(&self, other: &Self) -> bool4889 fn eq(&self, other: &Self) -> bool {
4890 self.GroupCount == other.GroupCount && self.Groups == other.Groups
4891 }
4892 }
4893 #[cfg(feature = "Win32_Foundation")]
4894 impl ::std::cmp::Eq for TOKEN_GROUPS {}
4895 #[cfg(feature = "Win32_Foundation")]
4896 unsafe impl ::windows::runtime::Abi for TOKEN_GROUPS {
4897 type Abi = Self;
4898 type DefaultType = Self;
4899 }
4900 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4901 #[repr(C)]
4902 #[cfg(feature = "Win32_Foundation")]
4903 pub struct TOKEN_GROUPS_AND_PRIVILEGES {
4904 pub SidCount: u32,
4905 pub SidLength: u32,
4906 pub Sids: *mut SID_AND_ATTRIBUTES,
4907 pub RestrictedSidCount: u32,
4908 pub RestrictedSidLength: u32,
4909 pub RestrictedSids: *mut SID_AND_ATTRIBUTES,
4910 pub PrivilegeCount: u32,
4911 pub PrivilegeLength: u32,
4912 pub Privileges: *mut LUID_AND_ATTRIBUTES,
4913 pub AuthenticationId: super::Foundation::LUID,
4914 }
4915 #[cfg(feature = "Win32_Foundation")]
4916 impl TOKEN_GROUPS_AND_PRIVILEGES {}
4917 #[cfg(feature = "Win32_Foundation")]
4918 impl ::std::default::Default for TOKEN_GROUPS_AND_PRIVILEGES {
default() -> Self4919 fn default() -> Self {
4920 unsafe { ::std::mem::zeroed() }
4921 }
4922 }
4923 #[cfg(feature = "Win32_Foundation")]
4924 impl ::std::fmt::Debug for TOKEN_GROUPS_AND_PRIVILEGES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4925 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4926 fmt.debug_struct("TOKEN_GROUPS_AND_PRIVILEGES")
4927 .field("SidCount", &self.SidCount)
4928 .field("SidLength", &self.SidLength)
4929 .field("Sids", &self.Sids)
4930 .field("RestrictedSidCount", &self.RestrictedSidCount)
4931 .field("RestrictedSidLength", &self.RestrictedSidLength)
4932 .field("RestrictedSids", &self.RestrictedSids)
4933 .field("PrivilegeCount", &self.PrivilegeCount)
4934 .field("PrivilegeLength", &self.PrivilegeLength)
4935 .field("Privileges", &self.Privileges)
4936 .field("AuthenticationId", &self.AuthenticationId)
4937 .finish()
4938 }
4939 }
4940 #[cfg(feature = "Win32_Foundation")]
4941 impl ::std::cmp::PartialEq for TOKEN_GROUPS_AND_PRIVILEGES {
eq(&self, other: &Self) -> bool4942 fn eq(&self, other: &Self) -> bool {
4943 self.SidCount == other.SidCount && self.SidLength == other.SidLength && self.Sids == other.Sids && self.RestrictedSidCount == other.RestrictedSidCount && self.RestrictedSidLength == other.RestrictedSidLength && self.RestrictedSids == other.RestrictedSids && self.PrivilegeCount == other.PrivilegeCount && self.PrivilegeLength == other.PrivilegeLength && self.Privileges == other.Privileges && self.AuthenticationId == other.AuthenticationId
4944 }
4945 }
4946 #[cfg(feature = "Win32_Foundation")]
4947 impl ::std::cmp::Eq for TOKEN_GROUPS_AND_PRIVILEGES {}
4948 #[cfg(feature = "Win32_Foundation")]
4949 unsafe impl ::windows::runtime::Abi for TOKEN_GROUPS_AND_PRIVILEGES {
4950 type Abi = Self;
4951 type DefaultType = Self;
4952 }
4953 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4954 #[repr(transparent)]
4955 pub struct TOKEN_INFORMATION_CLASS(pub i32);
4956 pub const TokenUser: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(1i32);
4957 pub const TokenGroups: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(2i32);
4958 pub const TokenPrivileges: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(3i32);
4959 pub const TokenOwner: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(4i32);
4960 pub const TokenPrimaryGroup: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(5i32);
4961 pub const TokenDefaultDacl: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(6i32);
4962 pub const TokenSource: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(7i32);
4963 pub const TokenType: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(8i32);
4964 pub const TokenImpersonationLevel: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(9i32);
4965 pub const TokenStatistics: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(10i32);
4966 pub const TokenRestrictedSids: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(11i32);
4967 pub const TokenSessionId: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(12i32);
4968 pub const TokenGroupsAndPrivileges: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(13i32);
4969 pub const TokenSessionReference: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(14i32);
4970 pub const TokenSandBoxInert: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(15i32);
4971 pub const TokenAuditPolicy: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(16i32);
4972 pub const TokenOrigin: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(17i32);
4973 pub const TokenElevationType: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(18i32);
4974 pub const TokenLinkedToken: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(19i32);
4975 pub const TokenElevation: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(20i32);
4976 pub const TokenHasRestrictions: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(21i32);
4977 pub const TokenAccessInformation: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(22i32);
4978 pub const TokenVirtualizationAllowed: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(23i32);
4979 pub const TokenVirtualizationEnabled: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(24i32);
4980 pub const TokenIntegrityLevel: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(25i32);
4981 pub const TokenUIAccess: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(26i32);
4982 pub const TokenMandatoryPolicy: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(27i32);
4983 pub const TokenLogonSid: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(28i32);
4984 pub const TokenIsAppContainer: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(29i32);
4985 pub const TokenCapabilities: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(30i32);
4986 pub const TokenAppContainerSid: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(31i32);
4987 pub const TokenAppContainerNumber: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(32i32);
4988 pub const TokenUserClaimAttributes: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(33i32);
4989 pub const TokenDeviceClaimAttributes: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(34i32);
4990 pub const TokenRestrictedUserClaimAttributes: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(35i32);
4991 pub const TokenRestrictedDeviceClaimAttributes: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(36i32);
4992 pub const TokenDeviceGroups: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(37i32);
4993 pub const TokenRestrictedDeviceGroups: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(38i32);
4994 pub const TokenSecurityAttributes: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(39i32);
4995 pub const TokenIsRestricted: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(40i32);
4996 pub const TokenProcessTrustLevel: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(41i32);
4997 pub const TokenPrivateNameSpace: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(42i32);
4998 pub const TokenSingletonAttributes: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(43i32);
4999 pub const TokenBnoIsolation: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(44i32);
5000 pub const TokenChildProcessFlags: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(45i32);
5001 pub const TokenIsLessPrivilegedAppContainer: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(46i32);
5002 pub const TokenIsSandboxed: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(47i32);
5003 pub const MaxTokenInfoClass: TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS(48i32);
5004 impl ::std::convert::From<i32> for TOKEN_INFORMATION_CLASS {
from(value: i32) -> Self5005 fn from(value: i32) -> Self {
5006 Self(value)
5007 }
5008 }
5009 unsafe impl ::windows::runtime::Abi for TOKEN_INFORMATION_CLASS {
5010 type Abi = Self;
5011 type DefaultType = Self;
5012 }
5013 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5014 #[repr(C)]
5015 #[cfg(feature = "Win32_Foundation")]
5016 pub struct TOKEN_LINKED_TOKEN {
5017 pub LinkedToken: super::Foundation::HANDLE,
5018 }
5019 #[cfg(feature = "Win32_Foundation")]
5020 impl TOKEN_LINKED_TOKEN {}
5021 #[cfg(feature = "Win32_Foundation")]
5022 impl ::std::default::Default for TOKEN_LINKED_TOKEN {
default() -> Self5023 fn default() -> Self {
5024 unsafe { ::std::mem::zeroed() }
5025 }
5026 }
5027 #[cfg(feature = "Win32_Foundation")]
5028 impl ::std::fmt::Debug for TOKEN_LINKED_TOKEN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5029 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5030 fmt.debug_struct("TOKEN_LINKED_TOKEN").field("LinkedToken", &self.LinkedToken).finish()
5031 }
5032 }
5033 #[cfg(feature = "Win32_Foundation")]
5034 impl ::std::cmp::PartialEq for TOKEN_LINKED_TOKEN {
eq(&self, other: &Self) -> bool5035 fn eq(&self, other: &Self) -> bool {
5036 self.LinkedToken == other.LinkedToken
5037 }
5038 }
5039 #[cfg(feature = "Win32_Foundation")]
5040 impl ::std::cmp::Eq for TOKEN_LINKED_TOKEN {}
5041 #[cfg(feature = "Win32_Foundation")]
5042 unsafe impl ::windows::runtime::Abi for TOKEN_LINKED_TOKEN {
5043 type Abi = Self;
5044 type DefaultType = Self;
5045 }
5046 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5047 #[repr(C)]
5048 #[cfg(feature = "Win32_Foundation")]
5049 pub struct TOKEN_MANDATORY_LABEL {
5050 pub Label: SID_AND_ATTRIBUTES,
5051 }
5052 #[cfg(feature = "Win32_Foundation")]
5053 impl TOKEN_MANDATORY_LABEL {}
5054 #[cfg(feature = "Win32_Foundation")]
5055 impl ::std::default::Default for TOKEN_MANDATORY_LABEL {
default() -> Self5056 fn default() -> Self {
5057 unsafe { ::std::mem::zeroed() }
5058 }
5059 }
5060 #[cfg(feature = "Win32_Foundation")]
5061 impl ::std::fmt::Debug for TOKEN_MANDATORY_LABEL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5062 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5063 fmt.debug_struct("TOKEN_MANDATORY_LABEL").field("Label", &self.Label).finish()
5064 }
5065 }
5066 #[cfg(feature = "Win32_Foundation")]
5067 impl ::std::cmp::PartialEq for TOKEN_MANDATORY_LABEL {
eq(&self, other: &Self) -> bool5068 fn eq(&self, other: &Self) -> bool {
5069 self.Label == other.Label
5070 }
5071 }
5072 #[cfg(feature = "Win32_Foundation")]
5073 impl ::std::cmp::Eq for TOKEN_MANDATORY_LABEL {}
5074 #[cfg(feature = "Win32_Foundation")]
5075 unsafe impl ::windows::runtime::Abi for TOKEN_MANDATORY_LABEL {
5076 type Abi = Self;
5077 type DefaultType = Self;
5078 }
5079 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5080 #[repr(C)]
5081 pub struct TOKEN_MANDATORY_POLICY {
5082 pub Policy: TOKEN_MANDATORY_POLICY_ID,
5083 }
5084 impl TOKEN_MANDATORY_POLICY {}
5085 impl ::std::default::Default for TOKEN_MANDATORY_POLICY {
default() -> Self5086 fn default() -> Self {
5087 unsafe { ::std::mem::zeroed() }
5088 }
5089 }
5090 impl ::std::fmt::Debug for TOKEN_MANDATORY_POLICY {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5091 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5092 fmt.debug_struct("TOKEN_MANDATORY_POLICY").field("Policy", &self.Policy).finish()
5093 }
5094 }
5095 impl ::std::cmp::PartialEq for TOKEN_MANDATORY_POLICY {
eq(&self, other: &Self) -> bool5096 fn eq(&self, other: &Self) -> bool {
5097 self.Policy == other.Policy
5098 }
5099 }
5100 impl ::std::cmp::Eq for TOKEN_MANDATORY_POLICY {}
5101 unsafe impl ::windows::runtime::Abi for TOKEN_MANDATORY_POLICY {
5102 type Abi = Self;
5103 type DefaultType = Self;
5104 }
5105 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5106 #[repr(transparent)]
5107 pub struct TOKEN_MANDATORY_POLICY_ID(pub u32);
5108 pub const TOKEN_MANDATORY_POLICY_OFF: TOKEN_MANDATORY_POLICY_ID = TOKEN_MANDATORY_POLICY_ID(0u32);
5109 pub const TOKEN_MANDATORY_POLICY_NO_WRITE_UP: TOKEN_MANDATORY_POLICY_ID = TOKEN_MANDATORY_POLICY_ID(1u32);
5110 pub const TOKEN_MANDATORY_POLICY_NEW_PROCESS_MIN: TOKEN_MANDATORY_POLICY_ID = TOKEN_MANDATORY_POLICY_ID(2u32);
5111 pub const TOKEN_MANDATORY_POLICY_VALID_MASK: TOKEN_MANDATORY_POLICY_ID = TOKEN_MANDATORY_POLICY_ID(3u32);
5112 impl ::std::convert::From<u32> for TOKEN_MANDATORY_POLICY_ID {
from(value: u32) -> Self5113 fn from(value: u32) -> Self {
5114 Self(value)
5115 }
5116 }
5117 unsafe impl ::windows::runtime::Abi for TOKEN_MANDATORY_POLICY_ID {
5118 type Abi = Self;
5119 type DefaultType = Self;
5120 }
5121 impl ::std::ops::BitOr for TOKEN_MANDATORY_POLICY_ID {
5122 type Output = Self;
bitor(self, rhs: Self) -> Self5123 fn bitor(self, rhs: Self) -> Self {
5124 Self(self.0 | rhs.0)
5125 }
5126 }
5127 impl ::std::ops::BitAnd for TOKEN_MANDATORY_POLICY_ID {
5128 type Output = Self;
bitand(self, rhs: Self) -> Self5129 fn bitand(self, rhs: Self) -> Self {
5130 Self(self.0 & rhs.0)
5131 }
5132 }
5133 impl ::std::ops::BitOrAssign for TOKEN_MANDATORY_POLICY_ID {
bitor_assign(&mut self, rhs: Self)5134 fn bitor_assign(&mut self, rhs: Self) {
5135 self.0.bitor_assign(rhs.0)
5136 }
5137 }
5138 impl ::std::ops::BitAndAssign for TOKEN_MANDATORY_POLICY_ID {
bitand_assign(&mut self, rhs: Self)5139 fn bitand_assign(&mut self, rhs: Self) {
5140 self.0.bitand_assign(rhs.0)
5141 }
5142 }
5143 impl ::std::ops::Not for TOKEN_MANDATORY_POLICY_ID {
5144 type Output = Self;
not(self) -> Self5145 fn not(self) -> Self {
5146 Self(self.0.not())
5147 }
5148 }
5149 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5150 #[repr(C)]
5151 #[cfg(feature = "Win32_Foundation")]
5152 pub struct TOKEN_ORIGIN {
5153 pub OriginatingLogonSession: super::Foundation::LUID,
5154 }
5155 #[cfg(feature = "Win32_Foundation")]
5156 impl TOKEN_ORIGIN {}
5157 #[cfg(feature = "Win32_Foundation")]
5158 impl ::std::default::Default for TOKEN_ORIGIN {
default() -> Self5159 fn default() -> Self {
5160 unsafe { ::std::mem::zeroed() }
5161 }
5162 }
5163 #[cfg(feature = "Win32_Foundation")]
5164 impl ::std::fmt::Debug for TOKEN_ORIGIN {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5165 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5166 fmt.debug_struct("TOKEN_ORIGIN").field("OriginatingLogonSession", &self.OriginatingLogonSession).finish()
5167 }
5168 }
5169 #[cfg(feature = "Win32_Foundation")]
5170 impl ::std::cmp::PartialEq for TOKEN_ORIGIN {
eq(&self, other: &Self) -> bool5171 fn eq(&self, other: &Self) -> bool {
5172 self.OriginatingLogonSession == other.OriginatingLogonSession
5173 }
5174 }
5175 #[cfg(feature = "Win32_Foundation")]
5176 impl ::std::cmp::Eq for TOKEN_ORIGIN {}
5177 #[cfg(feature = "Win32_Foundation")]
5178 unsafe impl ::windows::runtime::Abi for TOKEN_ORIGIN {
5179 type Abi = Self;
5180 type DefaultType = Self;
5181 }
5182 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5183 #[repr(C)]
5184 #[cfg(feature = "Win32_Foundation")]
5185 pub struct TOKEN_OWNER {
5186 pub Owner: super::Foundation::PSID,
5187 }
5188 #[cfg(feature = "Win32_Foundation")]
5189 impl TOKEN_OWNER {}
5190 #[cfg(feature = "Win32_Foundation")]
5191 impl ::std::default::Default for TOKEN_OWNER {
default() -> Self5192 fn default() -> Self {
5193 unsafe { ::std::mem::zeroed() }
5194 }
5195 }
5196 #[cfg(feature = "Win32_Foundation")]
5197 impl ::std::fmt::Debug for TOKEN_OWNER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5198 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5199 fmt.debug_struct("TOKEN_OWNER").field("Owner", &self.Owner).finish()
5200 }
5201 }
5202 #[cfg(feature = "Win32_Foundation")]
5203 impl ::std::cmp::PartialEq for TOKEN_OWNER {
eq(&self, other: &Self) -> bool5204 fn eq(&self, other: &Self) -> bool {
5205 self.Owner == other.Owner
5206 }
5207 }
5208 #[cfg(feature = "Win32_Foundation")]
5209 impl ::std::cmp::Eq for TOKEN_OWNER {}
5210 #[cfg(feature = "Win32_Foundation")]
5211 unsafe impl ::windows::runtime::Abi for TOKEN_OWNER {
5212 type Abi = Self;
5213 type DefaultType = Self;
5214 }
5215 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5216 #[repr(C)]
5217 #[cfg(feature = "Win32_Foundation")]
5218 pub struct TOKEN_PRIMARY_GROUP {
5219 pub PrimaryGroup: super::Foundation::PSID,
5220 }
5221 #[cfg(feature = "Win32_Foundation")]
5222 impl TOKEN_PRIMARY_GROUP {}
5223 #[cfg(feature = "Win32_Foundation")]
5224 impl ::std::default::Default for TOKEN_PRIMARY_GROUP {
default() -> Self5225 fn default() -> Self {
5226 unsafe { ::std::mem::zeroed() }
5227 }
5228 }
5229 #[cfg(feature = "Win32_Foundation")]
5230 impl ::std::fmt::Debug for TOKEN_PRIMARY_GROUP {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5231 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5232 fmt.debug_struct("TOKEN_PRIMARY_GROUP").field("PrimaryGroup", &self.PrimaryGroup).finish()
5233 }
5234 }
5235 #[cfg(feature = "Win32_Foundation")]
5236 impl ::std::cmp::PartialEq for TOKEN_PRIMARY_GROUP {
eq(&self, other: &Self) -> bool5237 fn eq(&self, other: &Self) -> bool {
5238 self.PrimaryGroup == other.PrimaryGroup
5239 }
5240 }
5241 #[cfg(feature = "Win32_Foundation")]
5242 impl ::std::cmp::Eq for TOKEN_PRIMARY_GROUP {}
5243 #[cfg(feature = "Win32_Foundation")]
5244 unsafe impl ::windows::runtime::Abi for TOKEN_PRIMARY_GROUP {
5245 type Abi = Self;
5246 type DefaultType = Self;
5247 }
5248 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5249 #[repr(C)]
5250 #[cfg(feature = "Win32_Foundation")]
5251 pub struct TOKEN_PRIVILEGES {
5252 pub PrivilegeCount: u32,
5253 pub Privileges: [LUID_AND_ATTRIBUTES; 1],
5254 }
5255 #[cfg(feature = "Win32_Foundation")]
5256 impl TOKEN_PRIVILEGES {}
5257 #[cfg(feature = "Win32_Foundation")]
5258 impl ::std::default::Default for TOKEN_PRIVILEGES {
default() -> Self5259 fn default() -> Self {
5260 unsafe { ::std::mem::zeroed() }
5261 }
5262 }
5263 #[cfg(feature = "Win32_Foundation")]
5264 impl ::std::fmt::Debug for TOKEN_PRIVILEGES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5265 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5266 fmt.debug_struct("TOKEN_PRIVILEGES").field("PrivilegeCount", &self.PrivilegeCount).field("Privileges", &self.Privileges).finish()
5267 }
5268 }
5269 #[cfg(feature = "Win32_Foundation")]
5270 impl ::std::cmp::PartialEq for TOKEN_PRIVILEGES {
eq(&self, other: &Self) -> bool5271 fn eq(&self, other: &Self) -> bool {
5272 self.PrivilegeCount == other.PrivilegeCount && self.Privileges == other.Privileges
5273 }
5274 }
5275 #[cfg(feature = "Win32_Foundation")]
5276 impl ::std::cmp::Eq for TOKEN_PRIVILEGES {}
5277 #[cfg(feature = "Win32_Foundation")]
5278 unsafe impl ::windows::runtime::Abi for TOKEN_PRIVILEGES {
5279 type Abi = Self;
5280 type DefaultType = Self;
5281 }
5282 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5283 #[repr(transparent)]
5284 pub struct TOKEN_PRIVILEGES_ATTRIBUTES(pub u32);
5285 pub const SE_PRIVILEGE_ENABLED: TOKEN_PRIVILEGES_ATTRIBUTES = TOKEN_PRIVILEGES_ATTRIBUTES(2u32);
5286 pub const SE_PRIVILEGE_ENABLED_BY_DEFAULT: TOKEN_PRIVILEGES_ATTRIBUTES = TOKEN_PRIVILEGES_ATTRIBUTES(1u32);
5287 pub const SE_PRIVILEGE_REMOVED: TOKEN_PRIVILEGES_ATTRIBUTES = TOKEN_PRIVILEGES_ATTRIBUTES(4u32);
5288 pub const SE_PRIVILEGE_USED_FOR_ACCESS: TOKEN_PRIVILEGES_ATTRIBUTES = TOKEN_PRIVILEGES_ATTRIBUTES(2147483648u32);
5289 impl ::std::convert::From<u32> for TOKEN_PRIVILEGES_ATTRIBUTES {
from(value: u32) -> Self5290 fn from(value: u32) -> Self {
5291 Self(value)
5292 }
5293 }
5294 unsafe impl ::windows::runtime::Abi for TOKEN_PRIVILEGES_ATTRIBUTES {
5295 type Abi = Self;
5296 type DefaultType = Self;
5297 }
5298 impl ::std::ops::BitOr for TOKEN_PRIVILEGES_ATTRIBUTES {
5299 type Output = Self;
bitor(self, rhs: Self) -> Self5300 fn bitor(self, rhs: Self) -> Self {
5301 Self(self.0 | rhs.0)
5302 }
5303 }
5304 impl ::std::ops::BitAnd for TOKEN_PRIVILEGES_ATTRIBUTES {
5305 type Output = Self;
bitand(self, rhs: Self) -> Self5306 fn bitand(self, rhs: Self) -> Self {
5307 Self(self.0 & rhs.0)
5308 }
5309 }
5310 impl ::std::ops::BitOrAssign for TOKEN_PRIVILEGES_ATTRIBUTES {
bitor_assign(&mut self, rhs: Self)5311 fn bitor_assign(&mut self, rhs: Self) {
5312 self.0.bitor_assign(rhs.0)
5313 }
5314 }
5315 impl ::std::ops::BitAndAssign for TOKEN_PRIVILEGES_ATTRIBUTES {
bitand_assign(&mut self, rhs: Self)5316 fn bitand_assign(&mut self, rhs: Self) {
5317 self.0.bitand_assign(rhs.0)
5318 }
5319 }
5320 impl ::std::ops::Not for TOKEN_PRIVILEGES_ATTRIBUTES {
5321 type Output = Self;
not(self) -> Self5322 fn not(self) -> Self {
5323 Self(self.0.not())
5324 }
5325 }
5326 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5327 #[repr(C)]
5328 #[cfg(feature = "Win32_Foundation")]
5329 pub struct TOKEN_SOURCE {
5330 pub SourceName: [super::Foundation::CHAR; 8],
5331 pub SourceIdentifier: super::Foundation::LUID,
5332 }
5333 #[cfg(feature = "Win32_Foundation")]
5334 impl TOKEN_SOURCE {}
5335 #[cfg(feature = "Win32_Foundation")]
5336 impl ::std::default::Default for TOKEN_SOURCE {
default() -> Self5337 fn default() -> Self {
5338 unsafe { ::std::mem::zeroed() }
5339 }
5340 }
5341 #[cfg(feature = "Win32_Foundation")]
5342 impl ::std::fmt::Debug for TOKEN_SOURCE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5343 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5344 fmt.debug_struct("TOKEN_SOURCE").field("SourceName", &self.SourceName).field("SourceIdentifier", &self.SourceIdentifier).finish()
5345 }
5346 }
5347 #[cfg(feature = "Win32_Foundation")]
5348 impl ::std::cmp::PartialEq for TOKEN_SOURCE {
eq(&self, other: &Self) -> bool5349 fn eq(&self, other: &Self) -> bool {
5350 self.SourceName == other.SourceName && self.SourceIdentifier == other.SourceIdentifier
5351 }
5352 }
5353 #[cfg(feature = "Win32_Foundation")]
5354 impl ::std::cmp::Eq for TOKEN_SOURCE {}
5355 #[cfg(feature = "Win32_Foundation")]
5356 unsafe impl ::windows::runtime::Abi for TOKEN_SOURCE {
5357 type Abi = Self;
5358 type DefaultType = Self;
5359 }
5360 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5361 #[repr(C)]
5362 #[cfg(feature = "Win32_Foundation")]
5363 pub struct TOKEN_STATISTICS {
5364 pub TokenId: super::Foundation::LUID,
5365 pub AuthenticationId: super::Foundation::LUID,
5366 pub ExpirationTime: i64,
5367 pub TokenType: TOKEN_TYPE,
5368 pub ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL,
5369 pub DynamicCharged: u32,
5370 pub DynamicAvailable: u32,
5371 pub GroupCount: u32,
5372 pub PrivilegeCount: u32,
5373 pub ModifiedId: super::Foundation::LUID,
5374 }
5375 #[cfg(feature = "Win32_Foundation")]
5376 impl TOKEN_STATISTICS {}
5377 #[cfg(feature = "Win32_Foundation")]
5378 impl ::std::default::Default for TOKEN_STATISTICS {
default() -> Self5379 fn default() -> Self {
5380 unsafe { ::std::mem::zeroed() }
5381 }
5382 }
5383 #[cfg(feature = "Win32_Foundation")]
5384 impl ::std::fmt::Debug for TOKEN_STATISTICS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5385 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5386 fmt.debug_struct("TOKEN_STATISTICS")
5387 .field("TokenId", &self.TokenId)
5388 .field("AuthenticationId", &self.AuthenticationId)
5389 .field("ExpirationTime", &self.ExpirationTime)
5390 .field("TokenType", &self.TokenType)
5391 .field("ImpersonationLevel", &self.ImpersonationLevel)
5392 .field("DynamicCharged", &self.DynamicCharged)
5393 .field("DynamicAvailable", &self.DynamicAvailable)
5394 .field("GroupCount", &self.GroupCount)
5395 .field("PrivilegeCount", &self.PrivilegeCount)
5396 .field("ModifiedId", &self.ModifiedId)
5397 .finish()
5398 }
5399 }
5400 #[cfg(feature = "Win32_Foundation")]
5401 impl ::std::cmp::PartialEq for TOKEN_STATISTICS {
eq(&self, other: &Self) -> bool5402 fn eq(&self, other: &Self) -> bool {
5403 self.TokenId == other.TokenId && self.AuthenticationId == other.AuthenticationId && self.ExpirationTime == other.ExpirationTime && self.TokenType == other.TokenType && self.ImpersonationLevel == other.ImpersonationLevel && self.DynamicCharged == other.DynamicCharged && self.DynamicAvailable == other.DynamicAvailable && self.GroupCount == other.GroupCount && self.PrivilegeCount == other.PrivilegeCount && self.ModifiedId == other.ModifiedId
5404 }
5405 }
5406 #[cfg(feature = "Win32_Foundation")]
5407 impl ::std::cmp::Eq for TOKEN_STATISTICS {}
5408 #[cfg(feature = "Win32_Foundation")]
5409 unsafe impl ::windows::runtime::Abi for TOKEN_STATISTICS {
5410 type Abi = Self;
5411 type DefaultType = Self;
5412 }
5413 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5414 #[repr(transparent)]
5415 pub struct TOKEN_TYPE(pub i32);
5416 pub const TokenPrimary: TOKEN_TYPE = TOKEN_TYPE(1i32);
5417 pub const TokenImpersonation: TOKEN_TYPE = TOKEN_TYPE(2i32);
5418 impl ::std::convert::From<i32> for TOKEN_TYPE {
from(value: i32) -> Self5419 fn from(value: i32) -> Self {
5420 Self(value)
5421 }
5422 }
5423 unsafe impl ::windows::runtime::Abi for TOKEN_TYPE {
5424 type Abi = Self;
5425 type DefaultType = Self;
5426 }
5427 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5428 #[repr(C)]
5429 #[cfg(feature = "Win32_Foundation")]
5430 pub struct TOKEN_USER {
5431 pub User: SID_AND_ATTRIBUTES,
5432 }
5433 #[cfg(feature = "Win32_Foundation")]
5434 impl TOKEN_USER {}
5435 #[cfg(feature = "Win32_Foundation")]
5436 impl ::std::default::Default for TOKEN_USER {
default() -> Self5437 fn default() -> Self {
5438 unsafe { ::std::mem::zeroed() }
5439 }
5440 }
5441 #[cfg(feature = "Win32_Foundation")]
5442 impl ::std::fmt::Debug for TOKEN_USER {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5443 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5444 fmt.debug_struct("TOKEN_USER").field("User", &self.User).finish()
5445 }
5446 }
5447 #[cfg(feature = "Win32_Foundation")]
5448 impl ::std::cmp::PartialEq for TOKEN_USER {
eq(&self, other: &Self) -> bool5449 fn eq(&self, other: &Self) -> bool {
5450 self.User == other.User
5451 }
5452 }
5453 #[cfg(feature = "Win32_Foundation")]
5454 impl ::std::cmp::Eq for TOKEN_USER {}
5455 #[cfg(feature = "Win32_Foundation")]
5456 unsafe impl ::windows::runtime::Abi for TOKEN_USER {
5457 type Abi = Self;
5458 type DefaultType = Self;
5459 }
5460 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5461 #[repr(C)]
5462 pub struct TOKEN_USER_CLAIMS {
5463 pub UserClaims: *mut ::std::ffi::c_void,
5464 }
5465 impl TOKEN_USER_CLAIMS {}
5466 impl ::std::default::Default for TOKEN_USER_CLAIMS {
default() -> Self5467 fn default() -> Self {
5468 unsafe { ::std::mem::zeroed() }
5469 }
5470 }
5471 impl ::std::fmt::Debug for TOKEN_USER_CLAIMS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5472 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5473 fmt.debug_struct("TOKEN_USER_CLAIMS").field("UserClaims", &self.UserClaims).finish()
5474 }
5475 }
5476 impl ::std::cmp::PartialEq for TOKEN_USER_CLAIMS {
eq(&self, other: &Self) -> bool5477 fn eq(&self, other: &Self) -> bool {
5478 self.UserClaims == other.UserClaims
5479 }
5480 }
5481 impl ::std::cmp::Eq for TOKEN_USER_CLAIMS {}
5482 unsafe impl ::windows::runtime::Abi for TOKEN_USER_CLAIMS {
5483 type Abi = Self;
5484 type DefaultType = Self;
5485 }
5486 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5487 #[repr(transparent)]
5488 pub struct WELL_KNOWN_SID_TYPE(pub i32);
5489 pub const WinNullSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(0i32);
5490 pub const WinWorldSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(1i32);
5491 pub const WinLocalSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(2i32);
5492 pub const WinCreatorOwnerSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(3i32);
5493 pub const WinCreatorGroupSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(4i32);
5494 pub const WinCreatorOwnerServerSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(5i32);
5495 pub const WinCreatorGroupServerSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(6i32);
5496 pub const WinNtAuthoritySid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(7i32);
5497 pub const WinDialupSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(8i32);
5498 pub const WinNetworkSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(9i32);
5499 pub const WinBatchSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(10i32);
5500 pub const WinInteractiveSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(11i32);
5501 pub const WinServiceSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(12i32);
5502 pub const WinAnonymousSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(13i32);
5503 pub const WinProxySid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(14i32);
5504 pub const WinEnterpriseControllersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(15i32);
5505 pub const WinSelfSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(16i32);
5506 pub const WinAuthenticatedUserSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(17i32);
5507 pub const WinRestrictedCodeSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(18i32);
5508 pub const WinTerminalServerSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(19i32);
5509 pub const WinRemoteLogonIdSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(20i32);
5510 pub const WinLogonIdsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(21i32);
5511 pub const WinLocalSystemSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(22i32);
5512 pub const WinLocalServiceSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(23i32);
5513 pub const WinNetworkServiceSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(24i32);
5514 pub const WinBuiltinDomainSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(25i32);
5515 pub const WinBuiltinAdministratorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(26i32);
5516 pub const WinBuiltinUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(27i32);
5517 pub const WinBuiltinGuestsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(28i32);
5518 pub const WinBuiltinPowerUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(29i32);
5519 pub const WinBuiltinAccountOperatorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(30i32);
5520 pub const WinBuiltinSystemOperatorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(31i32);
5521 pub const WinBuiltinPrintOperatorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(32i32);
5522 pub const WinBuiltinBackupOperatorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(33i32);
5523 pub const WinBuiltinReplicatorSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(34i32);
5524 pub const WinBuiltinPreWindows2000CompatibleAccessSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(35i32);
5525 pub const WinBuiltinRemoteDesktopUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(36i32);
5526 pub const WinBuiltinNetworkConfigurationOperatorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(37i32);
5527 pub const WinAccountAdministratorSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(38i32);
5528 pub const WinAccountGuestSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(39i32);
5529 pub const WinAccountKrbtgtSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(40i32);
5530 pub const WinAccountDomainAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(41i32);
5531 pub const WinAccountDomainUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(42i32);
5532 pub const WinAccountDomainGuestsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(43i32);
5533 pub const WinAccountComputersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(44i32);
5534 pub const WinAccountControllersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(45i32);
5535 pub const WinAccountCertAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(46i32);
5536 pub const WinAccountSchemaAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(47i32);
5537 pub const WinAccountEnterpriseAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(48i32);
5538 pub const WinAccountPolicyAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(49i32);
5539 pub const WinAccountRasAndIasServersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(50i32);
5540 pub const WinNTLMAuthenticationSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(51i32);
5541 pub const WinDigestAuthenticationSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(52i32);
5542 pub const WinSChannelAuthenticationSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(53i32);
5543 pub const WinThisOrganizationSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(54i32);
5544 pub const WinOtherOrganizationSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(55i32);
5545 pub const WinBuiltinIncomingForestTrustBuildersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(56i32);
5546 pub const WinBuiltinPerfMonitoringUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(57i32);
5547 pub const WinBuiltinPerfLoggingUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(58i32);
5548 pub const WinBuiltinAuthorizationAccessSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(59i32);
5549 pub const WinBuiltinTerminalServerLicenseServersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(60i32);
5550 pub const WinBuiltinDCOMUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(61i32);
5551 pub const WinBuiltinIUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(62i32);
5552 pub const WinIUserSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(63i32);
5553 pub const WinBuiltinCryptoOperatorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(64i32);
5554 pub const WinUntrustedLabelSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(65i32);
5555 pub const WinLowLabelSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(66i32);
5556 pub const WinMediumLabelSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(67i32);
5557 pub const WinHighLabelSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(68i32);
5558 pub const WinSystemLabelSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(69i32);
5559 pub const WinWriteRestrictedCodeSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(70i32);
5560 pub const WinCreatorOwnerRightsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(71i32);
5561 pub const WinCacheablePrincipalsGroupSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(72i32);
5562 pub const WinNonCacheablePrincipalsGroupSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(73i32);
5563 pub const WinEnterpriseReadonlyControllersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(74i32);
5564 pub const WinAccountReadonlyControllersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(75i32);
5565 pub const WinBuiltinEventLogReadersGroup: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(76i32);
5566 pub const WinNewEnterpriseReadonlyControllersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(77i32);
5567 pub const WinBuiltinCertSvcDComAccessGroup: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(78i32);
5568 pub const WinMediumPlusLabelSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(79i32);
5569 pub const WinLocalLogonSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(80i32);
5570 pub const WinConsoleLogonSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(81i32);
5571 pub const WinThisOrganizationCertificateSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(82i32);
5572 pub const WinApplicationPackageAuthoritySid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(83i32);
5573 pub const WinBuiltinAnyPackageSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(84i32);
5574 pub const WinCapabilityInternetClientSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(85i32);
5575 pub const WinCapabilityInternetClientServerSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(86i32);
5576 pub const WinCapabilityPrivateNetworkClientServerSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(87i32);
5577 pub const WinCapabilityPicturesLibrarySid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(88i32);
5578 pub const WinCapabilityVideosLibrarySid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(89i32);
5579 pub const WinCapabilityMusicLibrarySid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(90i32);
5580 pub const WinCapabilityDocumentsLibrarySid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(91i32);
5581 pub const WinCapabilitySharedUserCertificatesSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(92i32);
5582 pub const WinCapabilityEnterpriseAuthenticationSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(93i32);
5583 pub const WinCapabilityRemovableStorageSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(94i32);
5584 pub const WinBuiltinRDSRemoteAccessServersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(95i32);
5585 pub const WinBuiltinRDSEndpointServersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(96i32);
5586 pub const WinBuiltinRDSManagementServersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(97i32);
5587 pub const WinUserModeDriversSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(98i32);
5588 pub const WinBuiltinHyperVAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(99i32);
5589 pub const WinAccountCloneableControllersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(100i32);
5590 pub const WinBuiltinAccessControlAssistanceOperatorsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(101i32);
5591 pub const WinBuiltinRemoteManagementUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(102i32);
5592 pub const WinAuthenticationAuthorityAssertedSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(103i32);
5593 pub const WinAuthenticationServiceAssertedSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(104i32);
5594 pub const WinLocalAccountSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(105i32);
5595 pub const WinLocalAccountAndAdministratorSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(106i32);
5596 pub const WinAccountProtectedUsersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(107i32);
5597 pub const WinCapabilityAppointmentsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(108i32);
5598 pub const WinCapabilityContactsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(109i32);
5599 pub const WinAccountDefaultSystemManagedSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(110i32);
5600 pub const WinBuiltinDefaultSystemManagedGroupSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(111i32);
5601 pub const WinBuiltinStorageReplicaAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(112i32);
5602 pub const WinAccountKeyAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(113i32);
5603 pub const WinAccountEnterpriseKeyAdminsSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(114i32);
5604 pub const WinAuthenticationKeyTrustSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(115i32);
5605 pub const WinAuthenticationKeyPropertyMFASid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(116i32);
5606 pub const WinAuthenticationKeyPropertyAttestationSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(117i32);
5607 pub const WinAuthenticationFreshKeyAuthSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(118i32);
5608 pub const WinBuiltinDeviceOwnersSid: WELL_KNOWN_SID_TYPE = WELL_KNOWN_SID_TYPE(119i32);
5609 impl ::std::convert::From<i32> for WELL_KNOWN_SID_TYPE {
from(value: i32) -> Self5610 fn from(value: i32) -> Self {
5611 Self(value)
5612 }
5613 }
5614 unsafe impl ::windows::runtime::Abi for WELL_KNOWN_SID_TYPE {
5615 type Abi = Self;
5616 type DefaultType = Self;
5617 }
5618