1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3 #[repr(C)]
4 #[cfg(feature = "Win32_Foundation")]
5 pub struct CAT_MEMBERINFO {
6 pub pwszSubjGuid: super::super::Foundation::PWSTR,
7 pub dwCertVersion: u32,
8 }
9 #[cfg(feature = "Win32_Foundation")]
10 impl CAT_MEMBERINFO {}
11 #[cfg(feature = "Win32_Foundation")]
12 impl ::std::default::Default for CAT_MEMBERINFO {
13 fn default() -> Self {
14 unsafe { ::std::mem::zeroed() }
15 }
16 }
17 #[cfg(feature = "Win32_Foundation")]
18 impl ::std::fmt::Debug for CAT_MEMBERINFO {
19 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
20 fmt.debug_struct("CAT_MEMBERINFO").field("pwszSubjGuid", &self.pwszSubjGuid).field("dwCertVersion", &self.dwCertVersion).finish()
21 }
22 }
23 #[cfg(feature = "Win32_Foundation")]
24 impl ::std::cmp::PartialEq for CAT_MEMBERINFO {
25 fn eq(&self, other: &Self) -> bool {
26 self.pwszSubjGuid == other.pwszSubjGuid && self.dwCertVersion == other.dwCertVersion
27 }
28 }
29 #[cfg(feature = "Win32_Foundation")]
30 impl ::std::cmp::Eq for CAT_MEMBERINFO {}
31 #[cfg(feature = "Win32_Foundation")]
32 unsafe impl ::windows::runtime::Abi for CAT_MEMBERINFO {
operator ()TestFn33 type Abi = Self;
34 type DefaultType = Self;
35 }
36 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
37 #[repr(C)]
38 pub struct CAT_MEMBERINFO2 {
39 pub SubjectGuid: ::windows::runtime::GUID,
40 pub dwCertVersion: u32,
41 }
42 impl CAT_MEMBERINFO2 {}
43 impl ::std::default::Default for CAT_MEMBERINFO2 {
44 fn default() -> Self {
45 unsafe { ::std::mem::zeroed() }
46 }
47 }
48 impl ::std::fmt::Debug for CAT_MEMBERINFO2 {
49 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
50 fmt.debug_struct("CAT_MEMBERINFO2").field("SubjectGuid", &self.SubjectGuid).field("dwCertVersion", &self.dwCertVersion).finish()
51 }
52 }
53 impl ::std::cmp::PartialEq for CAT_MEMBERINFO2 {
54 fn eq(&self, other: &Self) -> bool {
55 self.SubjectGuid == other.SubjectGuid && self.dwCertVersion == other.dwCertVersion
56 }
57 }
58 impl ::std::cmp::Eq for CAT_MEMBERINFO2 {}
main(int,char **)59 unsafe impl ::windows::runtime::Abi for CAT_MEMBERINFO2 {
60 type Abi = Self;
61 type DefaultType = Self;
62 }
63 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
64 #[repr(C)]
65 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
66 pub struct CAT_NAMEVALUE {
67 pub pwszTag: super::super::Foundation::PWSTR,
68 pub fdwFlags: u32,
69 pub Value: super::Cryptography::CRYPTOAPI_BLOB,
70 }
71 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
72 impl CAT_NAMEVALUE {}
73 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
74 impl ::std::default::Default for CAT_NAMEVALUE {
75 fn default() -> Self {
76 unsafe { ::std::mem::zeroed() }
77 }
78 }
79 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
80 impl ::std::fmt::Debug for CAT_NAMEVALUE {
81 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
82 fmt.debug_struct("CAT_NAMEVALUE").field("pwszTag", &self.pwszTag).field("fdwFlags", &self.fdwFlags).field("Value", &self.Value).finish()
83 }
84 }
85 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
86 impl ::std::cmp::PartialEq for CAT_NAMEVALUE {
87 fn eq(&self, other: &Self) -> bool {
88 self.pwszTag == other.pwszTag && self.fdwFlags == other.fdwFlags && self.Value == other.Value
89 }
90 }
91 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
92 impl ::std::cmp::Eq for CAT_NAMEVALUE {}
93 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
94 unsafe impl ::windows::runtime::Abi for CAT_NAMEVALUE {
95 type Abi = Self;
96 type DefaultType = Self;
97 }
98 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
99 #[repr(C)]
100 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
101 pub struct CONFIG_CI_PROV_INFO {
102 pub cbSize: u32,
103 pub dwPolicies: u32,
104 pub pPolicies: *mut super::Cryptography::CRYPTOAPI_BLOB,
105 pub result: CONFIG_CI_PROV_INFO_RESULT,
106 pub dwScenario: u32,
107 }
108 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
109 impl CONFIG_CI_PROV_INFO {}
110 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
111 impl ::std::default::Default for CONFIG_CI_PROV_INFO {
112 fn default() -> Self {
113 unsafe { ::std::mem::zeroed() }
114 }
115 }
116 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
117 impl ::std::fmt::Debug for CONFIG_CI_PROV_INFO {
118 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
119 fmt.debug_struct("CONFIG_CI_PROV_INFO").field("cbSize", &self.cbSize).field("dwPolicies", &self.dwPolicies).field("pPolicies", &self.pPolicies).field("result", &self.result).field("dwScenario", &self.dwScenario).finish()
120 }
121 }
122 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
123 impl ::std::cmp::PartialEq for CONFIG_CI_PROV_INFO {
124 fn eq(&self, other: &Self) -> bool {
125 self.cbSize == other.cbSize && self.dwPolicies == other.dwPolicies && self.pPolicies == other.pPolicies && self.result == other.result && self.dwScenario == other.dwScenario
126 }
127 }
128 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
129 impl ::std::cmp::Eq for CONFIG_CI_PROV_INFO {}
130 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
131 unsafe impl ::windows::runtime::Abi for CONFIG_CI_PROV_INFO {
132 type Abi = Self;
133 type DefaultType = Self;
134 }
135 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
136 #[repr(C)]
137 #[cfg(feature = "Win32_Foundation")]
138 pub struct CONFIG_CI_PROV_INFO_RESULT {
139 pub hr: ::windows::runtime::HRESULT,
140 pub dwResult: u32,
141 pub dwPolicyIndex: u32,
142 pub fIsExplicitDeny: super::super::Foundation::BOOLEAN,
143 }
144 #[cfg(feature = "Win32_Foundation")]
145 impl CONFIG_CI_PROV_INFO_RESULT {}
146 #[cfg(feature = "Win32_Foundation")]
147 impl ::std::default::Default for CONFIG_CI_PROV_INFO_RESULT {
148 fn default() -> Self {
149 unsafe { ::std::mem::zeroed() }
150 }
151 }
152 #[cfg(feature = "Win32_Foundation")]
153 impl ::std::fmt::Debug for CONFIG_CI_PROV_INFO_RESULT {
154 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
155 fmt.debug_struct("CONFIG_CI_PROV_INFO_RESULT").field("hr", &self.hr).field("dwResult", &self.dwResult).field("dwPolicyIndex", &self.dwPolicyIndex).field("fIsExplicitDeny", &self.fIsExplicitDeny).finish()
156 }
157 }
158 #[cfg(feature = "Win32_Foundation")]
159 impl ::std::cmp::PartialEq for CONFIG_CI_PROV_INFO_RESULT {
160 fn eq(&self, other: &Self) -> bool {
161 self.hr == other.hr && self.dwResult == other.dwResult && self.dwPolicyIndex == other.dwPolicyIndex && self.fIsExplicitDeny == other.fIsExplicitDeny
162 }
163 }
164 #[cfg(feature = "Win32_Foundation")]
165 impl ::std::cmp::Eq for CONFIG_CI_PROV_INFO_RESULT {}
166 #[cfg(feature = "Win32_Foundation")]
167 unsafe impl ::windows::runtime::Abi for CONFIG_CI_PROV_INFO_RESULT {
168 type Abi = Self;
169 type DefaultType = Self;
170 }
171 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
172 #[repr(C)]
173 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
174 pub struct CRYPT_PROVIDER_CERT {
175 pub cbStruct: u32,
176 pub pCert: *mut super::Cryptography::CERT_CONTEXT,
177 pub fCommercial: super::super::Foundation::BOOL,
178 pub fTrustedRoot: super::super::Foundation::BOOL,
179 pub fSelfSigned: super::super::Foundation::BOOL,
180 pub fTestCert: super::super::Foundation::BOOL,
181 pub dwRevokedReason: u32,
182 pub dwConfidence: u32,
183 pub dwError: u32,
184 pub pTrustListContext: *mut super::Cryptography::CTL_CONTEXT,
185 pub fTrustListSignerCert: super::super::Foundation::BOOL,
186 pub pCtlContext: *mut super::Cryptography::CTL_CONTEXT,
187 pub dwCtlError: u32,
188 pub fIsCyclic: super::super::Foundation::BOOL,
189 pub pChainElement: *mut super::Cryptography::CERT_CHAIN_ELEMENT,
190 }
191 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
192 impl CRYPT_PROVIDER_CERT {}
193 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
194 impl ::std::default::Default for CRYPT_PROVIDER_CERT {
195 fn default() -> Self {
196 unsafe { ::std::mem::zeroed() }
197 }
198 }
199 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
200 impl ::std::fmt::Debug for CRYPT_PROVIDER_CERT {
201 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
202 fmt.debug_struct("CRYPT_PROVIDER_CERT")
203 .field("cbStruct", &self.cbStruct)
204 .field("pCert", &self.pCert)
205 .field("fCommercial", &self.fCommercial)
206 .field("fTrustedRoot", &self.fTrustedRoot)
207 .field("fSelfSigned", &self.fSelfSigned)
208 .field("fTestCert", &self.fTestCert)
209 .field("dwRevokedReason", &self.dwRevokedReason)
210 .field("dwConfidence", &self.dwConfidence)
211 .field("dwError", &self.dwError)
212 .field("pTrustListContext", &self.pTrustListContext)
213 .field("fTrustListSignerCert", &self.fTrustListSignerCert)
214 .field("pCtlContext", &self.pCtlContext)
215 .field("dwCtlError", &self.dwCtlError)
216 .field("fIsCyclic", &self.fIsCyclic)
217 .field("pChainElement", &self.pChainElement)
218 .finish()
219 }
220 }
221 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
222 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_CERT {
223 fn eq(&self, other: &Self) -> bool {
224 self.cbStruct == other.cbStruct
225 && self.pCert == other.pCert
226 && self.fCommercial == other.fCommercial
227 && self.fTrustedRoot == other.fTrustedRoot
228 && self.fSelfSigned == other.fSelfSigned
229 && self.fTestCert == other.fTestCert
230 && self.dwRevokedReason == other.dwRevokedReason
231 && self.dwConfidence == other.dwConfidence
232 && self.dwError == other.dwError
233 && self.pTrustListContext == other.pTrustListContext
234 && self.fTrustListSignerCert == other.fTrustListSignerCert
235 && self.pCtlContext == other.pCtlContext
236 && self.dwCtlError == other.dwCtlError
237 && self.fIsCyclic == other.fIsCyclic
238 && self.pChainElement == other.pChainElement
239 }
240 }
241 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
242 impl ::std::cmp::Eq for CRYPT_PROVIDER_CERT {}
243 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
244 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_CERT {
245 type Abi = Self;
246 type DefaultType = Self;
247 }
248 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
249 #[repr(C)]
250 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
251 pub struct CRYPT_PROVIDER_DATA {
252 pub cbStruct: u32,
253 pub pWintrustData: *mut WINTRUST_DATA,
254 pub fOpenedFile: super::super::Foundation::BOOL,
255 pub hWndParent: super::super::Foundation::HWND,
256 pub pgActionID: *mut ::windows::runtime::GUID,
257 pub hProv: usize,
258 pub dwError: u32,
259 pub dwRegSecuritySettings: u32,
260 pub dwRegPolicySettings: u32,
261 pub psPfns: *mut CRYPT_PROVIDER_FUNCTIONS,
262 pub cdwTrustStepErrors: u32,
263 pub padwTrustStepErrors: *mut u32,
264 pub chStores: u32,
265 pub pahStores: *mut *mut ::std::ffi::c_void,
266 pub dwEncoding: u32,
267 pub hMsg: *mut ::std::ffi::c_void,
268 pub csSigners: u32,
269 pub pasSigners: *mut CRYPT_PROVIDER_SGNR,
270 pub csProvPrivData: u32,
271 pub pasProvPrivData: *mut CRYPT_PROVIDER_PRIVDATA,
272 pub dwSubjectChoice: u32,
273 pub Anonymous: CRYPT_PROVIDER_DATA_0,
274 pub pszUsageOID: super::super::Foundation::PSTR,
275 pub fRecallWithState: super::super::Foundation::BOOL,
276 pub sftSystemTime: super::super::Foundation::FILETIME,
277 pub pszCTLSignerUsageOID: super::super::Foundation::PSTR,
278 pub dwProvFlags: u32,
279 pub dwFinalError: u32,
280 pub pRequestUsage: *mut super::Cryptography::CERT_USAGE_MATCH,
281 pub dwTrustPubSettings: u32,
282 pub dwUIStateFlags: u32,
283 pub pSigState: *mut CRYPT_PROVIDER_SIGSTATE,
284 pub pSigSettings: *mut WINTRUST_SIGNATURE_SETTINGS,
285 }
286 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
287 impl CRYPT_PROVIDER_DATA {}
288 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
289 impl ::std::default::Default for CRYPT_PROVIDER_DATA {
290 fn default() -> Self {
291 unsafe { ::std::mem::zeroed() }
292 }
293 }
294 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
295 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_DATA {
296 fn eq(&self, _other: &Self) -> bool {
297 unimplemented!()
298 }
299 }
300 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
301 impl ::std::cmp::Eq for CRYPT_PROVIDER_DATA {}
302 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
303 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_DATA {
304 type Abi = Self;
305 type DefaultType = Self;
306 }
307 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
308 #[repr(C)]
309 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
310 pub union CRYPT_PROVIDER_DATA_0 {
311 pub pPDSip: *mut PROVDATA_SIP,
312 }
313 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
314 impl CRYPT_PROVIDER_DATA_0 {}
315 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
316 impl ::std::default::Default for CRYPT_PROVIDER_DATA_0 {
317 fn default() -> Self {
318 unsafe { ::std::mem::zeroed() }
319 }
320 }
321 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
322 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_DATA_0 {
323 fn eq(&self, _other: &Self) -> bool {
324 unimplemented!()
325 }
326 }
327 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
328 impl ::std::cmp::Eq for CRYPT_PROVIDER_DATA_0 {}
329 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
330 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_DATA_0 {
331 type Abi = Self;
332 type DefaultType = Self;
333 }
334 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
335 #[repr(C)]
336 pub struct CRYPT_PROVIDER_DEFUSAGE {
337 pub cbStruct: u32,
338 pub gActionID: ::windows::runtime::GUID,
339 pub pDefPolicyCallbackData: *mut ::std::ffi::c_void,
340 pub pDefSIPClientData: *mut ::std::ffi::c_void,
341 }
342 impl CRYPT_PROVIDER_DEFUSAGE {}
343 impl ::std::default::Default for CRYPT_PROVIDER_DEFUSAGE {
344 fn default() -> Self {
345 unsafe { ::std::mem::zeroed() }
346 }
347 }
348 impl ::std::fmt::Debug for CRYPT_PROVIDER_DEFUSAGE {
349 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
350 fmt.debug_struct("CRYPT_PROVIDER_DEFUSAGE").field("cbStruct", &self.cbStruct).field("gActionID", &self.gActionID).field("pDefPolicyCallbackData", &self.pDefPolicyCallbackData).field("pDefSIPClientData", &self.pDefSIPClientData).finish()
351 }
352 }
353 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_DEFUSAGE {
354 fn eq(&self, other: &Self) -> bool {
355 self.cbStruct == other.cbStruct && self.gActionID == other.gActionID && self.pDefPolicyCallbackData == other.pDefPolicyCallbackData && self.pDefSIPClientData == other.pDefSIPClientData
356 }
357 }
358 impl ::std::cmp::Eq for CRYPT_PROVIDER_DEFUSAGE {}
359 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_DEFUSAGE {
360 type Abi = Self;
361 type DefaultType = Self;
362 }
363 #[derive(:: std :: clone :: Clone)]
364 #[repr(C)]
365 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
366 pub struct CRYPT_PROVIDER_FUNCTIONS {
367 pub cbStruct: u32,
368 pub pfnAlloc: ::std::option::Option<PFN_CPD_MEM_ALLOC>,
369 pub pfnFree: ::std::option::Option<PFN_CPD_MEM_FREE>,
370 pub pfnAddStore2Chain: ::std::option::Option<PFN_CPD_ADD_STORE>,
371 pub pfnAddSgnr2Chain: ::std::option::Option<PFN_CPD_ADD_SGNR>,
372 pub pfnAddCert2Chain: ::std::option::Option<PFN_CPD_ADD_CERT>,
373 pub pfnAddPrivData2Chain: ::std::option::Option<PFN_CPD_ADD_PRIVDATA>,
374 pub pfnInitialize: ::std::option::Option<PFN_PROVIDER_INIT_CALL>,
375 pub pfnObjectTrust: ::std::option::Option<PFN_PROVIDER_OBJTRUST_CALL>,
376 pub pfnSignatureTrust: ::std::option::Option<PFN_PROVIDER_SIGTRUST_CALL>,
377 pub pfnCertificateTrust: ::std::option::Option<PFN_PROVIDER_CERTTRUST_CALL>,
378 pub pfnFinalPolicy: ::std::option::Option<PFN_PROVIDER_FINALPOLICY_CALL>,
379 pub pfnCertCheckPolicy: ::std::option::Option<PFN_PROVIDER_CERTCHKPOLICY_CALL>,
380 pub pfnTestFinalPolicy: ::std::option::Option<PFN_PROVIDER_TESTFINALPOLICY_CALL>,
381 pub psUIpfns: *mut CRYPT_PROVUI_FUNCS,
382 pub pfnCleanupPolicy: ::std::option::Option<PFN_PROVIDER_CLEANUP_CALL>,
383 }
384 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
385 impl CRYPT_PROVIDER_FUNCTIONS {}
386 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
387 impl ::std::default::Default for CRYPT_PROVIDER_FUNCTIONS {
388 fn default() -> Self {
389 unsafe { ::std::mem::zeroed() }
390 }
391 }
392 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
393 impl ::std::fmt::Debug for CRYPT_PROVIDER_FUNCTIONS {
394 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
395 fmt.debug_struct("CRYPT_PROVIDER_FUNCTIONS").field("cbStruct", &self.cbStruct).field("psUIpfns", &self.psUIpfns).finish()
396 }
397 }
398 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
399 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_FUNCTIONS {
400 fn eq(&self, other: &Self) -> bool {
401 self.cbStruct == other.cbStruct
402 && self.pfnAlloc.map(|f| f as usize) == other.pfnAlloc.map(|f| f as usize)
403 && self.pfnFree.map(|f| f as usize) == other.pfnFree.map(|f| f as usize)
404 && self.pfnAddStore2Chain.map(|f| f as usize) == other.pfnAddStore2Chain.map(|f| f as usize)
405 && self.pfnAddSgnr2Chain.map(|f| f as usize) == other.pfnAddSgnr2Chain.map(|f| f as usize)
406 && self.pfnAddCert2Chain.map(|f| f as usize) == other.pfnAddCert2Chain.map(|f| f as usize)
407 && self.pfnAddPrivData2Chain.map(|f| f as usize) == other.pfnAddPrivData2Chain.map(|f| f as usize)
408 && self.pfnInitialize.map(|f| f as usize) == other.pfnInitialize.map(|f| f as usize)
409 && self.pfnObjectTrust.map(|f| f as usize) == other.pfnObjectTrust.map(|f| f as usize)
410 && self.pfnSignatureTrust.map(|f| f as usize) == other.pfnSignatureTrust.map(|f| f as usize)
411 && self.pfnCertificateTrust.map(|f| f as usize) == other.pfnCertificateTrust.map(|f| f as usize)
412 && self.pfnFinalPolicy.map(|f| f as usize) == other.pfnFinalPolicy.map(|f| f as usize)
413 && self.pfnCertCheckPolicy.map(|f| f as usize) == other.pfnCertCheckPolicy.map(|f| f as usize)
414 && self.pfnTestFinalPolicy.map(|f| f as usize) == other.pfnTestFinalPolicy.map(|f| f as usize)
415 && self.psUIpfns == other.psUIpfns
416 && self.pfnCleanupPolicy.map(|f| f as usize) == other.pfnCleanupPolicy.map(|f| f as usize)
417 }
418 }
419 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
420 impl ::std::cmp::Eq for CRYPT_PROVIDER_FUNCTIONS {}
421 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
422 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_FUNCTIONS {
423 type Abi = ::std::mem::ManuallyDrop<Self>;
424 type DefaultType = Self;
425 }
426 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
427 #[repr(C)]
428 pub struct CRYPT_PROVIDER_PRIVDATA {
429 pub cbStruct: u32,
430 pub gProviderID: ::windows::runtime::GUID,
431 pub cbProvData: u32,
432 pub pvProvData: *mut ::std::ffi::c_void,
433 }
434 impl CRYPT_PROVIDER_PRIVDATA {}
435 impl ::std::default::Default for CRYPT_PROVIDER_PRIVDATA {
436 fn default() -> Self {
437 unsafe { ::std::mem::zeroed() }
438 }
439 }
440 impl ::std::fmt::Debug for CRYPT_PROVIDER_PRIVDATA {
441 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
442 fmt.debug_struct("CRYPT_PROVIDER_PRIVDATA").field("cbStruct", &self.cbStruct).field("gProviderID", &self.gProviderID).field("cbProvData", &self.cbProvData).field("pvProvData", &self.pvProvData).finish()
443 }
444 }
445 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_PRIVDATA {
446 fn eq(&self, other: &Self) -> bool {
447 self.cbStruct == other.cbStruct && self.gProviderID == other.gProviderID && self.cbProvData == other.cbProvData && self.pvProvData == other.pvProvData
448 }
449 }
450 impl ::std::cmp::Eq for CRYPT_PROVIDER_PRIVDATA {}
451 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_PRIVDATA {
452 type Abi = Self;
453 type DefaultType = Self;
454 }
455 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
456 #[repr(C)]
457 #[cfg(feature = "Win32_Foundation")]
458 pub struct CRYPT_PROVIDER_REGDEFUSAGE {
459 pub cbStruct: u32,
460 pub pgActionID: *mut ::windows::runtime::GUID,
461 pub pwszDllName: super::super::Foundation::PWSTR,
462 pub pwszLoadCallbackDataFunctionName: super::super::Foundation::PSTR,
463 pub pwszFreeCallbackDataFunctionName: super::super::Foundation::PSTR,
464 }
465 #[cfg(feature = "Win32_Foundation")]
466 impl CRYPT_PROVIDER_REGDEFUSAGE {}
467 #[cfg(feature = "Win32_Foundation")]
468 impl ::std::default::Default for CRYPT_PROVIDER_REGDEFUSAGE {
469 fn default() -> Self {
470 unsafe { ::std::mem::zeroed() }
471 }
472 }
473 #[cfg(feature = "Win32_Foundation")]
474 impl ::std::fmt::Debug for CRYPT_PROVIDER_REGDEFUSAGE {
475 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
476 fmt.debug_struct("CRYPT_PROVIDER_REGDEFUSAGE")
477 .field("cbStruct", &self.cbStruct)
478 .field("pgActionID", &self.pgActionID)
479 .field("pwszDllName", &self.pwszDllName)
480 .field("pwszLoadCallbackDataFunctionName", &self.pwszLoadCallbackDataFunctionName)
481 .field("pwszFreeCallbackDataFunctionName", &self.pwszFreeCallbackDataFunctionName)
482 .finish()
483 }
484 }
485 #[cfg(feature = "Win32_Foundation")]
486 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_REGDEFUSAGE {
487 fn eq(&self, other: &Self) -> bool {
488 self.cbStruct == other.cbStruct && self.pgActionID == other.pgActionID && self.pwszDllName == other.pwszDllName && self.pwszLoadCallbackDataFunctionName == other.pwszLoadCallbackDataFunctionName && self.pwszFreeCallbackDataFunctionName == other.pwszFreeCallbackDataFunctionName
489 }
490 }
491 #[cfg(feature = "Win32_Foundation")]
492 impl ::std::cmp::Eq for CRYPT_PROVIDER_REGDEFUSAGE {}
493 #[cfg(feature = "Win32_Foundation")]
494 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_REGDEFUSAGE {
495 type Abi = Self;
496 type DefaultType = Self;
497 }
498 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
499 #[repr(C)]
500 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
501 pub struct CRYPT_PROVIDER_SGNR {
502 pub cbStruct: u32,
503 pub sftVerifyAsOf: super::super::Foundation::FILETIME,
504 pub csCertChain: u32,
505 pub pasCertChain: *mut CRYPT_PROVIDER_CERT,
506 pub dwSignerType: u32,
507 pub psSigner: *mut super::Cryptography::CMSG_SIGNER_INFO,
508 pub dwError: u32,
509 pub csCounterSigners: u32,
510 pub pasCounterSigners: *mut CRYPT_PROVIDER_SGNR,
511 pub pChainContext: *mut super::Cryptography::CERT_CHAIN_CONTEXT,
512 }
513 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
514 impl CRYPT_PROVIDER_SGNR {}
515 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
516 impl ::std::default::Default for CRYPT_PROVIDER_SGNR {
517 fn default() -> Self {
518 unsafe { ::std::mem::zeroed() }
519 }
520 }
521 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
522 impl ::std::fmt::Debug for CRYPT_PROVIDER_SGNR {
523 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
524 fmt.debug_struct("CRYPT_PROVIDER_SGNR")
525 .field("cbStruct", &self.cbStruct)
526 .field("sftVerifyAsOf", &self.sftVerifyAsOf)
527 .field("csCertChain", &self.csCertChain)
528 .field("pasCertChain", &self.pasCertChain)
529 .field("dwSignerType", &self.dwSignerType)
530 .field("psSigner", &self.psSigner)
531 .field("dwError", &self.dwError)
532 .field("csCounterSigners", &self.csCounterSigners)
533 .field("pasCounterSigners", &self.pasCounterSigners)
534 .field("pChainContext", &self.pChainContext)
535 .finish()
536 }
537 }
538 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
539 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_SGNR {
540 fn eq(&self, other: &Self) -> bool {
541 self.cbStruct == other.cbStruct && self.sftVerifyAsOf == other.sftVerifyAsOf && self.csCertChain == other.csCertChain && self.pasCertChain == other.pasCertChain && self.dwSignerType == other.dwSignerType && self.psSigner == other.psSigner && self.dwError == other.dwError && self.csCounterSigners == other.csCounterSigners && self.pasCounterSigners == other.pasCounterSigners && self.pChainContext == other.pChainContext
542 }
543 }
544 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
545 impl ::std::cmp::Eq for CRYPT_PROVIDER_SGNR {}
546 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
547 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_SGNR {
548 type Abi = Self;
549 type DefaultType = Self;
550 }
551 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
552 #[repr(C)]
553 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
554 pub struct CRYPT_PROVIDER_SIGSTATE {
555 pub cbStruct: u32,
556 pub rhSecondarySigs: *mut *mut ::std::ffi::c_void,
557 pub hPrimarySig: *mut ::std::ffi::c_void,
558 pub fFirstAttemptMade: super::super::Foundation::BOOL,
559 pub fNoMoreSigs: super::super::Foundation::BOOL,
560 pub cSecondarySigs: u32,
561 pub dwCurrentIndex: u32,
562 pub fSupportMultiSig: super::super::Foundation::BOOL,
563 pub dwCryptoPolicySupport: u32,
564 pub iAttemptCount: u32,
565 pub fCheckedSealing: super::super::Foundation::BOOL,
566 pub pSealingSignature: *mut SEALING_SIGNATURE_ATTRIBUTE,
567 }
568 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
569 impl CRYPT_PROVIDER_SIGSTATE {}
570 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
571 impl ::std::default::Default for CRYPT_PROVIDER_SIGSTATE {
572 fn default() -> Self {
573 unsafe { ::std::mem::zeroed() }
574 }
575 }
576 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
577 impl ::std::fmt::Debug for CRYPT_PROVIDER_SIGSTATE {
578 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
579 fmt.debug_struct("CRYPT_PROVIDER_SIGSTATE")
580 .field("cbStruct", &self.cbStruct)
581 .field("rhSecondarySigs", &self.rhSecondarySigs)
582 .field("hPrimarySig", &self.hPrimarySig)
583 .field("fFirstAttemptMade", &self.fFirstAttemptMade)
584 .field("fNoMoreSigs", &self.fNoMoreSigs)
585 .field("cSecondarySigs", &self.cSecondarySigs)
586 .field("dwCurrentIndex", &self.dwCurrentIndex)
587 .field("fSupportMultiSig", &self.fSupportMultiSig)
588 .field("dwCryptoPolicySupport", &self.dwCryptoPolicySupport)
589 .field("iAttemptCount", &self.iAttemptCount)
590 .field("fCheckedSealing", &self.fCheckedSealing)
591 .field("pSealingSignature", &self.pSealingSignature)
592 .finish()
593 }
594 }
595 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
596 impl ::std::cmp::PartialEq for CRYPT_PROVIDER_SIGSTATE {
597 fn eq(&self, other: &Self) -> bool {
598 self.cbStruct == other.cbStruct
599 && self.rhSecondarySigs == other.rhSecondarySigs
600 && self.hPrimarySig == other.hPrimarySig
601 && self.fFirstAttemptMade == other.fFirstAttemptMade
602 && self.fNoMoreSigs == other.fNoMoreSigs
603 && self.cSecondarySigs == other.cSecondarySigs
604 && self.dwCurrentIndex == other.dwCurrentIndex
605 && self.fSupportMultiSig == other.fSupportMultiSig
606 && self.dwCryptoPolicySupport == other.dwCryptoPolicySupport
607 && self.iAttemptCount == other.iAttemptCount
608 && self.fCheckedSealing == other.fCheckedSealing
609 && self.pSealingSignature == other.pSealingSignature
610 }
611 }
612 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
613 impl ::std::cmp::Eq for CRYPT_PROVIDER_SIGSTATE {}
614 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
615 unsafe impl ::windows::runtime::Abi for CRYPT_PROVIDER_SIGSTATE {
616 type Abi = Self;
617 type DefaultType = Self;
618 }
619 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
620 #[repr(C)]
621 #[cfg(feature = "Win32_Foundation")]
622 pub struct CRYPT_PROVUI_DATA {
623 pub cbStruct: u32,
624 pub dwFinalError: u32,
625 pub pYesButtonText: super::super::Foundation::PWSTR,
626 pub pNoButtonText: super::super::Foundation::PWSTR,
627 pub pMoreInfoButtonText: super::super::Foundation::PWSTR,
628 pub pAdvancedLinkText: super::super::Foundation::PWSTR,
629 pub pCopyActionText: super::super::Foundation::PWSTR,
630 pub pCopyActionTextNoTS: super::super::Foundation::PWSTR,
631 pub pCopyActionTextNotSigned: super::super::Foundation::PWSTR,
632 }
633 #[cfg(feature = "Win32_Foundation")]
634 impl CRYPT_PROVUI_DATA {}
635 #[cfg(feature = "Win32_Foundation")]
636 impl ::std::default::Default for CRYPT_PROVUI_DATA {
637 fn default() -> Self {
638 unsafe { ::std::mem::zeroed() }
639 }
640 }
641 #[cfg(feature = "Win32_Foundation")]
642 impl ::std::fmt::Debug for CRYPT_PROVUI_DATA {
643 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
644 fmt.debug_struct("CRYPT_PROVUI_DATA")
645 .field("cbStruct", &self.cbStruct)
646 .field("dwFinalError", &self.dwFinalError)
647 .field("pYesButtonText", &self.pYesButtonText)
648 .field("pNoButtonText", &self.pNoButtonText)
649 .field("pMoreInfoButtonText", &self.pMoreInfoButtonText)
650 .field("pAdvancedLinkText", &self.pAdvancedLinkText)
651 .field("pCopyActionText", &self.pCopyActionText)
652 .field("pCopyActionTextNoTS", &self.pCopyActionTextNoTS)
653 .field("pCopyActionTextNotSigned", &self.pCopyActionTextNotSigned)
654 .finish()
655 }
656 }
657 #[cfg(feature = "Win32_Foundation")]
658 impl ::std::cmp::PartialEq for CRYPT_PROVUI_DATA {
659 fn eq(&self, other: &Self) -> bool {
660 self.cbStruct == other.cbStruct && self.dwFinalError == other.dwFinalError && self.pYesButtonText == other.pYesButtonText && self.pNoButtonText == other.pNoButtonText && self.pMoreInfoButtonText == other.pMoreInfoButtonText && self.pAdvancedLinkText == other.pAdvancedLinkText && self.pCopyActionText == other.pCopyActionText && self.pCopyActionTextNoTS == other.pCopyActionTextNoTS && self.pCopyActionTextNotSigned == other.pCopyActionTextNotSigned
661 }
662 }
663 #[cfg(feature = "Win32_Foundation")]
664 impl ::std::cmp::Eq for CRYPT_PROVUI_DATA {}
665 #[cfg(feature = "Win32_Foundation")]
666 unsafe impl ::windows::runtime::Abi for CRYPT_PROVUI_DATA {
667 type Abi = Self;
668 type DefaultType = Self;
669 }
670 #[derive(:: std :: clone :: Clone)]
671 #[repr(C)]
672 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
673 pub struct CRYPT_PROVUI_FUNCS {
674 pub cbStruct: u32,
675 pub psUIData: *mut CRYPT_PROVUI_DATA,
676 pub pfnOnMoreInfoClick: ::std::option::Option<PFN_PROVUI_CALL>,
677 pub pfnOnMoreInfoClickDefault: ::std::option::Option<PFN_PROVUI_CALL>,
678 pub pfnOnAdvancedClick: ::std::option::Option<PFN_PROVUI_CALL>,
679 pub pfnOnAdvancedClickDefault: ::std::option::Option<PFN_PROVUI_CALL>,
680 }
681 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
682 impl CRYPT_PROVUI_FUNCS {}
683 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
684 impl ::std::default::Default for CRYPT_PROVUI_FUNCS {
685 fn default() -> Self {
686 unsafe { ::std::mem::zeroed() }
687 }
688 }
689 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
690 impl ::std::fmt::Debug for CRYPT_PROVUI_FUNCS {
691 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
692 fmt.debug_struct("CRYPT_PROVUI_FUNCS").field("cbStruct", &self.cbStruct).field("psUIData", &self.psUIData).finish()
693 }
694 }
695 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
696 impl ::std::cmp::PartialEq for CRYPT_PROVUI_FUNCS {
697 fn eq(&self, other: &Self) -> bool {
698 self.cbStruct == other.cbStruct && self.psUIData == other.psUIData && self.pfnOnMoreInfoClick.map(|f| f as usize) == other.pfnOnMoreInfoClick.map(|f| f as usize) && self.pfnOnMoreInfoClickDefault.map(|f| f as usize) == other.pfnOnMoreInfoClickDefault.map(|f| f as usize) && self.pfnOnAdvancedClick.map(|f| f as usize) == other.pfnOnAdvancedClick.map(|f| f as usize) && self.pfnOnAdvancedClickDefault.map(|f| f as usize) == other.pfnOnAdvancedClickDefault.map(|f| f as usize)
699 }
700 }
701 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
702 impl ::std::cmp::Eq for CRYPT_PROVUI_FUNCS {}
703 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
704 unsafe impl ::windows::runtime::Abi for CRYPT_PROVUI_FUNCS {
705 type Abi = ::std::mem::ManuallyDrop<Self>;
706 type DefaultType = Self;
707 }
708 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
709 #[repr(C)]
710 #[cfg(feature = "Win32_Foundation")]
711 pub struct CRYPT_REGISTER_ACTIONID {
712 pub cbStruct: u32,
713 pub sInitProvider: CRYPT_TRUST_REG_ENTRY,
714 pub sObjectProvider: CRYPT_TRUST_REG_ENTRY,
715 pub sSignatureProvider: CRYPT_TRUST_REG_ENTRY,
716 pub sCertificateProvider: CRYPT_TRUST_REG_ENTRY,
717 pub sCertificatePolicyProvider: CRYPT_TRUST_REG_ENTRY,
718 pub sFinalPolicyProvider: CRYPT_TRUST_REG_ENTRY,
719 pub sTestPolicyProvider: CRYPT_TRUST_REG_ENTRY,
720 pub sCleanupProvider: CRYPT_TRUST_REG_ENTRY,
721 }
722 #[cfg(feature = "Win32_Foundation")]
723 impl CRYPT_REGISTER_ACTIONID {}
724 #[cfg(feature = "Win32_Foundation")]
725 impl ::std::default::Default for CRYPT_REGISTER_ACTIONID {
726 fn default() -> Self {
727 unsafe { ::std::mem::zeroed() }
728 }
729 }
730 #[cfg(feature = "Win32_Foundation")]
731 impl ::std::fmt::Debug for CRYPT_REGISTER_ACTIONID {
732 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
733 fmt.debug_struct("CRYPT_REGISTER_ACTIONID")
734 .field("cbStruct", &self.cbStruct)
735 .field("sInitProvider", &self.sInitProvider)
736 .field("sObjectProvider", &self.sObjectProvider)
737 .field("sSignatureProvider", &self.sSignatureProvider)
738 .field("sCertificateProvider", &self.sCertificateProvider)
739 .field("sCertificatePolicyProvider", &self.sCertificatePolicyProvider)
740 .field("sFinalPolicyProvider", &self.sFinalPolicyProvider)
741 .field("sTestPolicyProvider", &self.sTestPolicyProvider)
742 .field("sCleanupProvider", &self.sCleanupProvider)
743 .finish()
744 }
745 }
746 #[cfg(feature = "Win32_Foundation")]
747 impl ::std::cmp::PartialEq for CRYPT_REGISTER_ACTIONID {
748 fn eq(&self, other: &Self) -> bool {
749 self.cbStruct == other.cbStruct && self.sInitProvider == other.sInitProvider && self.sObjectProvider == other.sObjectProvider && self.sSignatureProvider == other.sSignatureProvider && self.sCertificateProvider == other.sCertificateProvider && self.sCertificatePolicyProvider == other.sCertificatePolicyProvider && self.sFinalPolicyProvider == other.sFinalPolicyProvider && self.sTestPolicyProvider == other.sTestPolicyProvider && self.sCleanupProvider == other.sCleanupProvider
750 }
751 }
752 #[cfg(feature = "Win32_Foundation")]
753 impl ::std::cmp::Eq for CRYPT_REGISTER_ACTIONID {}
754 #[cfg(feature = "Win32_Foundation")]
755 unsafe impl ::windows::runtime::Abi for CRYPT_REGISTER_ACTIONID {
756 type Abi = Self;
757 type DefaultType = Self;
758 }
759 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
760 #[repr(C)]
761 #[cfg(feature = "Win32_Foundation")]
762 pub struct CRYPT_TRUST_REG_ENTRY {
763 pub cbStruct: u32,
764 pub pwszDLLName: super::super::Foundation::PWSTR,
765 pub pwszFunctionName: super::super::Foundation::PWSTR,
766 }
767 #[cfg(feature = "Win32_Foundation")]
768 impl CRYPT_TRUST_REG_ENTRY {}
769 #[cfg(feature = "Win32_Foundation")]
770 impl ::std::default::Default for CRYPT_TRUST_REG_ENTRY {
771 fn default() -> Self {
772 unsafe { ::std::mem::zeroed() }
773 }
774 }
775 #[cfg(feature = "Win32_Foundation")]
776 impl ::std::fmt::Debug for CRYPT_TRUST_REG_ENTRY {
777 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
778 fmt.debug_struct("CRYPT_TRUST_REG_ENTRY").field("cbStruct", &self.cbStruct).field("pwszDLLName", &self.pwszDLLName).field("pwszFunctionName", &self.pwszFunctionName).finish()
779 }
780 }
781 #[cfg(feature = "Win32_Foundation")]
782 impl ::std::cmp::PartialEq for CRYPT_TRUST_REG_ENTRY {
783 fn eq(&self, other: &Self) -> bool {
784 self.cbStruct == other.cbStruct && self.pwszDLLName == other.pwszDLLName && self.pwszFunctionName == other.pwszFunctionName
785 }
786 }
787 #[cfg(feature = "Win32_Foundation")]
788 impl ::std::cmp::Eq for CRYPT_TRUST_REG_ENTRY {}
789 #[cfg(feature = "Win32_Foundation")]
790 unsafe impl ::windows::runtime::Abi for CRYPT_TRUST_REG_ENTRY {
791 type Abi = Self;
792 type DefaultType = Self;
793 }
794 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
795 #[repr(C)]
796 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
797 pub struct DRIVER_VER_INFO {
798 pub cbStruct: u32,
799 pub dwReserved1: usize,
800 pub dwReserved2: usize,
801 pub dwPlatform: u32,
802 pub dwVersion: u32,
803 pub wszVersion: [u16; 260],
804 pub wszSignedBy: [u16; 260],
805 pub pcSignerCertContext: *mut super::Cryptography::CERT_CONTEXT,
806 pub sOSVersionLow: DRIVER_VER_MAJORMINOR,
807 pub sOSVersionHigh: DRIVER_VER_MAJORMINOR,
808 pub dwBuildNumberLow: u32,
809 pub dwBuildNumberHigh: u32,
810 }
811 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
812 impl DRIVER_VER_INFO {}
813 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
814 impl ::std::default::Default for DRIVER_VER_INFO {
815 fn default() -> Self {
816 unsafe { ::std::mem::zeroed() }
817 }
818 }
819 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
820 impl ::std::fmt::Debug for DRIVER_VER_INFO {
821 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
822 fmt.debug_struct("DRIVER_VER_INFO")
823 .field("cbStruct", &self.cbStruct)
824 .field("dwReserved1", &self.dwReserved1)
825 .field("dwReserved2", &self.dwReserved2)
826 .field("dwPlatform", &self.dwPlatform)
827 .field("dwVersion", &self.dwVersion)
828 .field("wszVersion", &self.wszVersion)
829 .field("wszSignedBy", &self.wszSignedBy)
830 .field("pcSignerCertContext", &self.pcSignerCertContext)
831 .field("sOSVersionLow", &self.sOSVersionLow)
832 .field("sOSVersionHigh", &self.sOSVersionHigh)
833 .field("dwBuildNumberLow", &self.dwBuildNumberLow)
834 .field("dwBuildNumberHigh", &self.dwBuildNumberHigh)
835 .finish()
836 }
837 }
838 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
839 impl ::std::cmp::PartialEq for DRIVER_VER_INFO {
840 fn eq(&self, other: &Self) -> bool {
841 self.cbStruct == other.cbStruct
842 && self.dwReserved1 == other.dwReserved1
843 && self.dwReserved2 == other.dwReserved2
844 && self.dwPlatform == other.dwPlatform
845 && self.dwVersion == other.dwVersion
846 && self.wszVersion == other.wszVersion
847 && self.wszSignedBy == other.wszSignedBy
848 && self.pcSignerCertContext == other.pcSignerCertContext
849 && self.sOSVersionLow == other.sOSVersionLow
850 && self.sOSVersionHigh == other.sOSVersionHigh
851 && self.dwBuildNumberLow == other.dwBuildNumberLow
852 && self.dwBuildNumberHigh == other.dwBuildNumberHigh
853 }
854 }
855 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
856 impl ::std::cmp::Eq for DRIVER_VER_INFO {}
857 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
858 unsafe impl ::windows::runtime::Abi for DRIVER_VER_INFO {
859 type Abi = Self;
860 type DefaultType = Self;
861 }
862 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
863 #[repr(C)]
864 pub struct DRIVER_VER_MAJORMINOR {
865 pub dwMajor: u32,
866 pub dwMinor: u32,
867 }
868 impl DRIVER_VER_MAJORMINOR {}
869 impl ::std::default::Default for DRIVER_VER_MAJORMINOR {
870 fn default() -> Self {
871 unsafe { ::std::mem::zeroed() }
872 }
873 }
874 impl ::std::fmt::Debug for DRIVER_VER_MAJORMINOR {
875 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
876 fmt.debug_struct("DRIVER_VER_MAJORMINOR").field("dwMajor", &self.dwMajor).field("dwMinor", &self.dwMinor).finish()
877 }
878 }
879 impl ::std::cmp::PartialEq for DRIVER_VER_MAJORMINOR {
880 fn eq(&self, other: &Self) -> bool {
881 self.dwMajor == other.dwMajor && self.dwMinor == other.dwMinor
882 }
883 }
884 impl ::std::cmp::Eq for DRIVER_VER_MAJORMINOR {}
885 unsafe impl ::windows::runtime::Abi for DRIVER_VER_MAJORMINOR {
886 type Abi = Self;
887 type DefaultType = Self;
888 }
889 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
890 #[repr(C)]
891 #[cfg(feature = "Win32_Foundation")]
892 pub struct INTENT_TO_SEAL_ATTRIBUTE {
893 pub version: u32,
894 pub seal: super::super::Foundation::BOOLEAN,
895 }
896 #[cfg(feature = "Win32_Foundation")]
897 impl INTENT_TO_SEAL_ATTRIBUTE {}
898 #[cfg(feature = "Win32_Foundation")]
899 impl ::std::default::Default for INTENT_TO_SEAL_ATTRIBUTE {
900 fn default() -> Self {
901 unsafe { ::std::mem::zeroed() }
902 }
903 }
904 #[cfg(feature = "Win32_Foundation")]
905 impl ::std::fmt::Debug for INTENT_TO_SEAL_ATTRIBUTE {
906 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
907 fmt.debug_struct("INTENT_TO_SEAL_ATTRIBUTE").field("version", &self.version).field("seal", &self.seal).finish()
908 }
909 }
910 #[cfg(feature = "Win32_Foundation")]
911 impl ::std::cmp::PartialEq for INTENT_TO_SEAL_ATTRIBUTE {
912 fn eq(&self, other: &Self) -> bool {
913 self.version == other.version && self.seal == other.seal
914 }
915 }
916 #[cfg(feature = "Win32_Foundation")]
917 impl ::std::cmp::Eq for INTENT_TO_SEAL_ATTRIBUTE {}
918 #[cfg(feature = "Win32_Foundation")]
919 unsafe impl ::windows::runtime::Abi for INTENT_TO_SEAL_ATTRIBUTE {
920 type Abi = Self;
921 type DefaultType = Self;
922 }
923 #[cfg(feature = "Win32_Foundation")]
924 #[inline]
925 pub unsafe fn OpenPersonalTrustDBDialog<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwndparent: Param0) -> super::super::Foundation::BOOL {
926 #[cfg(windows)]
927 {
928 #[link(name = "windows")]
929 extern "system" {
930 fn OpenPersonalTrustDBDialog(hwndparent: super::super::Foundation::HWND) -> super::super::Foundation::BOOL;
931 }
932 ::std::mem::transmute(OpenPersonalTrustDBDialog(hwndparent.into_param().abi()))
933 }
934 #[cfg(not(windows))]
935 unimplemented!("Unsupported target OS");
936 }
937 #[cfg(feature = "Win32_Foundation")]
938 #[inline]
939 pub unsafe fn OpenPersonalTrustDBDialogEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwndparent: Param0, dwflags: u32, pvreserved: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL {
940 #[cfg(windows)]
941 {
942 #[link(name = "windows")]
943 extern "system" {
944 fn OpenPersonalTrustDBDialogEx(hwndparent: super::super::Foundation::HWND, dwflags: u32, pvreserved: *mut *mut ::std::ffi::c_void) -> super::super::Foundation::BOOL;
945 }
946 ::std::mem::transmute(OpenPersonalTrustDBDialogEx(hwndparent.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(pvreserved)))
947 }
948 #[cfg(not(windows))]
949 unimplemented!("Unsupported target OS");
950 }
951 #[cfg(feature = "Win32_Foundation")]
952 pub type PFN_ALLOCANDFILLDEFUSAGE = unsafe extern "system" fn(pszusageoid: super::super::Foundation::PSTR, psdefusage: *const CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL;
953 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
954 pub type PFN_CPD_ADD_CERT = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersigner: super::super::Foundation::BOOL, idxcountersigner: u32, pcert2add: *const super::Cryptography::CERT_CONTEXT) -> super::super::Foundation::BOOL;
955 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
956 pub type PFN_CPD_ADD_PRIVDATA = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, pprivdata2add: *const CRYPT_PROVIDER_PRIVDATA) -> super::super::Foundation::BOOL;
957 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
958 pub type PFN_CPD_ADD_SGNR = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, fcountersigner: super::super::Foundation::BOOL, idxsigner: u32, psgnr2add: *const CRYPT_PROVIDER_SGNR) -> super::super::Foundation::BOOL;
959 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
960 pub type PFN_CPD_ADD_STORE = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, hstore2add: *const ::std::ffi::c_void) -> super::super::Foundation::BOOL;
961 pub type PFN_CPD_MEM_ALLOC = unsafe extern "system" fn(cbsize: u32) -> *mut ::std::ffi::c_void;
962 pub type PFN_CPD_MEM_FREE = unsafe extern "system" fn(pvmem2free: *const ::std::ffi::c_void);
963 #[cfg(feature = "Win32_Foundation")]
964 pub type PFN_FREEDEFUSAGE = unsafe extern "system" fn(pszusageoid: super::super::Foundation::PSTR, psdefusage: *const CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL;
965 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
966 pub type PFN_PROVIDER_CERTCHKPOLICY_CALL = unsafe extern "system" fn(pprovdata: *const CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersignerchain: super::super::Foundation::BOOL, idxcountersigner: u32) -> super::super::Foundation::BOOL;
967 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
968 pub type PFN_PROVIDER_CERTTRUST_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
969 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
970 pub type PFN_PROVIDER_CLEANUP_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
971 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
972 pub type PFN_PROVIDER_FINALPOLICY_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
973 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
974 pub type PFN_PROVIDER_INIT_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
975 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
976 pub type PFN_PROVIDER_OBJTRUST_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
977 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
978 pub type PFN_PROVIDER_SIGTRUST_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
979 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
980 pub type PFN_PROVIDER_TESTFINALPOLICY_CALL = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
981 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
982 pub type PFN_PROVUI_CALL = unsafe extern "system" fn(hwndsecuritydialog: super::super::Foundation::HWND, pprovdata: *const CRYPT_PROVIDER_DATA) -> super::super::Foundation::BOOL;
983 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
984 pub type PFN_WTD_GENERIC_CHAIN_POLICY_CALLBACK = unsafe extern "system" fn(pprovdata: *mut CRYPT_PROVIDER_DATA, dwsteperror: u32, dwregpolicysettings: u32, csigner: u32, rgpsigner: *mut *mut WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO, pvpolicyarg: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
985 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
986 #[repr(C)]
987 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
988 pub struct PROVDATA_SIP {
989 pub cbStruct: u32,
990 pub gSubject: ::windows::runtime::GUID,
991 pub pSip: *mut super::Cryptography::Sip::SIP_DISPATCH_INFO,
992 pub pCATSip: *mut super::Cryptography::Sip::SIP_DISPATCH_INFO,
993 pub psSipSubjectInfo: *mut super::Cryptography::Sip::SIP_SUBJECTINFO,
994 pub psSipCATSubjectInfo: *mut super::Cryptography::Sip::SIP_SUBJECTINFO,
995 pub psIndirectData: *mut super::Cryptography::Sip::SIP_INDIRECT_DATA,
996 }
997 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
998 impl PROVDATA_SIP {}
999 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1000 impl ::std::default::Default for PROVDATA_SIP {
1001 fn default() -> Self {
1002 unsafe { ::std::mem::zeroed() }
1003 }
1004 }
1005 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1006 impl ::std::fmt::Debug for PROVDATA_SIP {
1007 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1008 fmt.debug_struct("PROVDATA_SIP")
1009 .field("cbStruct", &self.cbStruct)
1010 .field("gSubject", &self.gSubject)
1011 .field("pSip", &self.pSip)
1012 .field("pCATSip", &self.pCATSip)
1013 .field("psSipSubjectInfo", &self.psSipSubjectInfo)
1014 .field("psSipCATSubjectInfo", &self.psSipCATSubjectInfo)
1015 .field("psIndirectData", &self.psIndirectData)
1016 .finish()
1017 }
1018 }
1019 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1020 impl ::std::cmp::PartialEq for PROVDATA_SIP {
1021 fn eq(&self, other: &Self) -> bool {
1022 self.cbStruct == other.cbStruct && self.gSubject == other.gSubject && self.pSip == other.pSip && self.pCATSip == other.pCATSip && self.psSipSubjectInfo == other.psSipSubjectInfo && self.psSipCATSubjectInfo == other.psSipCATSubjectInfo && self.psIndirectData == other.psIndirectData
1023 }
1024 }
1025 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1026 impl ::std::cmp::Eq for PROVDATA_SIP {}
1027 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
1028 unsafe impl ::windows::runtime::Abi for PROVDATA_SIP {
1029 type Abi = Self;
1030 type DefaultType = Self;
1031 }
1032 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1033 #[repr(C)]
1034 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1035 pub struct SEALING_SIGNATURE_ATTRIBUTE {
1036 pub version: u32,
1037 pub signerIndex: u32,
1038 pub signatureAlgorithm: super::Cryptography::CRYPT_ALGORITHM_IDENTIFIER,
1039 pub encryptedDigest: super::Cryptography::CRYPTOAPI_BLOB,
1040 }
1041 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1042 impl SEALING_SIGNATURE_ATTRIBUTE {}
1043 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1044 impl ::std::default::Default for SEALING_SIGNATURE_ATTRIBUTE {
1045 fn default() -> Self {
1046 unsafe { ::std::mem::zeroed() }
1047 }
1048 }
1049 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1050 impl ::std::fmt::Debug for SEALING_SIGNATURE_ATTRIBUTE {
1051 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1052 fmt.debug_struct("SEALING_SIGNATURE_ATTRIBUTE").field("version", &self.version).field("signerIndex", &self.signerIndex).field("signatureAlgorithm", &self.signatureAlgorithm).field("encryptedDigest", &self.encryptedDigest).finish()
1053 }
1054 }
1055 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1056 impl ::std::cmp::PartialEq for SEALING_SIGNATURE_ATTRIBUTE {
1057 fn eq(&self, other: &Self) -> bool {
1058 self.version == other.version && self.signerIndex == other.signerIndex && self.signatureAlgorithm == other.signatureAlgorithm && self.encryptedDigest == other.encryptedDigest
1059 }
1060 }
1061 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1062 impl ::std::cmp::Eq for SEALING_SIGNATURE_ATTRIBUTE {}
1063 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1064 unsafe impl ::windows::runtime::Abi for SEALING_SIGNATURE_ATTRIBUTE {
1065 type Abi = Self;
1066 type DefaultType = Self;
1067 }
1068 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1069 #[repr(C)]
1070 #[cfg(feature = "Win32_Security_Cryptography")]
1071 pub struct SEALING_TIMESTAMP_ATTRIBUTE {
1072 pub version: u32,
1073 pub signerIndex: u32,
1074 pub sealTimeStampToken: super::Cryptography::CRYPTOAPI_BLOB,
1075 }
1076 #[cfg(feature = "Win32_Security_Cryptography")]
1077 impl SEALING_TIMESTAMP_ATTRIBUTE {}
1078 #[cfg(feature = "Win32_Security_Cryptography")]
1079 impl ::std::default::Default for SEALING_TIMESTAMP_ATTRIBUTE {
1080 fn default() -> Self {
1081 unsafe { ::std::mem::zeroed() }
1082 }
1083 }
1084 #[cfg(feature = "Win32_Security_Cryptography")]
1085 impl ::std::fmt::Debug for SEALING_TIMESTAMP_ATTRIBUTE {
1086 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1087 fmt.debug_struct("SEALING_TIMESTAMP_ATTRIBUTE").field("version", &self.version).field("signerIndex", &self.signerIndex).field("sealTimeStampToken", &self.sealTimeStampToken).finish()
1088 }
1089 }
1090 #[cfg(feature = "Win32_Security_Cryptography")]
1091 impl ::std::cmp::PartialEq for SEALING_TIMESTAMP_ATTRIBUTE {
1092 fn eq(&self, other: &Self) -> bool {
1093 self.version == other.version && self.signerIndex == other.signerIndex && self.sealTimeStampToken == other.sealTimeStampToken
1094 }
1095 }
1096 #[cfg(feature = "Win32_Security_Cryptography")]
1097 impl ::std::cmp::Eq for SEALING_TIMESTAMP_ATTRIBUTE {}
1098 #[cfg(feature = "Win32_Security_Cryptography")]
1099 unsafe impl ::windows::runtime::Abi for SEALING_TIMESTAMP_ATTRIBUTE {
1100 type Abi = Self;
1101 type DefaultType = Self;
1102 }
1103 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1104 #[repr(C)]
1105 #[cfg(feature = "Win32_Foundation")]
1106 pub struct SPC_FINANCIAL_CRITERIA {
1107 pub fFinancialInfoAvailable: super::super::Foundation::BOOL,
1108 pub fMeetsCriteria: super::super::Foundation::BOOL,
1109 }
1110 #[cfg(feature = "Win32_Foundation")]
1111 impl SPC_FINANCIAL_CRITERIA {}
1112 #[cfg(feature = "Win32_Foundation")]
1113 impl ::std::default::Default for SPC_FINANCIAL_CRITERIA {
1114 fn default() -> Self {
1115 unsafe { ::std::mem::zeroed() }
1116 }
1117 }
1118 #[cfg(feature = "Win32_Foundation")]
1119 impl ::std::fmt::Debug for SPC_FINANCIAL_CRITERIA {
1120 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1121 fmt.debug_struct("SPC_FINANCIAL_CRITERIA").field("fFinancialInfoAvailable", &self.fFinancialInfoAvailable).field("fMeetsCriteria", &self.fMeetsCriteria).finish()
1122 }
1123 }
1124 #[cfg(feature = "Win32_Foundation")]
1125 impl ::std::cmp::PartialEq for SPC_FINANCIAL_CRITERIA {
1126 fn eq(&self, other: &Self) -> bool {
1127 self.fFinancialInfoAvailable == other.fFinancialInfoAvailable && self.fMeetsCriteria == other.fMeetsCriteria
1128 }
1129 }
1130 #[cfg(feature = "Win32_Foundation")]
1131 impl ::std::cmp::Eq for SPC_FINANCIAL_CRITERIA {}
1132 #[cfg(feature = "Win32_Foundation")]
1133 unsafe impl ::windows::runtime::Abi for SPC_FINANCIAL_CRITERIA {
1134 type Abi = Self;
1135 type DefaultType = Self;
1136 }
1137 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1138 #[repr(C)]
1139 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1140 pub struct SPC_IMAGE {
1141 pub pImageLink: *mut SPC_LINK,
1142 pub Bitmap: super::Cryptography::CRYPTOAPI_BLOB,
1143 pub Metafile: super::Cryptography::CRYPTOAPI_BLOB,
1144 pub EnhancedMetafile: super::Cryptography::CRYPTOAPI_BLOB,
1145 pub GifFile: super::Cryptography::CRYPTOAPI_BLOB,
1146 }
1147 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1148 impl SPC_IMAGE {}
1149 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1150 impl ::std::default::Default for SPC_IMAGE {
1151 fn default() -> Self {
1152 unsafe { ::std::mem::zeroed() }
1153 }
1154 }
1155 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1156 impl ::std::fmt::Debug for SPC_IMAGE {
1157 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1158 fmt.debug_struct("SPC_IMAGE").field("pImageLink", &self.pImageLink).field("Bitmap", &self.Bitmap).field("Metafile", &self.Metafile).field("EnhancedMetafile", &self.EnhancedMetafile).field("GifFile", &self.GifFile).finish()
1159 }
1160 }
1161 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1162 impl ::std::cmp::PartialEq for SPC_IMAGE {
1163 fn eq(&self, other: &Self) -> bool {
1164 self.pImageLink == other.pImageLink && self.Bitmap == other.Bitmap && self.Metafile == other.Metafile && self.EnhancedMetafile == other.EnhancedMetafile && self.GifFile == other.GifFile
1165 }
1166 }
1167 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1168 impl ::std::cmp::Eq for SPC_IMAGE {}
1169 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1170 unsafe impl ::windows::runtime::Abi for SPC_IMAGE {
1171 type Abi = Self;
1172 type DefaultType = Self;
1173 }
1174 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1175 #[repr(C)]
1176 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1177 pub struct SPC_INDIRECT_DATA_CONTENT {
1178 pub Data: super::Cryptography::CRYPT_ATTRIBUTE_TYPE_VALUE,
1179 pub DigestAlgorithm: super::Cryptography::CRYPT_ALGORITHM_IDENTIFIER,
1180 pub Digest: super::Cryptography::CRYPTOAPI_BLOB,
1181 }
1182 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1183 impl SPC_INDIRECT_DATA_CONTENT {}
1184 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1185 impl ::std::default::Default for SPC_INDIRECT_DATA_CONTENT {
1186 fn default() -> Self {
1187 unsafe { ::std::mem::zeroed() }
1188 }
1189 }
1190 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1191 impl ::std::fmt::Debug for SPC_INDIRECT_DATA_CONTENT {
1192 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1193 fmt.debug_struct("SPC_INDIRECT_DATA_CONTENT").field("Data", &self.Data).field("DigestAlgorithm", &self.DigestAlgorithm).field("Digest", &self.Digest).finish()
1194 }
1195 }
1196 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1197 impl ::std::cmp::PartialEq for SPC_INDIRECT_DATA_CONTENT {
1198 fn eq(&self, other: &Self) -> bool {
1199 self.Data == other.Data && self.DigestAlgorithm == other.DigestAlgorithm && self.Digest == other.Digest
1200 }
1201 }
1202 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1203 impl ::std::cmp::Eq for SPC_INDIRECT_DATA_CONTENT {}
1204 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1205 unsafe impl ::windows::runtime::Abi for SPC_INDIRECT_DATA_CONTENT {
1206 type Abi = Self;
1207 type DefaultType = Self;
1208 }
1209 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1210 #[repr(C)]
1211 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1212 pub struct SPC_LINK {
1213 pub dwLinkChoice: u32,
1214 pub Anonymous: SPC_LINK_0,
1215 }
1216 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1217 impl SPC_LINK {}
1218 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1219 impl ::std::default::Default for SPC_LINK {
1220 fn default() -> Self {
1221 unsafe { ::std::mem::zeroed() }
1222 }
1223 }
1224 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1225 impl ::std::cmp::PartialEq for SPC_LINK {
1226 fn eq(&self, _other: &Self) -> bool {
1227 unimplemented!()
1228 }
1229 }
1230 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1231 impl ::std::cmp::Eq for SPC_LINK {}
1232 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1233 unsafe impl ::windows::runtime::Abi for SPC_LINK {
1234 type Abi = Self;
1235 type DefaultType = Self;
1236 }
1237 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1238 #[repr(C)]
1239 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1240 pub union SPC_LINK_0 {
1241 pub pwszUrl: super::super::Foundation::PWSTR,
1242 pub Moniker: SPC_SERIALIZED_OBJECT,
1243 pub pwszFile: super::super::Foundation::PWSTR,
1244 }
1245 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1246 impl SPC_LINK_0 {}
1247 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1248 impl ::std::default::Default for SPC_LINK_0 {
1249 fn default() -> Self {
1250 unsafe { ::std::mem::zeroed() }
1251 }
1252 }
1253 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1254 impl ::std::cmp::PartialEq for SPC_LINK_0 {
1255 fn eq(&self, _other: &Self) -> bool {
1256 unimplemented!()
1257 }
1258 }
1259 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1260 impl ::std::cmp::Eq for SPC_LINK_0 {}
1261 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1262 unsafe impl ::windows::runtime::Abi for SPC_LINK_0 {
1263 type Abi = Self;
1264 type DefaultType = Self;
1265 }
1266 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1267 #[repr(C)]
1268 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1269 pub struct SPC_PE_IMAGE_DATA {
1270 pub Flags: super::Cryptography::CRYPT_BIT_BLOB,
1271 pub pFile: *mut SPC_LINK,
1272 }
1273 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1274 impl SPC_PE_IMAGE_DATA {}
1275 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1276 impl ::std::default::Default for SPC_PE_IMAGE_DATA {
1277 fn default() -> Self {
1278 unsafe { ::std::mem::zeroed() }
1279 }
1280 }
1281 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1282 impl ::std::fmt::Debug for SPC_PE_IMAGE_DATA {
1283 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1284 fmt.debug_struct("SPC_PE_IMAGE_DATA").field("Flags", &self.Flags).field("pFile", &self.pFile).finish()
1285 }
1286 }
1287 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1288 impl ::std::cmp::PartialEq for SPC_PE_IMAGE_DATA {
1289 fn eq(&self, other: &Self) -> bool {
1290 self.Flags == other.Flags && self.pFile == other.pFile
1291 }
1292 }
1293 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1294 impl ::std::cmp::Eq for SPC_PE_IMAGE_DATA {}
1295 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1296 unsafe impl ::windows::runtime::Abi for SPC_PE_IMAGE_DATA {
1297 type Abi = Self;
1298 type DefaultType = Self;
1299 }
1300 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1301 #[repr(C)]
1302 #[cfg(feature = "Win32_Security_Cryptography")]
1303 pub struct SPC_SERIALIZED_OBJECT {
1304 pub ClassId: [u8; 16],
1305 pub SerializedData: super::Cryptography::CRYPTOAPI_BLOB,
1306 }
1307 #[cfg(feature = "Win32_Security_Cryptography")]
1308 impl SPC_SERIALIZED_OBJECT {}
1309 #[cfg(feature = "Win32_Security_Cryptography")]
1310 impl ::std::default::Default for SPC_SERIALIZED_OBJECT {
1311 fn default() -> Self {
1312 unsafe { ::std::mem::zeroed() }
1313 }
1314 }
1315 #[cfg(feature = "Win32_Security_Cryptography")]
1316 impl ::std::fmt::Debug for SPC_SERIALIZED_OBJECT {
1317 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1318 fmt.debug_struct("SPC_SERIALIZED_OBJECT").field("ClassId", &self.ClassId).field("SerializedData", &self.SerializedData).finish()
1319 }
1320 }
1321 #[cfg(feature = "Win32_Security_Cryptography")]
1322 impl ::std::cmp::PartialEq for SPC_SERIALIZED_OBJECT {
1323 fn eq(&self, other: &Self) -> bool {
1324 self.ClassId == other.ClassId && self.SerializedData == other.SerializedData
1325 }
1326 }
1327 #[cfg(feature = "Win32_Security_Cryptography")]
1328 impl ::std::cmp::Eq for SPC_SERIALIZED_OBJECT {}
1329 #[cfg(feature = "Win32_Security_Cryptography")]
1330 unsafe impl ::windows::runtime::Abi for SPC_SERIALIZED_OBJECT {
1331 type Abi = Self;
1332 type DefaultType = Self;
1333 }
1334 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1335 #[repr(C)]
1336 pub struct SPC_SIGINFO {
1337 pub dwSipVersion: u32,
1338 pub gSIPGuid: ::windows::runtime::GUID,
1339 pub dwReserved1: u32,
1340 pub dwReserved2: u32,
1341 pub dwReserved3: u32,
1342 pub dwReserved4: u32,
1343 pub dwReserved5: u32,
1344 }
1345 impl SPC_SIGINFO {}
1346 impl ::std::default::Default for SPC_SIGINFO {
1347 fn default() -> Self {
1348 unsafe { ::std::mem::zeroed() }
1349 }
1350 }
1351 impl ::std::fmt::Debug for SPC_SIGINFO {
1352 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1353 fmt.debug_struct("SPC_SIGINFO")
1354 .field("dwSipVersion", &self.dwSipVersion)
1355 .field("gSIPGuid", &self.gSIPGuid)
1356 .field("dwReserved1", &self.dwReserved1)
1357 .field("dwReserved2", &self.dwReserved2)
1358 .field("dwReserved3", &self.dwReserved3)
1359 .field("dwReserved4", &self.dwReserved4)
1360 .field("dwReserved5", &self.dwReserved5)
1361 .finish()
1362 }
1363 }
1364 impl ::std::cmp::PartialEq for SPC_SIGINFO {
1365 fn eq(&self, other: &Self) -> bool {
1366 self.dwSipVersion == other.dwSipVersion && self.gSIPGuid == other.gSIPGuid && self.dwReserved1 == other.dwReserved1 && self.dwReserved2 == other.dwReserved2 && self.dwReserved3 == other.dwReserved3 && self.dwReserved4 == other.dwReserved4 && self.dwReserved5 == other.dwReserved5
1367 }
1368 }
1369 impl ::std::cmp::Eq for SPC_SIGINFO {}
1370 unsafe impl ::windows::runtime::Abi for SPC_SIGINFO {
1371 type Abi = Self;
1372 type DefaultType = Self;
1373 }
1374 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1375 #[repr(C)]
1376 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1377 pub struct SPC_SP_AGENCY_INFO {
1378 pub pPolicyInformation: *mut SPC_LINK,
1379 pub pwszPolicyDisplayText: super::super::Foundation::PWSTR,
1380 pub pLogoImage: *mut SPC_IMAGE,
1381 pub pLogoLink: *mut SPC_LINK,
1382 }
1383 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1384 impl SPC_SP_AGENCY_INFO {}
1385 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1386 impl ::std::default::Default for SPC_SP_AGENCY_INFO {
1387 fn default() -> Self {
1388 unsafe { ::std::mem::zeroed() }
1389 }
1390 }
1391 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1392 impl ::std::fmt::Debug for SPC_SP_AGENCY_INFO {
1393 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1394 fmt.debug_struct("SPC_SP_AGENCY_INFO").field("pPolicyInformation", &self.pPolicyInformation).field("pwszPolicyDisplayText", &self.pwszPolicyDisplayText).field("pLogoImage", &self.pLogoImage).field("pLogoLink", &self.pLogoLink).finish()
1395 }
1396 }
1397 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1398 impl ::std::cmp::PartialEq for SPC_SP_AGENCY_INFO {
1399 fn eq(&self, other: &Self) -> bool {
1400 self.pPolicyInformation == other.pPolicyInformation && self.pwszPolicyDisplayText == other.pwszPolicyDisplayText && self.pLogoImage == other.pLogoImage && self.pLogoLink == other.pLogoLink
1401 }
1402 }
1403 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1404 impl ::std::cmp::Eq for SPC_SP_AGENCY_INFO {}
1405 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1406 unsafe impl ::windows::runtime::Abi for SPC_SP_AGENCY_INFO {
1407 type Abi = Self;
1408 type DefaultType = Self;
1409 }
1410 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1411 #[repr(C)]
1412 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1413 pub struct SPC_SP_OPUS_INFO {
1414 pub pwszProgramName: super::super::Foundation::PWSTR,
1415 pub pMoreInfo: *mut SPC_LINK,
1416 pub pPublisherInfo: *mut SPC_LINK,
1417 }
1418 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1419 impl SPC_SP_OPUS_INFO {}
1420 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1421 impl ::std::default::Default for SPC_SP_OPUS_INFO {
1422 fn default() -> Self {
1423 unsafe { ::std::mem::zeroed() }
1424 }
1425 }
1426 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1427 impl ::std::fmt::Debug for SPC_SP_OPUS_INFO {
1428 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1429 fmt.debug_struct("SPC_SP_OPUS_INFO").field("pwszProgramName", &self.pwszProgramName).field("pMoreInfo", &self.pMoreInfo).field("pPublisherInfo", &self.pPublisherInfo).finish()
1430 }
1431 }
1432 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1433 impl ::std::cmp::PartialEq for SPC_SP_OPUS_INFO {
1434 fn eq(&self, other: &Self) -> bool {
1435 self.pwszProgramName == other.pwszProgramName && self.pMoreInfo == other.pMoreInfo && self.pPublisherInfo == other.pPublisherInfo
1436 }
1437 }
1438 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1439 impl ::std::cmp::Eq for SPC_SP_OPUS_INFO {}
1440 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1441 unsafe impl ::windows::runtime::Abi for SPC_SP_OPUS_INFO {
1442 type Abi = Self;
1443 type DefaultType = Self;
1444 }
1445 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1446 #[repr(C)]
1447 #[cfg(feature = "Win32_Foundation")]
1448 pub struct SPC_STATEMENT_TYPE {
1449 pub cKeyPurposeId: u32,
1450 pub rgpszKeyPurposeId: *mut super::super::Foundation::PSTR,
1451 }
1452 #[cfg(feature = "Win32_Foundation")]
1453 impl SPC_STATEMENT_TYPE {}
1454 #[cfg(feature = "Win32_Foundation")]
1455 impl ::std::default::Default for SPC_STATEMENT_TYPE {
1456 fn default() -> Self {
1457 unsafe { ::std::mem::zeroed() }
1458 }
1459 }
1460 #[cfg(feature = "Win32_Foundation")]
1461 impl ::std::fmt::Debug for SPC_STATEMENT_TYPE {
1462 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1463 fmt.debug_struct("SPC_STATEMENT_TYPE").field("cKeyPurposeId", &self.cKeyPurposeId).field("rgpszKeyPurposeId", &self.rgpszKeyPurposeId).finish()
1464 }
1465 }
1466 #[cfg(feature = "Win32_Foundation")]
1467 impl ::std::cmp::PartialEq for SPC_STATEMENT_TYPE {
1468 fn eq(&self, other: &Self) -> bool {
1469 self.cKeyPurposeId == other.cKeyPurposeId && self.rgpszKeyPurposeId == other.rgpszKeyPurposeId
1470 }
1471 }
1472 #[cfg(feature = "Win32_Foundation")]
1473 impl ::std::cmp::Eq for SPC_STATEMENT_TYPE {}
1474 #[cfg(feature = "Win32_Foundation")]
1475 unsafe impl ::windows::runtime::Abi for SPC_STATEMENT_TYPE {
1476 type Abi = Self;
1477 type DefaultType = Self;
1478 }
1479 pub const SPC_UUID_LENGTH: u32 = 16u32;
1480 pub const TRUSTERROR_MAX_STEPS: u32 = 38u32;
1481 pub const TRUSTERROR_STEP_CATALOGFILE: u32 = 6u32;
1482 pub const TRUSTERROR_STEP_CERTSTORE: u32 = 7u32;
1483 pub const TRUSTERROR_STEP_FILEIO: u32 = 2u32;
1484 pub const TRUSTERROR_STEP_FINAL_CERTCHKPROV: u32 = 35u32;
1485 pub const TRUSTERROR_STEP_FINAL_CERTPROV: u32 = 34u32;
1486 pub const TRUSTERROR_STEP_FINAL_INITPROV: u32 = 31u32;
1487 pub const TRUSTERROR_STEP_FINAL_OBJPROV: u32 = 32u32;
1488 pub const TRUSTERROR_STEP_FINAL_POLICYPROV: u32 = 36u32;
1489 pub const TRUSTERROR_STEP_FINAL_SIGPROV: u32 = 33u32;
1490 pub const TRUSTERROR_STEP_FINAL_UIPROV: u32 = 37u32;
1491 pub const TRUSTERROR_STEP_FINAL_WVTINIT: u32 = 30u32;
1492 pub const TRUSTERROR_STEP_MESSAGE: u32 = 8u32;
1493 pub const TRUSTERROR_STEP_MSG_CERTCHAIN: u32 = 15u32;
1494 pub const TRUSTERROR_STEP_MSG_COUNTERSIGCERT: u32 = 17u32;
1495 pub const TRUSTERROR_STEP_MSG_COUNTERSIGINFO: u32 = 16u32;
1496 pub const TRUSTERROR_STEP_MSG_INNERCNT: u32 = 11u32;
1497 pub const TRUSTERROR_STEP_MSG_INNERCNTTYPE: u32 = 10u32;
1498 pub const TRUSTERROR_STEP_MSG_SIGNERCERT: u32 = 14u32;
1499 pub const TRUSTERROR_STEP_MSG_SIGNERCOUNT: u32 = 9u32;
1500 pub const TRUSTERROR_STEP_MSG_SIGNERINFO: u32 = 13u32;
1501 pub const TRUSTERROR_STEP_MSG_STORE: u32 = 12u32;
1502 pub const TRUSTERROR_STEP_SIP: u32 = 3u32;
1503 pub const TRUSTERROR_STEP_SIPSUBJINFO: u32 = 5u32;
1504 pub const TRUSTERROR_STEP_VERIFY_MSGHASH: u32 = 18u32;
1505 pub const TRUSTERROR_STEP_VERIFY_MSGINDIRECTDATA: u32 = 19u32;
1506 pub const TRUSTERROR_STEP_WVTPARAMS: u32 = 0u32;
1507 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1508 #[repr(C)]
1509 #[cfg(feature = "Win32_Foundation")]
1510 pub struct WINTRUST_BLOB_INFO {
1511 pub cbStruct: u32,
1512 pub gSubject: ::windows::runtime::GUID,
1513 pub pcwszDisplayName: super::super::Foundation::PWSTR,
1514 pub cbMemObject: u32,
1515 pub pbMemObject: *mut u8,
1516 pub cbMemSignedMsg: u32,
1517 pub pbMemSignedMsg: *mut u8,
1518 }
1519 #[cfg(feature = "Win32_Foundation")]
1520 impl WINTRUST_BLOB_INFO {}
1521 #[cfg(feature = "Win32_Foundation")]
1522 impl ::std::default::Default for WINTRUST_BLOB_INFO {
1523 fn default() -> Self {
1524 unsafe { ::std::mem::zeroed() }
1525 }
1526 }
1527 #[cfg(feature = "Win32_Foundation")]
1528 impl ::std::fmt::Debug for WINTRUST_BLOB_INFO {
1529 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1530 fmt.debug_struct("WINTRUST_BLOB_INFO")
1531 .field("cbStruct", &self.cbStruct)
1532 .field("gSubject", &self.gSubject)
1533 .field("pcwszDisplayName", &self.pcwszDisplayName)
1534 .field("cbMemObject", &self.cbMemObject)
1535 .field("pbMemObject", &self.pbMemObject)
1536 .field("cbMemSignedMsg", &self.cbMemSignedMsg)
1537 .field("pbMemSignedMsg", &self.pbMemSignedMsg)
1538 .finish()
1539 }
1540 }
1541 #[cfg(feature = "Win32_Foundation")]
1542 impl ::std::cmp::PartialEq for WINTRUST_BLOB_INFO {
1543 fn eq(&self, other: &Self) -> bool {
1544 self.cbStruct == other.cbStruct && self.gSubject == other.gSubject && self.pcwszDisplayName == other.pcwszDisplayName && self.cbMemObject == other.cbMemObject && self.pbMemObject == other.pbMemObject && self.cbMemSignedMsg == other.cbMemSignedMsg && self.pbMemSignedMsg == other.pbMemSignedMsg
1545 }
1546 }
1547 #[cfg(feature = "Win32_Foundation")]
1548 impl ::std::cmp::Eq for WINTRUST_BLOB_INFO {}
1549 #[cfg(feature = "Win32_Foundation")]
1550 unsafe impl ::windows::runtime::Abi for WINTRUST_BLOB_INFO {
1551 type Abi = Self;
1552 type DefaultType = Self;
1553 }
1554 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1555 #[repr(C)]
1556 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1557 pub struct WINTRUST_CATALOG_INFO {
1558 pub cbStruct: u32,
1559 pub dwCatalogVersion: u32,
1560 pub pcwszCatalogFilePath: super::super::Foundation::PWSTR,
1561 pub pcwszMemberTag: super::super::Foundation::PWSTR,
1562 pub pcwszMemberFilePath: super::super::Foundation::PWSTR,
1563 pub hMemberFile: super::super::Foundation::HANDLE,
1564 pub pbCalculatedFileHash: *mut u8,
1565 pub cbCalculatedFileHash: u32,
1566 pub pcCatalogContext: *mut super::Cryptography::CTL_CONTEXT,
1567 pub hCatAdmin: isize,
1568 }
1569 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1570 impl WINTRUST_CATALOG_INFO {}
1571 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1572 impl ::std::default::Default for WINTRUST_CATALOG_INFO {
1573 fn default() -> Self {
1574 unsafe { ::std::mem::zeroed() }
1575 }
1576 }
1577 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1578 impl ::std::fmt::Debug for WINTRUST_CATALOG_INFO {
1579 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1580 fmt.debug_struct("WINTRUST_CATALOG_INFO")
1581 .field("cbStruct", &self.cbStruct)
1582 .field("dwCatalogVersion", &self.dwCatalogVersion)
1583 .field("pcwszCatalogFilePath", &self.pcwszCatalogFilePath)
1584 .field("pcwszMemberTag", &self.pcwszMemberTag)
1585 .field("pcwszMemberFilePath", &self.pcwszMemberFilePath)
1586 .field("hMemberFile", &self.hMemberFile)
1587 .field("pbCalculatedFileHash", &self.pbCalculatedFileHash)
1588 .field("cbCalculatedFileHash", &self.cbCalculatedFileHash)
1589 .field("pcCatalogContext", &self.pcCatalogContext)
1590 .field("hCatAdmin", &self.hCatAdmin)
1591 .finish()
1592 }
1593 }
1594 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1595 impl ::std::cmp::PartialEq for WINTRUST_CATALOG_INFO {
1596 fn eq(&self, other: &Self) -> bool {
1597 self.cbStruct == other.cbStruct && self.dwCatalogVersion == other.dwCatalogVersion && self.pcwszCatalogFilePath == other.pcwszCatalogFilePath && self.pcwszMemberTag == other.pcwszMemberTag && self.pcwszMemberFilePath == other.pcwszMemberFilePath && self.hMemberFile == other.hMemberFile && self.pbCalculatedFileHash == other.pbCalculatedFileHash && self.cbCalculatedFileHash == other.cbCalculatedFileHash && self.pcCatalogContext == other.pcCatalogContext && self.hCatAdmin == other.hCatAdmin
1598 }
1599 }
1600 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1601 impl ::std::cmp::Eq for WINTRUST_CATALOG_INFO {}
1602 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1603 unsafe impl ::windows::runtime::Abi for WINTRUST_CATALOG_INFO {
1604 type Abi = Self;
1605 type DefaultType = Self;
1606 }
1607 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1608 #[repr(C)]
1609 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1610 pub struct WINTRUST_CERT_INFO {
1611 pub cbStruct: u32,
1612 pub pcwszDisplayName: super::super::Foundation::PWSTR,
1613 pub psCertContext: *mut super::Cryptography::CERT_CONTEXT,
1614 pub chStores: u32,
1615 pub pahStores: *mut *mut ::std::ffi::c_void,
1616 pub dwFlags: u32,
1617 pub psftVerifyAsOf: *mut super::super::Foundation::FILETIME,
1618 }
1619 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1620 impl WINTRUST_CERT_INFO {}
1621 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1622 impl ::std::default::Default for WINTRUST_CERT_INFO {
1623 fn default() -> Self {
1624 unsafe { ::std::mem::zeroed() }
1625 }
1626 }
1627 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1628 impl ::std::fmt::Debug for WINTRUST_CERT_INFO {
1629 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1630 fmt.debug_struct("WINTRUST_CERT_INFO")
1631 .field("cbStruct", &self.cbStruct)
1632 .field("pcwszDisplayName", &self.pcwszDisplayName)
1633 .field("psCertContext", &self.psCertContext)
1634 .field("chStores", &self.chStores)
1635 .field("pahStores", &self.pahStores)
1636 .field("dwFlags", &self.dwFlags)
1637 .field("psftVerifyAsOf", &self.psftVerifyAsOf)
1638 .finish()
1639 }
1640 }
1641 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1642 impl ::std::cmp::PartialEq for WINTRUST_CERT_INFO {
1643 fn eq(&self, other: &Self) -> bool {
1644 self.cbStruct == other.cbStruct && self.pcwszDisplayName == other.pcwszDisplayName && self.psCertContext == other.psCertContext && self.chStores == other.chStores && self.pahStores == other.pahStores && self.dwFlags == other.dwFlags && self.psftVerifyAsOf == other.psftVerifyAsOf
1645 }
1646 }
1647 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1648 impl ::std::cmp::Eq for WINTRUST_CERT_INFO {}
1649 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1650 unsafe impl ::windows::runtime::Abi for WINTRUST_CERT_INFO {
1651 type Abi = Self;
1652 type DefaultType = Self;
1653 }
1654 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1655 #[repr(C)]
1656 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1657 pub struct WINTRUST_DATA {
1658 pub cbStruct: u32,
1659 pub pPolicyCallbackData: *mut ::std::ffi::c_void,
1660 pub pSIPClientData: *mut ::std::ffi::c_void,
1661 pub dwUIChoice: WINTRUST_DATA_UICHOICE,
1662 pub fdwRevocationChecks: WINTRUST_DATA_REVOCATION_CHECKS,
1663 pub dwUnionChoice: WINTRUST_DATA_UNION_CHOICE,
1664 pub Anonymous: WINTRUST_DATA_0,
1665 pub dwStateAction: WINTRUST_DATA_STATE_ACTION,
1666 pub hWVTStateData: super::super::Foundation::HANDLE,
1667 pub pwszURLReference: super::super::Foundation::PWSTR,
1668 pub dwProvFlags: u32,
1669 pub dwUIContext: WINTRUST_DATA_UICONTEXT,
1670 pub pSignatureSettings: *mut WINTRUST_SIGNATURE_SETTINGS,
1671 }
1672 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1673 impl WINTRUST_DATA {}
1674 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1675 impl ::std::default::Default for WINTRUST_DATA {
1676 fn default() -> Self {
1677 unsafe { ::std::mem::zeroed() }
1678 }
1679 }
1680 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1681 impl ::std::cmp::PartialEq for WINTRUST_DATA {
1682 fn eq(&self, _other: &Self) -> bool {
1683 unimplemented!()
1684 }
1685 }
1686 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1687 impl ::std::cmp::Eq for WINTRUST_DATA {}
1688 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1689 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA {
1690 type Abi = Self;
1691 type DefaultType = Self;
1692 }
1693 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1694 #[repr(C)]
1695 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1696 pub union WINTRUST_DATA_0 {
1697 pub pFile: *mut WINTRUST_FILE_INFO,
1698 pub pCatalog: *mut WINTRUST_CATALOG_INFO,
1699 pub pBlob: *mut WINTRUST_BLOB_INFO,
1700 pub pSgnr: *mut WINTRUST_SGNR_INFO,
1701 pub pCert: *mut WINTRUST_CERT_INFO,
1702 }
1703 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1704 impl WINTRUST_DATA_0 {}
1705 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1706 impl ::std::default::Default for WINTRUST_DATA_0 {
1707 fn default() -> Self {
1708 unsafe { ::std::mem::zeroed() }
1709 }
1710 }
1711 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1712 impl ::std::cmp::PartialEq for WINTRUST_DATA_0 {
1713 fn eq(&self, _other: &Self) -> bool {
1714 unimplemented!()
1715 }
1716 }
1717 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1718 impl ::std::cmp::Eq for WINTRUST_DATA_0 {}
1719 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
1720 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_0 {
1721 type Abi = Self;
1722 type DefaultType = Self;
1723 }
1724 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1725 #[repr(transparent)]
1726 pub struct WINTRUST_DATA_REVOCATION_CHECKS(pub u32);
1727 pub const WTD_REVOKE_NONE: WINTRUST_DATA_REVOCATION_CHECKS = WINTRUST_DATA_REVOCATION_CHECKS(0u32);
1728 pub const WTD_REVOKE_WHOLECHAIN: WINTRUST_DATA_REVOCATION_CHECKS = WINTRUST_DATA_REVOCATION_CHECKS(1u32);
1729 impl ::std::convert::From<u32> for WINTRUST_DATA_REVOCATION_CHECKS {
1730 fn from(value: u32) -> Self {
1731 Self(value)
1732 }
1733 }
1734 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_REVOCATION_CHECKS {
1735 type Abi = Self;
1736 type DefaultType = Self;
1737 }
1738 impl ::std::ops::BitOr for WINTRUST_DATA_REVOCATION_CHECKS {
1739 type Output = Self;
1740 fn bitor(self, rhs: Self) -> Self {
1741 Self(self.0 | rhs.0)
1742 }
1743 }
1744 impl ::std::ops::BitAnd for WINTRUST_DATA_REVOCATION_CHECKS {
1745 type Output = Self;
1746 fn bitand(self, rhs: Self) -> Self {
1747 Self(self.0 & rhs.0)
1748 }
1749 }
1750 impl ::std::ops::BitOrAssign for WINTRUST_DATA_REVOCATION_CHECKS {
1751 fn bitor_assign(&mut self, rhs: Self) {
1752 self.0.bitor_assign(rhs.0)
1753 }
1754 }
1755 impl ::std::ops::BitAndAssign for WINTRUST_DATA_REVOCATION_CHECKS {
1756 fn bitand_assign(&mut self, rhs: Self) {
1757 self.0.bitand_assign(rhs.0)
1758 }
1759 }
1760 impl ::std::ops::Not for WINTRUST_DATA_REVOCATION_CHECKS {
1761 type Output = Self;
1762 fn not(self) -> Self {
1763 Self(self.0.not())
1764 }
1765 }
1766 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1767 #[repr(transparent)]
1768 pub struct WINTRUST_DATA_STATE_ACTION(pub u32);
1769 pub const WTD_STATEACTION_IGNORE: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(0u32);
1770 pub const WTD_STATEACTION_VERIFY: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(1u32);
1771 pub const WTD_STATEACTION_CLOSE: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(2u32);
1772 pub const WTD_STATEACTION_AUTO_CACHE: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(3u32);
1773 pub const WTD_STATEACTION_AUTO_CACHE_FLUSH: WINTRUST_DATA_STATE_ACTION = WINTRUST_DATA_STATE_ACTION(4u32);
1774 impl ::std::convert::From<u32> for WINTRUST_DATA_STATE_ACTION {
1775 fn from(value: u32) -> Self {
1776 Self(value)
1777 }
1778 }
1779 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_STATE_ACTION {
1780 type Abi = Self;
1781 type DefaultType = Self;
1782 }
1783 impl ::std::ops::BitOr for WINTRUST_DATA_STATE_ACTION {
1784 type Output = Self;
1785 fn bitor(self, rhs: Self) -> Self {
1786 Self(self.0 | rhs.0)
1787 }
1788 }
1789 impl ::std::ops::BitAnd for WINTRUST_DATA_STATE_ACTION {
1790 type Output = Self;
1791 fn bitand(self, rhs: Self) -> Self {
1792 Self(self.0 & rhs.0)
1793 }
1794 }
1795 impl ::std::ops::BitOrAssign for WINTRUST_DATA_STATE_ACTION {
1796 fn bitor_assign(&mut self, rhs: Self) {
1797 self.0.bitor_assign(rhs.0)
1798 }
1799 }
1800 impl ::std::ops::BitAndAssign for WINTRUST_DATA_STATE_ACTION {
1801 fn bitand_assign(&mut self, rhs: Self) {
1802 self.0.bitand_assign(rhs.0)
1803 }
1804 }
1805 impl ::std::ops::Not for WINTRUST_DATA_STATE_ACTION {
1806 type Output = Self;
1807 fn not(self) -> Self {
1808 Self(self.0.not())
1809 }
1810 }
1811 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1812 #[repr(transparent)]
1813 pub struct WINTRUST_DATA_UICHOICE(pub u32);
1814 pub const WTD_UI_ALL: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(1u32);
1815 pub const WTD_UI_NONE: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(2u32);
1816 pub const WTD_UI_NOBAD: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(3u32);
1817 pub const WTD_UI_NOGOOD: WINTRUST_DATA_UICHOICE = WINTRUST_DATA_UICHOICE(4u32);
1818 impl ::std::convert::From<u32> for WINTRUST_DATA_UICHOICE {
1819 fn from(value: u32) -> Self {
1820 Self(value)
1821 }
1822 }
1823 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_UICHOICE {
1824 type Abi = Self;
1825 type DefaultType = Self;
1826 }
1827 impl ::std::ops::BitOr for WINTRUST_DATA_UICHOICE {
1828 type Output = Self;
1829 fn bitor(self, rhs: Self) -> Self {
1830 Self(self.0 | rhs.0)
1831 }
1832 }
1833 impl ::std::ops::BitAnd for WINTRUST_DATA_UICHOICE {
1834 type Output = Self;
1835 fn bitand(self, rhs: Self) -> Self {
1836 Self(self.0 & rhs.0)
1837 }
1838 }
1839 impl ::std::ops::BitOrAssign for WINTRUST_DATA_UICHOICE {
1840 fn bitor_assign(&mut self, rhs: Self) {
1841 self.0.bitor_assign(rhs.0)
1842 }
1843 }
1844 impl ::std::ops::BitAndAssign for WINTRUST_DATA_UICHOICE {
1845 fn bitand_assign(&mut self, rhs: Self) {
1846 self.0.bitand_assign(rhs.0)
1847 }
1848 }
1849 impl ::std::ops::Not for WINTRUST_DATA_UICHOICE {
1850 type Output = Self;
1851 fn not(self) -> Self {
1852 Self(self.0.not())
1853 }
1854 }
1855 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1856 #[repr(transparent)]
1857 pub struct WINTRUST_DATA_UICONTEXT(pub u32);
1858 pub const WTD_UICONTEXT_EXECUTE: WINTRUST_DATA_UICONTEXT = WINTRUST_DATA_UICONTEXT(0u32);
1859 pub const WTD_UICONTEXT_INSTALL: WINTRUST_DATA_UICONTEXT = WINTRUST_DATA_UICONTEXT(1u32);
1860 impl ::std::convert::From<u32> for WINTRUST_DATA_UICONTEXT {
1861 fn from(value: u32) -> Self {
1862 Self(value)
1863 }
1864 }
1865 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_UICONTEXT {
1866 type Abi = Self;
1867 type DefaultType = Self;
1868 }
1869 impl ::std::ops::BitOr for WINTRUST_DATA_UICONTEXT {
1870 type Output = Self;
1871 fn bitor(self, rhs: Self) -> Self {
1872 Self(self.0 | rhs.0)
1873 }
1874 }
1875 impl ::std::ops::BitAnd for WINTRUST_DATA_UICONTEXT {
1876 type Output = Self;
1877 fn bitand(self, rhs: Self) -> Self {
1878 Self(self.0 & rhs.0)
1879 }
1880 }
1881 impl ::std::ops::BitOrAssign for WINTRUST_DATA_UICONTEXT {
1882 fn bitor_assign(&mut self, rhs: Self) {
1883 self.0.bitor_assign(rhs.0)
1884 }
1885 }
1886 impl ::std::ops::BitAndAssign for WINTRUST_DATA_UICONTEXT {
1887 fn bitand_assign(&mut self, rhs: Self) {
1888 self.0.bitand_assign(rhs.0)
1889 }
1890 }
1891 impl ::std::ops::Not for WINTRUST_DATA_UICONTEXT {
1892 type Output = Self;
1893 fn not(self) -> Self {
1894 Self(self.0.not())
1895 }
1896 }
1897 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1898 #[repr(transparent)]
1899 pub struct WINTRUST_DATA_UNION_CHOICE(pub u32);
1900 pub const WTD_CHOICE_FILE: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(1u32);
1901 pub const WTD_CHOICE_CATALOG: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(2u32);
1902 pub const WTD_CHOICE_BLOB: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(3u32);
1903 pub const WTD_CHOICE_SIGNER: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(4u32);
1904 pub const WTD_CHOICE_CERT: WINTRUST_DATA_UNION_CHOICE = WINTRUST_DATA_UNION_CHOICE(5u32);
1905 impl ::std::convert::From<u32> for WINTRUST_DATA_UNION_CHOICE {
1906 fn from(value: u32) -> Self {
1907 Self(value)
1908 }
1909 }
1910 unsafe impl ::windows::runtime::Abi for WINTRUST_DATA_UNION_CHOICE {
1911 type Abi = Self;
1912 type DefaultType = Self;
1913 }
1914 impl ::std::ops::BitOr for WINTRUST_DATA_UNION_CHOICE {
1915 type Output = Self;
1916 fn bitor(self, rhs: Self) -> Self {
1917 Self(self.0 | rhs.0)
1918 }
1919 }
1920 impl ::std::ops::BitAnd for WINTRUST_DATA_UNION_CHOICE {
1921 type Output = Self;
1922 fn bitand(self, rhs: Self) -> Self {
1923 Self(self.0 & rhs.0)
1924 }
1925 }
1926 impl ::std::ops::BitOrAssign for WINTRUST_DATA_UNION_CHOICE {
1927 fn bitor_assign(&mut self, rhs: Self) {
1928 self.0.bitor_assign(rhs.0)
1929 }
1930 }
1931 impl ::std::ops::BitAndAssign for WINTRUST_DATA_UNION_CHOICE {
1932 fn bitand_assign(&mut self, rhs: Self) {
1933 self.0.bitand_assign(rhs.0)
1934 }
1935 }
1936 impl ::std::ops::Not for WINTRUST_DATA_UNION_CHOICE {
1937 type Output = Self;
1938 fn not(self) -> Self {
1939 Self(self.0.not())
1940 }
1941 }
1942 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1943 #[repr(C)]
1944 #[cfg(feature = "Win32_Foundation")]
1945 pub struct WINTRUST_FILE_INFO {
1946 pub cbStruct: u32,
1947 pub pcwszFilePath: super::super::Foundation::PWSTR,
1948 pub hFile: super::super::Foundation::HANDLE,
1949 pub pgKnownSubject: *mut ::windows::runtime::GUID,
1950 }
1951 #[cfg(feature = "Win32_Foundation")]
1952 impl WINTRUST_FILE_INFO {}
1953 #[cfg(feature = "Win32_Foundation")]
1954 impl ::std::default::Default for WINTRUST_FILE_INFO {
1955 fn default() -> Self {
1956 unsafe { ::std::mem::zeroed() }
1957 }
1958 }
1959 #[cfg(feature = "Win32_Foundation")]
1960 impl ::std::fmt::Debug for WINTRUST_FILE_INFO {
1961 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1962 fmt.debug_struct("WINTRUST_FILE_INFO").field("cbStruct", &self.cbStruct).field("pcwszFilePath", &self.pcwszFilePath).field("hFile", &self.hFile).field("pgKnownSubject", &self.pgKnownSubject).finish()
1963 }
1964 }
1965 #[cfg(feature = "Win32_Foundation")]
1966 impl ::std::cmp::PartialEq for WINTRUST_FILE_INFO {
1967 fn eq(&self, other: &Self) -> bool {
1968 self.cbStruct == other.cbStruct && self.pcwszFilePath == other.pcwszFilePath && self.hFile == other.hFile && self.pgKnownSubject == other.pgKnownSubject
1969 }
1970 }
1971 #[cfg(feature = "Win32_Foundation")]
1972 impl ::std::cmp::Eq for WINTRUST_FILE_INFO {}
1973 #[cfg(feature = "Win32_Foundation")]
1974 unsafe impl ::windows::runtime::Abi for WINTRUST_FILE_INFO {
1975 type Abi = Self;
1976 type DefaultType = Self;
1977 }
1978 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1979 #[repr(transparent)]
1980 pub struct WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION(pub u32);
1981 pub const DWACTION_ALLOCANDFILL: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION = WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION(1u32);
1982 pub const DWACTION_FREE: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION = WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION(2u32);
1983 impl ::std::convert::From<u32> for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1984 fn from(value: u32) -> Self {
1985 Self(value)
1986 }
1987 }
1988 unsafe impl ::windows::runtime::Abi for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1989 type Abi = Self;
1990 type DefaultType = Self;
1991 }
1992 impl ::std::ops::BitOr for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1993 type Output = Self;
1994 fn bitor(self, rhs: Self) -> Self {
1995 Self(self.0 | rhs.0)
1996 }
1997 }
1998 impl ::std::ops::BitAnd for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
1999 type Output = Self;
2000 fn bitand(self, rhs: Self) -> Self {
2001 Self(self.0 & rhs.0)
2002 }
2003 }
2004 impl ::std::ops::BitOrAssign for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
2005 fn bitor_assign(&mut self, rhs: Self) {
2006 self.0.bitor_assign(rhs.0)
2007 }
2008 }
2009 impl ::std::ops::BitAndAssign for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
2010 fn bitand_assign(&mut self, rhs: Self) {
2011 self.0.bitand_assign(rhs.0)
2012 }
2013 }
2014 impl ::std::ops::Not for WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION {
2015 type Output = Self;
2016 fn not(self) -> Self {
2017 Self(self.0.not())
2018 }
2019 }
2020 pub const WINTRUST_MAX_HASH_BYTES_TO_MAP_DEFAULT: u32 = 1048576u32;
2021 pub const WINTRUST_MAX_HEADER_BYTES_TO_MAP_DEFAULT: u32 = 10485760u32;
2022 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2023 #[repr(transparent)]
2024 pub struct WINTRUST_POLICY_FLAGS(pub u32);
2025 pub const WTPF_TRUSTTEST: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(32u32);
2026 pub const WTPF_TESTCANBEVALID: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(128u32);
2027 pub const WTPF_IGNOREEXPIRATION: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(256u32);
2028 pub const WTPF_IGNOREREVOKATION: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(512u32);
2029 pub const WTPF_OFFLINEOK_IND: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(1024u32);
2030 pub const WTPF_OFFLINEOK_COM: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(2048u32);
2031 pub const WTPF_OFFLINEOKNBU_IND: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(4096u32);
2032 pub const WTPF_OFFLINEOKNBU_COM: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(8192u32);
2033 pub const WTPF_VERIFY_V1_OFF: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(65536u32);
2034 pub const WTPF_IGNOREREVOCATIONONTS: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(131072u32);
2035 pub const WTPF_ALLOWONLYPERTRUST: WINTRUST_POLICY_FLAGS = WINTRUST_POLICY_FLAGS(262144u32);
2036 impl ::std::convert::From<u32> for WINTRUST_POLICY_FLAGS {
2037 fn from(value: u32) -> Self {
2038 Self(value)
2039 }
2040 }
2041 unsafe impl ::windows::runtime::Abi for WINTRUST_POLICY_FLAGS {
2042 type Abi = Self;
2043 type DefaultType = Self;
2044 }
2045 impl ::std::ops::BitOr for WINTRUST_POLICY_FLAGS {
2046 type Output = Self;
2047 fn bitor(self, rhs: Self) -> Self {
2048 Self(self.0 | rhs.0)
2049 }
2050 }
2051 impl ::std::ops::BitAnd for WINTRUST_POLICY_FLAGS {
2052 type Output = Self;
2053 fn bitand(self, rhs: Self) -> Self {
2054 Self(self.0 & rhs.0)
2055 }
2056 }
2057 impl ::std::ops::BitOrAssign for WINTRUST_POLICY_FLAGS {
2058 fn bitor_assign(&mut self, rhs: Self) {
2059 self.0.bitor_assign(rhs.0)
2060 }
2061 }
2062 impl ::std::ops::BitAndAssign for WINTRUST_POLICY_FLAGS {
2063 fn bitand_assign(&mut self, rhs: Self) {
2064 self.0.bitand_assign(rhs.0)
2065 }
2066 }
2067 impl ::std::ops::Not for WINTRUST_POLICY_FLAGS {
2068 type Output = Self;
2069 fn not(self) -> Self {
2070 Self(self.0.not())
2071 }
2072 }
2073 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2074 #[repr(C)]
2075 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2076 pub struct WINTRUST_SGNR_INFO {
2077 pub cbStruct: u32,
2078 pub pcwszDisplayName: super::super::Foundation::PWSTR,
2079 pub psSignerInfo: *mut super::Cryptography::CMSG_SIGNER_INFO,
2080 pub chStores: u32,
2081 pub pahStores: *mut *mut ::std::ffi::c_void,
2082 }
2083 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2084 impl WINTRUST_SGNR_INFO {}
2085 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2086 impl ::std::default::Default for WINTRUST_SGNR_INFO {
2087 fn default() -> Self {
2088 unsafe { ::std::mem::zeroed() }
2089 }
2090 }
2091 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2092 impl ::std::fmt::Debug for WINTRUST_SGNR_INFO {
2093 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2094 fmt.debug_struct("WINTRUST_SGNR_INFO").field("cbStruct", &self.cbStruct).field("pcwszDisplayName", &self.pcwszDisplayName).field("psSignerInfo", &self.psSignerInfo).field("chStores", &self.chStores).field("pahStores", &self.pahStores).finish()
2095 }
2096 }
2097 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2098 impl ::std::cmp::PartialEq for WINTRUST_SGNR_INFO {
2099 fn eq(&self, other: &Self) -> bool {
2100 self.cbStruct == other.cbStruct && self.pcwszDisplayName == other.pcwszDisplayName && self.psSignerInfo == other.psSignerInfo && self.chStores == other.chStores && self.pahStores == other.pahStores
2101 }
2102 }
2103 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2104 impl ::std::cmp::Eq for WINTRUST_SGNR_INFO {}
2105 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2106 unsafe impl ::windows::runtime::Abi for WINTRUST_SGNR_INFO {
2107 type Abi = Self;
2108 type DefaultType = Self;
2109 }
2110 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2111 #[repr(C)]
2112 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2113 pub struct WINTRUST_SIGNATURE_SETTINGS {
2114 pub cbStruct: u32,
2115 pub dwIndex: u32,
2116 pub dwFlags: WINTRUST_SIGNATURE_SETTINGS_FLAGS,
2117 pub cSecondarySigs: u32,
2118 pub dwVerifiedSigIndex: u32,
2119 pub pCryptoPolicy: *mut super::Cryptography::CERT_STRONG_SIGN_PARA,
2120 }
2121 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2122 impl WINTRUST_SIGNATURE_SETTINGS {}
2123 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2124 impl ::std::default::Default for WINTRUST_SIGNATURE_SETTINGS {
2125 fn default() -> Self {
2126 unsafe { ::std::mem::zeroed() }
2127 }
2128 }
2129 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2130 impl ::std::fmt::Debug for WINTRUST_SIGNATURE_SETTINGS {
2131 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2132 fmt.debug_struct("WINTRUST_SIGNATURE_SETTINGS").field("cbStruct", &self.cbStruct).field("dwIndex", &self.dwIndex).field("dwFlags", &self.dwFlags).field("cSecondarySigs", &self.cSecondarySigs).field("dwVerifiedSigIndex", &self.dwVerifiedSigIndex).field("pCryptoPolicy", &self.pCryptoPolicy).finish()
2133 }
2134 }
2135 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2136 impl ::std::cmp::PartialEq for WINTRUST_SIGNATURE_SETTINGS {
2137 fn eq(&self, other: &Self) -> bool {
2138 self.cbStruct == other.cbStruct && self.dwIndex == other.dwIndex && self.dwFlags == other.dwFlags && self.cSecondarySigs == other.cSecondarySigs && self.dwVerifiedSigIndex == other.dwVerifiedSigIndex && self.pCryptoPolicy == other.pCryptoPolicy
2139 }
2140 }
2141 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2142 impl ::std::cmp::Eq for WINTRUST_SIGNATURE_SETTINGS {}
2143 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2144 unsafe impl ::windows::runtime::Abi for WINTRUST_SIGNATURE_SETTINGS {
2145 type Abi = Self;
2146 type DefaultType = Self;
2147 }
2148 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
2149 #[repr(transparent)]
2150 pub struct WINTRUST_SIGNATURE_SETTINGS_FLAGS(pub u32);
2151 pub const WSS_VERIFY_SPECIFIC: WINTRUST_SIGNATURE_SETTINGS_FLAGS = WINTRUST_SIGNATURE_SETTINGS_FLAGS(1u32);
2152 pub const WSS_GET_SECONDARY_SIG_COUNT: WINTRUST_SIGNATURE_SETTINGS_FLAGS = WINTRUST_SIGNATURE_SETTINGS_FLAGS(2u32);
2153 impl ::std::convert::From<u32> for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2154 fn from(value: u32) -> Self {
2155 Self(value)
2156 }
2157 }
2158 unsafe impl ::windows::runtime::Abi for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2159 type Abi = Self;
2160 type DefaultType = Self;
2161 }
2162 impl ::std::ops::BitOr for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2163 type Output = Self;
2164 fn bitor(self, rhs: Self) -> Self {
2165 Self(self.0 | rhs.0)
2166 }
2167 }
2168 impl ::std::ops::BitAnd for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2169 type Output = Self;
2170 fn bitand(self, rhs: Self) -> Self {
2171 Self(self.0 & rhs.0)
2172 }
2173 }
2174 impl ::std::ops::BitOrAssign for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2175 fn bitor_assign(&mut self, rhs: Self) {
2176 self.0.bitor_assign(rhs.0)
2177 }
2178 }
2179 impl ::std::ops::BitAndAssign for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2180 fn bitand_assign(&mut self, rhs: Self) {
2181 self.0.bitand_assign(rhs.0)
2182 }
2183 }
2184 impl ::std::ops::Not for WINTRUST_SIGNATURE_SETTINGS_FLAGS {
2185 type Output = Self;
2186 fn not(self) -> Self {
2187 Self(self.0.not())
2188 }
2189 }
2190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2191 #[repr(C)]
2192 pub struct WIN_CERTIFICATE {
2193 pub dwLength: u32,
2194 pub wRevision: u16,
2195 pub wCertificateType: u16,
2196 pub bCertificate: [u8; 1],
2197 }
2198 impl WIN_CERTIFICATE {}
2199 impl ::std::default::Default for WIN_CERTIFICATE {
2200 fn default() -> Self {
2201 unsafe { ::std::mem::zeroed() }
2202 }
2203 }
2204 impl ::std::fmt::Debug for WIN_CERTIFICATE {
2205 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2206 fmt.debug_struct("WIN_CERTIFICATE").field("dwLength", &self.dwLength).field("wRevision", &self.wRevision).field("wCertificateType", &self.wCertificateType).field("bCertificate", &self.bCertificate).finish()
2207 }
2208 }
2209 impl ::std::cmp::PartialEq for WIN_CERTIFICATE {
2210 fn eq(&self, other: &Self) -> bool {
2211 self.dwLength == other.dwLength && self.wRevision == other.wRevision && self.wCertificateType == other.wCertificateType && self.bCertificate == other.bCertificate
2212 }
2213 }
2214 impl ::std::cmp::Eq for WIN_CERTIFICATE {}
2215 unsafe impl ::windows::runtime::Abi for WIN_CERTIFICATE {
2216 type Abi = Self;
2217 type DefaultType = Self;
2218 }
2219 pub const WIN_CERT_REVISION_1_0: u32 = 256u32;
2220 pub const WIN_CERT_REVISION_2_0: u32 = 512u32;
2221 pub const WIN_CERT_TYPE_PKCS_SIGNED_DATA: u32 = 2u32;
2222 pub const WIN_CERT_TYPE_RESERVED_1: u32 = 3u32;
2223 pub const WIN_CERT_TYPE_TS_STACK_SIGNED: u32 = 4u32;
2224 pub const WIN_CERT_TYPE_X509: u32 = 1u32;
2225 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2226 #[repr(C)]
2227 #[cfg(feature = "Win32_Foundation")]
2228 pub struct WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2229 pub hClientToken: super::super::Foundation::HANDLE,
2230 pub lpCertificate: *mut WIN_CERTIFICATE,
2231 }
2232 #[cfg(feature = "Win32_Foundation")]
2233 impl WIN_SPUB_TRUSTED_PUBLISHER_DATA {}
2234 #[cfg(feature = "Win32_Foundation")]
2235 impl ::std::default::Default for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2236 fn default() -> Self {
2237 unsafe { ::std::mem::zeroed() }
2238 }
2239 }
2240 #[cfg(feature = "Win32_Foundation")]
2241 impl ::std::fmt::Debug for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2242 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2243 fmt.debug_struct("WIN_SPUB_TRUSTED_PUBLISHER_DATA").field("hClientToken", &self.hClientToken).field("lpCertificate", &self.lpCertificate).finish()
2244 }
2245 }
2246 #[cfg(feature = "Win32_Foundation")]
2247 impl ::std::cmp::PartialEq for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2248 fn eq(&self, other: &Self) -> bool {
2249 self.hClientToken == other.hClientToken && self.lpCertificate == other.lpCertificate
2250 }
2251 }
2252 #[cfg(feature = "Win32_Foundation")]
2253 impl ::std::cmp::Eq for WIN_SPUB_TRUSTED_PUBLISHER_DATA {}
2254 #[cfg(feature = "Win32_Foundation")]
2255 unsafe impl ::windows::runtime::Abi for WIN_SPUB_TRUSTED_PUBLISHER_DATA {
2256 type Abi = Self;
2257 type DefaultType = Self;
2258 }
2259 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2260 #[repr(C)]
2261 #[cfg(feature = "Win32_Foundation")]
2262 pub struct WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2263 pub hClientToken: super::super::Foundation::HANDLE,
2264 pub SubjectType: *mut ::windows::runtime::GUID,
2265 pub Subject: *mut ::std::ffi::c_void,
2266 }
2267 #[cfg(feature = "Win32_Foundation")]
2268 impl WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {}
2269 #[cfg(feature = "Win32_Foundation")]
2270 impl ::std::default::Default for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2271 fn default() -> Self {
2272 unsafe { ::std::mem::zeroed() }
2273 }
2274 }
2275 #[cfg(feature = "Win32_Foundation")]
2276 impl ::std::fmt::Debug for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2277 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2278 fmt.debug_struct("WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT").field("hClientToken", &self.hClientToken).field("SubjectType", &self.SubjectType).field("Subject", &self.Subject).finish()
2279 }
2280 }
2281 #[cfg(feature = "Win32_Foundation")]
2282 impl ::std::cmp::PartialEq for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2283 fn eq(&self, other: &Self) -> bool {
2284 self.hClientToken == other.hClientToken && self.SubjectType == other.SubjectType && self.Subject == other.Subject
2285 }
2286 }
2287 #[cfg(feature = "Win32_Foundation")]
2288 impl ::std::cmp::Eq for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {}
2289 #[cfg(feature = "Win32_Foundation")]
2290 unsafe impl ::windows::runtime::Abi for WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT {
2291 type Abi = Self;
2292 type DefaultType = Self;
2293 }
2294 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2295 #[repr(C)]
2296 pub struct WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2297 pub SubjectType: *mut ::windows::runtime::GUID,
2298 pub Subject: *mut ::std::ffi::c_void,
2299 }
2300 impl WIN_TRUST_ACTDATA_SUBJECT_ONLY {}
2301 impl ::std::default::Default for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2302 fn default() -> Self {
2303 unsafe { ::std::mem::zeroed() }
2304 }
2305 }
2306 impl ::std::fmt::Debug for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2307 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2308 fmt.debug_struct("WIN_TRUST_ACTDATA_SUBJECT_ONLY").field("SubjectType", &self.SubjectType).field("Subject", &self.Subject).finish()
2309 }
2310 }
2311 impl ::std::cmp::PartialEq for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2312 fn eq(&self, other: &Self) -> bool {
2313 self.SubjectType == other.SubjectType && self.Subject == other.Subject
2314 }
2315 }
2316 impl ::std::cmp::Eq for WIN_TRUST_ACTDATA_SUBJECT_ONLY {}
2317 unsafe impl ::windows::runtime::Abi for WIN_TRUST_ACTDATA_SUBJECT_ONLY {
2318 type Abi = Self;
2319 type DefaultType = Self;
2320 }
2321 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2322 #[repr(C)]
2323 #[cfg(feature = "Win32_Foundation")]
2324 pub struct WIN_TRUST_SUBJECT_FILE {
2325 pub hFile: super::super::Foundation::HANDLE,
2326 pub lpPath: super::super::Foundation::PWSTR,
2327 }
2328 #[cfg(feature = "Win32_Foundation")]
2329 impl WIN_TRUST_SUBJECT_FILE {}
2330 #[cfg(feature = "Win32_Foundation")]
2331 impl ::std::default::Default for WIN_TRUST_SUBJECT_FILE {
2332 fn default() -> Self {
2333 unsafe { ::std::mem::zeroed() }
2334 }
2335 }
2336 #[cfg(feature = "Win32_Foundation")]
2337 impl ::std::fmt::Debug for WIN_TRUST_SUBJECT_FILE {
2338 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2339 fmt.debug_struct("WIN_TRUST_SUBJECT_FILE").field("hFile", &self.hFile).field("lpPath", &self.lpPath).finish()
2340 }
2341 }
2342 #[cfg(feature = "Win32_Foundation")]
2343 impl ::std::cmp::PartialEq for WIN_TRUST_SUBJECT_FILE {
2344 fn eq(&self, other: &Self) -> bool {
2345 self.hFile == other.hFile && self.lpPath == other.lpPath
2346 }
2347 }
2348 #[cfg(feature = "Win32_Foundation")]
2349 impl ::std::cmp::Eq for WIN_TRUST_SUBJECT_FILE {}
2350 #[cfg(feature = "Win32_Foundation")]
2351 unsafe impl ::windows::runtime::Abi for WIN_TRUST_SUBJECT_FILE {
2352 type Abi = Self;
2353 type DefaultType = Self;
2354 }
2355 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2356 #[repr(C)]
2357 #[cfg(feature = "Win32_Foundation")]
2358 pub struct WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2359 pub hFile: super::super::Foundation::HANDLE,
2360 pub lpPath: super::super::Foundation::PWSTR,
2361 pub lpDisplayName: super::super::Foundation::PWSTR,
2362 }
2363 #[cfg(feature = "Win32_Foundation")]
2364 impl WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {}
2365 #[cfg(feature = "Win32_Foundation")]
2366 impl ::std::default::Default for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2367 fn default() -> Self {
2368 unsafe { ::std::mem::zeroed() }
2369 }
2370 }
2371 #[cfg(feature = "Win32_Foundation")]
2372 impl ::std::fmt::Debug for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2373 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2374 fmt.debug_struct("WIN_TRUST_SUBJECT_FILE_AND_DISPLAY").field("hFile", &self.hFile).field("lpPath", &self.lpPath).field("lpDisplayName", &self.lpDisplayName).finish()
2375 }
2376 }
2377 #[cfg(feature = "Win32_Foundation")]
2378 impl ::std::cmp::PartialEq for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2379 fn eq(&self, other: &Self) -> bool {
2380 self.hFile == other.hFile && self.lpPath == other.lpPath && self.lpDisplayName == other.lpDisplayName
2381 }
2382 }
2383 #[cfg(feature = "Win32_Foundation")]
2384 impl ::std::cmp::Eq for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {}
2385 #[cfg(feature = "Win32_Foundation")]
2386 unsafe impl ::windows::runtime::Abi for WIN_TRUST_SUBJECT_FILE_AND_DISPLAY {
2387 type Abi = Self;
2388 type DefaultType = Self;
2389 }
2390 pub const WSS_CERTTRUST_SUPPORT: u32 = 4u32;
2391 pub const WSS_INPUT_FLAG_MASK: u32 = 7u32;
2392 pub const WSS_OBJTRUST_SUPPORT: u32 = 1u32;
2393 pub const WSS_OUTPUT_FLAG_MASK: u32 = 3758096384u32;
2394 pub const WSS_OUT_FILE_SUPPORTS_SEAL: u32 = 536870912u32;
2395 pub const WSS_OUT_HAS_SEALING_INTENT: u32 = 1073741824u32;
2396 pub const WSS_OUT_SEALING_STATUS_VERIFIED: u32 = 2147483648u32;
2397 pub const WSS_SIGTRUST_SUPPORT: u32 = 2u32;
2398 pub const WSS_VERIFY_SEALING: u32 = 4u32;
2399 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2400 #[repr(C)]
2401 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2402 pub struct WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2403 pub Anonymous: WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0,
2404 pub hChainEngine: super::Cryptography::HCERTCHAINENGINE,
2405 pub pChainPara: *mut super::Cryptography::CERT_CHAIN_PARA,
2406 pub dwFlags: u32,
2407 pub pvReserved: *mut ::std::ffi::c_void,
2408 }
2409 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2410 impl WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {}
2411 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2412 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2413 fn default() -> Self {
2414 unsafe { ::std::mem::zeroed() }
2415 }
2416 }
2417 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2418 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2419 fn eq(&self, _other: &Self) -> bool {
2420 unimplemented!()
2421 }
2422 }
2423 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2424 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {}
2425 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2426 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO {
2427 type Abi = Self;
2428 type DefaultType = Self;
2429 }
2430 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2431 #[repr(C)]
2432 pub union WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2433 pub cbStruct: u32,
2434 pub cbSize: u32,
2435 }
2436 impl WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {}
2437 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2438 fn default() -> Self {
2439 unsafe { ::std::mem::zeroed() }
2440 }
2441 }
2442 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2443 fn eq(&self, _other: &Self) -> bool {
2444 unimplemented!()
2445 }
2446 }
2447 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {}
2448 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_CREATE_INFO_0 {
2449 type Abi = Self;
2450 type DefaultType = Self;
2451 }
2452 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2453 impl ::std::clone::Clone for WTD_GENERIC_CHAIN_POLICY_DATA {
2454 fn clone(&self) -> Self {
2455 unimplemented!()
2456 }
2457 }
2458 #[repr(C)]
2459 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2460 pub struct WTD_GENERIC_CHAIN_POLICY_DATA {
2461 pub Anonymous: WTD_GENERIC_CHAIN_POLICY_DATA_0,
2462 pub pSignerChainInfo: *mut WTD_GENERIC_CHAIN_POLICY_CREATE_INFO,
2463 pub pCounterSignerChainInfo: *mut WTD_GENERIC_CHAIN_POLICY_CREATE_INFO,
2464 pub pfnPolicyCallback: ::std::option::Option<PFN_WTD_GENERIC_CHAIN_POLICY_CALLBACK>,
2465 pub pvPolicyArg: *mut ::std::ffi::c_void,
2466 }
2467 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2468 impl WTD_GENERIC_CHAIN_POLICY_DATA {}
2469 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2470 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_DATA {
2471 fn default() -> Self {
2472 unsafe { ::std::mem::zeroed() }
2473 }
2474 }
2475 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2476 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_DATA {
2477 fn eq(&self, _other: &Self) -> bool {
2478 unimplemented!()
2479 }
2480 }
2481 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2482 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_DATA {}
2483 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2484 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_DATA {
2485 type Abi = ::std::mem::ManuallyDrop<Self>;
2486 type DefaultType = Self;
2487 }
2488 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2489 #[repr(C)]
2490 pub union WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2491 pub cbStruct: u32,
2492 pub cbSize: u32,
2493 }
2494 impl WTD_GENERIC_CHAIN_POLICY_DATA_0 {}
2495 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2496 fn default() -> Self {
2497 unsafe { ::std::mem::zeroed() }
2498 }
2499 }
2500 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2501 fn eq(&self, _other: &Self) -> bool {
2502 unimplemented!()
2503 }
2504 }
2505 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_DATA_0 {}
2506 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_DATA_0 {
2507 type Abi = Self;
2508 type DefaultType = Self;
2509 }
2510 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2511 #[repr(C)]
2512 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2513 pub struct WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2514 pub Anonymous: WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0,
2515 pub pChainContext: *mut super::Cryptography::CERT_CHAIN_CONTEXT,
2516 pub dwSignerType: u32,
2517 pub pMsgSignerInfo: *mut super::Cryptography::CMSG_SIGNER_INFO,
2518 pub dwError: u32,
2519 pub cCounterSigner: u32,
2520 pub rgpCounterSigner: *mut *mut WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO,
2521 }
2522 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2523 impl WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {}
2524 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2525 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2526 fn default() -> Self {
2527 unsafe { ::std::mem::zeroed() }
2528 }
2529 }
2530 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2531 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2532 fn eq(&self, _other: &Self) -> bool {
2533 unimplemented!()
2534 }
2535 }
2536 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2537 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {}
2538 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2539 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO {
2540 type Abi = Self;
2541 type DefaultType = Self;
2542 }
2543 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2544 #[repr(C)]
2545 pub union WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2546 pub cbStruct: u32,
2547 pub cbSize: u32,
2548 }
2549 impl WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {}
2550 impl ::std::default::Default for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2551 fn default() -> Self {
2552 unsafe { ::std::mem::zeroed() }
2553 }
2554 }
2555 impl ::std::cmp::PartialEq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2556 fn eq(&self, _other: &Self) -> bool {
2557 unimplemented!()
2558 }
2559 }
2560 impl ::std::cmp::Eq for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {}
2561 unsafe impl ::windows::runtime::Abi for WTD_GENERIC_CHAIN_POLICY_SIGNER_INFO_0 {
2562 type Abi = Self;
2563 type DefaultType = Self;
2564 }
2565 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2566 #[inline]
2567 pub unsafe fn WTHelperCertCheckValidSignature(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::Result<()> {
2568 #[cfg(windows)]
2569 {
2570 #[link(name = "windows")]
2571 extern "system" {
2572 fn WTHelperCertCheckValidSignature(pprovdata: *mut CRYPT_PROVIDER_DATA) -> ::windows::runtime::HRESULT;
2573 }
2574 WTHelperCertCheckValidSignature(::std::mem::transmute(pprovdata)).ok()
2575 }
2576 #[cfg(not(windows))]
2577 unimplemented!("Unsupported target OS");
2578 }
2579 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2580 #[inline]
2581 pub unsafe fn WTHelperCertIsSelfSigned(dwencoding: u32, pcert: *mut super::Cryptography::CERT_INFO) -> super::super::Foundation::BOOL {
2582 #[cfg(windows)]
2583 {
2584 #[link(name = "windows")]
2585 extern "system" {
2586 fn WTHelperCertIsSelfSigned(dwencoding: u32, pcert: *mut super::Cryptography::CERT_INFO) -> super::super::Foundation::BOOL;
2587 }
2588 ::std::mem::transmute(WTHelperCertIsSelfSigned(::std::mem::transmute(dwencoding), ::std::mem::transmute(pcert)))
2589 }
2590 #[cfg(not(windows))]
2591 unimplemented!("Unsupported target OS");
2592 }
2593 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2594 #[inline]
2595 pub unsafe fn WTHelperGetProvCertFromChain(psgnr: *mut CRYPT_PROVIDER_SGNR, idxcert: u32) -> *mut CRYPT_PROVIDER_CERT {
2596 #[cfg(windows)]
2597 {
2598 #[link(name = "windows")]
2599 extern "system" {
2600 fn WTHelperGetProvCertFromChain(psgnr: *mut CRYPT_PROVIDER_SGNR, idxcert: u32) -> *mut CRYPT_PROVIDER_CERT;
2601 }
2602 ::std::mem::transmute(WTHelperGetProvCertFromChain(::std::mem::transmute(psgnr), ::std::mem::transmute(idxcert)))
2603 }
2604 #[cfg(not(windows))]
2605 unimplemented!("Unsupported target OS");
2606 }
2607 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2608 #[inline]
2609 pub unsafe fn WTHelperGetProvPrivateDataFromChain(pprovdata: *mut CRYPT_PROVIDER_DATA, pgproviderid: *mut ::windows::runtime::GUID) -> *mut CRYPT_PROVIDER_PRIVDATA {
2610 #[cfg(windows)]
2611 {
2612 #[link(name = "windows")]
2613 extern "system" {
2614 fn WTHelperGetProvPrivateDataFromChain(pprovdata: *mut CRYPT_PROVIDER_DATA, pgproviderid: *mut ::windows::runtime::GUID) -> *mut CRYPT_PROVIDER_PRIVDATA;
2615 }
2616 ::std::mem::transmute(WTHelperGetProvPrivateDataFromChain(::std::mem::transmute(pprovdata), ::std::mem::transmute(pgproviderid)))
2617 }
2618 #[cfg(not(windows))]
2619 unimplemented!("Unsupported target OS");
2620 }
2621 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2622 #[inline]
2623 pub unsafe fn WTHelperGetProvSignerFromChain<'a, Param2: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(pprovdata: *mut CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersigner: Param2, idxcountersigner: u32) -> *mut CRYPT_PROVIDER_SGNR {
2624 #[cfg(windows)]
2625 {
2626 #[link(name = "windows")]
2627 extern "system" {
2628 fn WTHelperGetProvSignerFromChain(pprovdata: *mut CRYPT_PROVIDER_DATA, idxsigner: u32, fcountersigner: super::super::Foundation::BOOL, idxcountersigner: u32) -> *mut CRYPT_PROVIDER_SGNR;
2629 }
2630 ::std::mem::transmute(WTHelperGetProvSignerFromChain(::std::mem::transmute(pprovdata), ::std::mem::transmute(idxsigner), fcountersigner.into_param().abi(), ::std::mem::transmute(idxcountersigner)))
2631 }
2632 #[cfg(not(windows))]
2633 unimplemented!("Unsupported target OS");
2634 }
2635 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2636 #[inline]
2637 pub unsafe fn WTHelperProvDataFromStateData<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HANDLE>>(hstatedata: Param0) -> *mut CRYPT_PROVIDER_DATA {
2638 #[cfg(windows)]
2639 {
2640 #[link(name = "windows")]
2641 extern "system" {
2642 fn WTHelperProvDataFromStateData(hstatedata: super::super::Foundation::HANDLE) -> *mut CRYPT_PROVIDER_DATA;
2643 }
2644 ::std::mem::transmute(WTHelperProvDataFromStateData(hstatedata.into_param().abi()))
2645 }
2646 #[cfg(not(windows))]
2647 unimplemented!("Unsupported target OS");
2648 }
2649 pub const WT_ADD_ACTION_ID_RET_RESULT_FLAG: u32 = 1u32;
2650 pub const WT_CURRENT_VERSION: u32 = 512u32;
2651 pub const WT_TRUSTDBDIALOG_NO_UI_FLAG: u32 = 1u32;
2652 pub const WT_TRUSTDBDIALOG_ONLY_PUB_TAB_FLAG: u32 = 2u32;
2653 pub const WT_TRUSTDBDIALOG_WRITE_IEAK_STORE_FLAG: u32 = 512u32;
2654 pub const WT_TRUSTDBDIALOG_WRITE_LEGACY_REG_FLAG: u32 = 256u32;
2655 #[cfg(feature = "Win32_Foundation")]
2656 #[inline]
2657 pub unsafe fn WinVerifyTrust<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, pgactionid: *mut ::windows::runtime::GUID, pwvtdata: *mut ::std::ffi::c_void) -> i32 {
2658 #[cfg(windows)]
2659 {
2660 #[link(name = "windows")]
2661 extern "system" {
2662 fn WinVerifyTrust(hwnd: super::super::Foundation::HWND, pgactionid: *mut ::windows::runtime::GUID, pwvtdata: *mut ::std::ffi::c_void) -> i32;
2663 }
2664 ::std::mem::transmute(WinVerifyTrust(hwnd.into_param().abi(), ::std::mem::transmute(pgactionid), ::std::mem::transmute(pwvtdata)))
2665 }
2666 #[cfg(not(windows))]
2667 unimplemented!("Unsupported target OS");
2668 }
2669 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography"))]
2670 #[inline]
2671 pub unsafe fn WinVerifyTrustEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::HWND>>(hwnd: Param0, pgactionid: *mut ::windows::runtime::GUID, pwintrustdata: *mut WINTRUST_DATA) -> i32 {
2672 #[cfg(windows)]
2673 {
2674 #[link(name = "windows")]
2675 extern "system" {
2676 fn WinVerifyTrustEx(hwnd: super::super::Foundation::HWND, pgactionid: *mut ::windows::runtime::GUID, pwintrustdata: *mut WINTRUST_DATA) -> i32;
2677 }
2678 ::std::mem::transmute(WinVerifyTrustEx(hwnd.into_param().abi(), ::std::mem::transmute(pgactionid), ::std::mem::transmute(pwintrustdata)))
2679 }
2680 #[cfg(not(windows))]
2681 unimplemented!("Unsupported target OS");
2682 }
2683 #[cfg(feature = "Win32_Foundation")]
2684 #[inline]
2685 pub unsafe fn WintrustAddActionID(pgactionid: *const ::windows::runtime::GUID, fdwflags: u32, psprovinfo: *const CRYPT_REGISTER_ACTIONID) -> super::super::Foundation::BOOL {
2686 #[cfg(windows)]
2687 {
2688 #[link(name = "windows")]
2689 extern "system" {
2690 fn WintrustAddActionID(pgactionid: *const ::windows::runtime::GUID, fdwflags: u32, psprovinfo: *const CRYPT_REGISTER_ACTIONID) -> super::super::Foundation::BOOL;
2691 }
2692 ::std::mem::transmute(WintrustAddActionID(::std::mem::transmute(pgactionid), ::std::mem::transmute(fdwflags), ::std::mem::transmute(psprovinfo)))
2693 }
2694 #[cfg(not(windows))]
2695 unimplemented!("Unsupported target OS");
2696 }
2697 #[cfg(feature = "Win32_Foundation")]
2698 #[inline]
2699 pub unsafe fn WintrustAddDefaultForUsage<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(pszusageoid: Param0, psdefusage: *const CRYPT_PROVIDER_REGDEFUSAGE) -> super::super::Foundation::BOOL {
2700 #[cfg(windows)]
2701 {
2702 #[link(name = "windows")]
2703 extern "system" {
2704 fn WintrustAddDefaultForUsage(pszusageoid: super::super::Foundation::PSTR, psdefusage: *const CRYPT_PROVIDER_REGDEFUSAGE) -> super::super::Foundation::BOOL;
2705 }
2706 ::std::mem::transmute(WintrustAddDefaultForUsage(pszusageoid.into_param().abi(), ::std::mem::transmute(psdefusage)))
2707 }
2708 #[cfg(not(windows))]
2709 unimplemented!("Unsupported target OS");
2710 }
2711 #[cfg(feature = "Win32_Foundation")]
2712 #[inline]
2713 pub unsafe fn WintrustGetDefaultForUsage<'a, Param1: ::windows::runtime::IntoParam<'a, super::super::Foundation::PSTR>>(dwaction: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION, pszusageoid: Param1, psusage: *mut CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL {
2714 #[cfg(windows)]
2715 {
2716 #[link(name = "windows")]
2717 extern "system" {
2718 fn WintrustGetDefaultForUsage(dwaction: WINTRUST_GET_DEFAULT_FOR_USAGE_ACTION, pszusageoid: super::super::Foundation::PSTR, psusage: *mut CRYPT_PROVIDER_DEFUSAGE) -> super::super::Foundation::BOOL;
2719 }
2720 ::std::mem::transmute(WintrustGetDefaultForUsage(::std::mem::transmute(dwaction), pszusageoid.into_param().abi(), ::std::mem::transmute(psusage)))
2721 }
2722 #[cfg(not(windows))]
2723 unimplemented!("Unsupported target OS");
2724 }
2725 #[inline]
2726 pub unsafe fn WintrustGetRegPolicyFlags(pdwpolicyflags: *mut WINTRUST_POLICY_FLAGS) {
2727 #[cfg(windows)]
2728 {
2729 #[link(name = "windows")]
2730 extern "system" {
2731 fn WintrustGetRegPolicyFlags(pdwpolicyflags: *mut WINTRUST_POLICY_FLAGS);
2732 }
2733 ::std::mem::transmute(WintrustGetRegPolicyFlags(::std::mem::transmute(pdwpolicyflags)))
2734 }
2735 #[cfg(not(windows))]
2736 unimplemented!("Unsupported target OS");
2737 }
2738 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_Cryptography", feature = "Win32_Security_Cryptography_Catalog", feature = "Win32_Security_Cryptography_Sip"))]
2739 #[inline]
2740 pub unsafe fn WintrustLoadFunctionPointers(pgactionid: *mut ::windows::runtime::GUID, ppfns: *mut CRYPT_PROVIDER_FUNCTIONS) -> super::super::Foundation::BOOL {
2741 #[cfg(windows)]
2742 {
2743 #[link(name = "windows")]
2744 extern "system" {
2745 fn WintrustLoadFunctionPointers(pgactionid: *mut ::windows::runtime::GUID, ppfns: *mut ::std::mem::ManuallyDrop<CRYPT_PROVIDER_FUNCTIONS>) -> super::super::Foundation::BOOL;
2746 }
2747 ::std::mem::transmute(WintrustLoadFunctionPointers(::std::mem::transmute(pgactionid), ::std::mem::transmute(ppfns)))
2748 }
2749 #[cfg(not(windows))]
2750 unimplemented!("Unsupported target OS");
2751 }
2752 #[cfg(feature = "Win32_Foundation")]
2753 #[inline]
2754 pub unsafe fn WintrustRemoveActionID(pgactionid: *const ::windows::runtime::GUID) -> super::super::Foundation::BOOL {
2755 #[cfg(windows)]
2756 {
2757 #[link(name = "windows")]
2758 extern "system" {
2759 fn WintrustRemoveActionID(pgactionid: *const ::windows::runtime::GUID) -> super::super::Foundation::BOOL;
2760 }
2761 ::std::mem::transmute(WintrustRemoveActionID(::std::mem::transmute(pgactionid)))
2762 }
2763 #[cfg(not(windows))]
2764 unimplemented!("Unsupported target OS");
2765 }
2766 #[cfg(feature = "Win32_Foundation")]
2767 #[inline]
2768 pub unsafe fn WintrustSetDefaultIncludePEPageHashes<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::Foundation::BOOL>>(fincludepepagehashes: Param0) {
2769 #[cfg(windows)]
2770 {
2771 #[link(name = "windows")]
2772 extern "system" {
2773 fn WintrustSetDefaultIncludePEPageHashes(fincludepepagehashes: super::super::Foundation::BOOL);
2774 }
2775 ::std::mem::transmute(WintrustSetDefaultIncludePEPageHashes(fincludepepagehashes.into_param().abi()))
2776 }
2777 #[cfg(not(windows))]
2778 unimplemented!("Unsupported target OS");
2779 }
2780 #[cfg(feature = "Win32_Foundation")]
2781 #[inline]
2782 pub unsafe fn WintrustSetRegPolicyFlags(dwpolicyflags: WINTRUST_POLICY_FLAGS) -> super::super::Foundation::BOOL {
2783 #[cfg(windows)]
2784 {
2785 #[link(name = "windows")]
2786 extern "system" {
2787 fn WintrustSetRegPolicyFlags(dwpolicyflags: WINTRUST_POLICY_FLAGS) -> super::super::Foundation::BOOL;
2788 }
2789 ::std::mem::transmute(WintrustSetRegPolicyFlags(::std::mem::transmute(dwpolicyflags)))
2790 }
2791 #[cfg(not(windows))]
2792 unimplemented!("Unsupported target OS");
2793 }
2794