1use core::ffi::*;
4#[cfg(feature = "objc2")]
5use objc2::__framework_prelude::*;
6
7use crate::*;
8
9#[cfg(feature = "cssmconfig")]
11pub type CSSM_HANDLE = CSSM_INTPTR;
12
13#[cfg(feature = "cssmconfig")]
15pub type CSSM_HANDLE_PTR = *mut CSSM_INTPTR;
16
17#[cfg(feature = "cssmconfig")]
19pub type CSSM_LONG_HANDLE = uint64;
20
21#[cfg(feature = "cssmconfig")]
23pub type CSSM_LONG_HANDLE_PTR = *mut uint64;
24
25#[cfg(feature = "cssmconfig")]
27pub type CSSM_MODULE_HANDLE = CSSM_HANDLE;
28
29#[cfg(feature = "cssmconfig")]
31pub type CSSM_MODULE_HANDLE_PTR = *mut CSSM_HANDLE;
32
33#[cfg(feature = "cssmconfig")]
35pub type CSSM_CC_HANDLE = CSSM_LONG_HANDLE;
36
37#[cfg(feature = "cssmconfig")]
39pub type CSSM_CSP_HANDLE = CSSM_MODULE_HANDLE;
40
41#[cfg(feature = "cssmconfig")]
43pub type CSSM_TP_HANDLE = CSSM_MODULE_HANDLE;
44
45#[cfg(feature = "cssmconfig")]
47pub type CSSM_AC_HANDLE = CSSM_MODULE_HANDLE;
48
49#[cfg(feature = "cssmconfig")]
51pub type CSSM_CL_HANDLE = CSSM_MODULE_HANDLE;
52
53#[cfg(feature = "cssmconfig")]
55pub type CSSM_DL_HANDLE = CSSM_MODULE_HANDLE;
56
57#[cfg(feature = "cssmconfig")]
59pub type CSSM_DB_HANDLE = CSSM_MODULE_HANDLE;
60
61pub const CSSM_INVALID_HANDLE: c_uint = 0;
63
64#[cfg(feature = "cssmconfig")]
66pub type CSSM_BOOL = sint32;
67
68pub const CSSM_FALSE: c_uint = 0;
70pub const CSSM_TRUE: c_uint = 1;
72
73#[cfg(feature = "cssmconfig")]
75pub type CSSM_RETURN = sint32;
76
77pub const CSSM_OK: c_uint = 0;
79
80pub const CSSM_MODULE_STRING_SIZE: c_uint = 64;
82
83#[cfg(feature = "SecAsn1Types")]
85pub type CSSM_DATA_PTR = *mut SecAsn1Item;
86
87#[cfg(feature = "cssmconfig")]
89#[repr(C)]
90#[derive(Clone, Copy, Debug, PartialEq)]
91pub struct cssm_guid {
92 pub Data1: uint32,
93 pub Data2: uint16,
94 pub Data3: uint16,
95 pub Data4: [uint8; 8],
96}
97
98#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
99unsafe impl Encode for cssm_guid {
100 const ENCODING: Encoding = Encoding::Struct(
101 "cssm_guid",
102 &[
103 <uint32>::ENCODING,
104 <uint16>::ENCODING,
105 <uint16>::ENCODING,
106 <[uint8; 8]>::ENCODING,
107 ],
108 );
109}
110
111#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
112unsafe impl RefEncode for cssm_guid {
113 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
114}
115
116#[cfg(feature = "cssmconfig")]
118pub type CSSM_GUID = cssm_guid;
119
120#[cfg(feature = "cssmconfig")]
122pub type CSSM_GUID_PTR = *mut cssm_guid;
123
124#[cfg(feature = "cssmconfig")]
126pub type CSSM_BITMASK = uint32;
127
128#[cfg(feature = "cssmconfig")]
130pub type CSSM_KEY_HIERARCHY = CSSM_BITMASK;
131
132pub const CSSM_KEY_HIERARCHY_NONE: c_uint = 0;
134pub const CSSM_KEY_HIERARCHY_INTEG: c_uint = 1;
136pub const CSSM_KEY_HIERARCHY_EXPORT: c_uint = 2;
138
139#[cfg(feature = "cssmconfig")]
141pub type CSSM_PVC_MODE = CSSM_BITMASK;
142
143pub const CSSM_PVC_NONE: c_uint = 0;
145pub const CSSM_PVC_APP: c_uint = 1;
147pub const CSSM_PVC_SP: c_uint = 2;
149
150#[cfg(feature = "cssmconfig")]
152pub type CSSM_PRIVILEGE_SCOPE = uint32;
153
154pub const CSSM_PRIVILEGE_SCOPE_NONE: c_uint = 0;
156pub const CSSM_PRIVILEGE_SCOPE_PROCESS: c_uint = 1;
158pub const CSSM_PRIVILEGE_SCOPE_THREAD: c_uint = 2;
160
161#[cfg(feature = "cssmconfig")]
163#[repr(C)]
164#[derive(Clone, Copy, Debug, PartialEq)]
165pub struct cssm_version {
166 pub Major: uint32,
167 pub Minor: uint32,
168}
169
170#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
171unsafe impl Encode for cssm_version {
172 const ENCODING: Encoding =
173 Encoding::Struct("cssm_version", &[<uint32>::ENCODING, <uint32>::ENCODING]);
174}
175
176#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
177unsafe impl RefEncode for cssm_version {
178 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
179}
180
181#[cfg(feature = "cssmconfig")]
183pub type CSSM_VERSION = cssm_version;
184
185#[cfg(feature = "cssmconfig")]
187pub type CSSM_VERSION_PTR = *mut cssm_version;
188
189#[cfg(feature = "cssmconfig")]
191pub type CSSM_SERVICE_MASK = uint32;
192
193pub const CSSM_SERVICE_CSSM: c_uint = 1;
195pub const CSSM_SERVICE_CSP: c_uint = 2;
197pub const CSSM_SERVICE_DL: c_uint = 4;
199pub const CSSM_SERVICE_CL: c_uint = 8;
201pub const CSSM_SERVICE_TP: c_uint = 16;
203pub const CSSM_SERVICE_AC: c_uint = 32;
205pub const CSSM_SERVICE_KR: c_uint = 64;
207
208#[cfg(feature = "cssmconfig")]
210pub type CSSM_SERVICE_TYPE = CSSM_SERVICE_MASK;
211
212#[cfg(feature = "cssmconfig")]
214#[deprecated]
215#[repr(C)]
216#[derive(Clone, Copy, Debug, PartialEq)]
217pub struct cssm_subservice_uid {
218 pub Guid: CSSM_GUID,
219 pub Version: CSSM_VERSION,
220 pub SubserviceId: uint32,
221 pub SubserviceType: CSSM_SERVICE_TYPE,
222}
223
224#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
225unsafe impl Encode for cssm_subservice_uid {
226 const ENCODING: Encoding = Encoding::Struct(
227 "cssm_subservice_uid",
228 &[
229 <CSSM_GUID>::ENCODING,
230 <CSSM_VERSION>::ENCODING,
231 <uint32>::ENCODING,
232 <CSSM_SERVICE_TYPE>::ENCODING,
233 ],
234 );
235}
236
237#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
238unsafe impl RefEncode for cssm_subservice_uid {
239 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
240}
241
242#[cfg(feature = "cssmconfig")]
244pub type CSSM_SUBSERVICE_UID = cssm_subservice_uid;
245
246#[cfg(feature = "cssmconfig")]
248pub type CSSM_SUBSERVICE_UID_PTR = *mut cssm_subservice_uid;
249
250#[cfg(feature = "cssmconfig")]
252pub type CSSM_MODULE_EVENT = uint32;
253
254#[cfg(feature = "cssmconfig")]
256pub type CSSM_MODULE_EVENT_PTR = *mut uint32;
257
258pub const CSSM_NOTIFY_INSERT: c_uint = 1;
260pub const CSSM_NOTIFY_REMOVE: c_uint = 2;
262pub const CSSM_NOTIFY_FAULT: c_uint = 3;
264
265#[cfg(feature = "cssmconfig")]
267pub type CSSM_API_ModuleEventHandler = Option<
268 unsafe extern "C-unwind" fn(
269 *const CSSM_GUID,
270 *mut c_void,
271 uint32,
272 CSSM_SERVICE_TYPE,
273 CSSM_MODULE_EVENT,
274 ) -> CSSM_RETURN,
275>;
276
277#[cfg(feature = "cssmconfig")]
279pub type CSSM_ATTACH_FLAGS = uint32;
280
281pub const CSSM_ATTACH_READ_ONLY: c_uint = 1;
283
284#[cfg(feature = "cssmconfig")]
286pub type CSSM_PRIVILEGE = uint64;
287
288#[cfg(feature = "cssmconfig")]
290pub type CSSM_USEE_TAG = CSSM_PRIVILEGE;
291
292pub const CSSM_USEE_LAST: c_uint = 255;
294pub const CSSM_USEE_NONE: c_uint = 0;
296pub const CSSM_USEE_DOMESTIC: c_uint = 1;
298pub const CSSM_USEE_FINANCIAL: c_uint = 2;
300pub const CSSM_USEE_KRLE: c_uint = 3;
302pub const CSSM_USEE_KRENT: c_uint = 4;
304pub const CSSM_USEE_SSL: c_uint = 5;
306pub const CSSM_USEE_AUTHENTICATION: c_uint = 6;
308pub const CSSM_USEE_KEYEXCH: c_uint = 7;
310pub const CSSM_USEE_MEDICAL: c_uint = 8;
312pub const CSSM_USEE_INSURANCE: c_uint = 9;
314pub const CSSM_USEE_WEAK: c_uint = 10;
316
317#[cfg(feature = "cssmconfig")]
319pub type CSSM_NET_ADDRESS_TYPE = uint32;
320
321pub const CSSM_ADDR_NONE: c_uint = 0;
323pub const CSSM_ADDR_CUSTOM: c_uint = 1;
325pub const CSSM_ADDR_URL: c_uint = 2;
327pub const CSSM_ADDR_SOCKADDR: c_uint = 3;
329pub const CSSM_ADDR_NAME: c_uint = 4;
331
332#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
334#[deprecated]
335#[repr(C)]
336#[derive(Clone, Copy, Debug, PartialEq)]
337pub struct cssm_net_address {
338 pub AddressType: CSSM_NET_ADDRESS_TYPE,
339 pub Address: SecAsn1Item,
340}
341
342#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
343unsafe impl Encode for cssm_net_address {
344 const ENCODING: Encoding = Encoding::Struct(
345 "cssm_net_address",
346 &[<CSSM_NET_ADDRESS_TYPE>::ENCODING, <SecAsn1Item>::ENCODING],
347 );
348}
349
350#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
351unsafe impl RefEncode for cssm_net_address {
352 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
353}
354
355#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
357pub type CSSM_NET_ADDRESS = cssm_net_address;
358
359#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
361pub type CSSM_NET_ADDRESS_PTR = *mut cssm_net_address;
362
363#[cfg(feature = "cssmconfig")]
365pub type CSSM_NET_PROTOCOL = uint32;
366
367pub const CSSM_NET_PROTO_NONE: c_uint = 0;
369pub const CSSM_NET_PROTO_CUSTOM: c_uint = 1;
371pub const CSSM_NET_PROTO_UNSPECIFIED: c_uint = 2;
373pub const CSSM_NET_PROTO_LDAP: c_uint = 3;
375pub const CSSM_NET_PROTO_LDAPS: c_uint = 4;
377pub const CSSM_NET_PROTO_LDAPNS: c_uint = 5;
379pub const CSSM_NET_PROTO_X500DAP: c_uint = 6;
381pub const CSSM_NET_PROTO_FTP: c_uint = 7;
383pub const CSSM_NET_PROTO_FTPS: c_uint = 8;
385pub const CSSM_NET_PROTO_OCSP: c_uint = 9;
387pub const CSSM_NET_PROTO_CMP: c_uint = 10;
389pub const CSSM_NET_PROTO_CMPS: c_uint = 11;
391
392#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
394pub type CSSM_CALLBACK =
395 Option<unsafe extern "C-unwind" fn(CSSM_DATA_PTR, *mut c_void) -> CSSM_RETURN>;
396
397#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
399#[deprecated]
400#[repr(C)]
401#[derive(Clone, Copy, Debug, PartialEq)]
402pub struct cssm_crypto_data {
403 pub Param: SecAsn1Item,
404 pub Callback: CSSM_CALLBACK,
405 pub CallerCtx: *mut c_void,
406}
407
408#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
409unsafe impl Encode for cssm_crypto_data {
410 const ENCODING: Encoding = Encoding::Struct(
411 "cssm_crypto_data",
412 &[
413 <SecAsn1Item>::ENCODING,
414 <CSSM_CALLBACK>::ENCODING,
415 <*mut c_void>::ENCODING,
416 ],
417 );
418}
419
420#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
421unsafe impl RefEncode for cssm_crypto_data {
422 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
423}
424
425#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
427pub type CSSM_CRYPTO_DATA = cssm_crypto_data;
428
429#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
431pub type CSSM_CRYPTO_DATA_PTR = *mut cssm_crypto_data;
432
433#[cfg(feature = "cssmconfig")]
435pub type CSSM_WORDID_TYPE = sint32;
436
437pub const CSSM_WORDID__UNK_: c_int = -1;
439pub const CSSM_WORDID__NLU_: c_int = 0;
441pub const CSSM_WORDID__STAR_: c_int = 1;
443pub const CSSM_WORDID_A: c_int = 2;
445pub const CSSM_WORDID_ACL: c_int = 3;
447pub const CSSM_WORDID_ALPHA: c_int = 4;
449pub const CSSM_WORDID_B: c_int = 5;
451pub const CSSM_WORDID_BER: c_int = 6;
453pub const CSSM_WORDID_BINARY: c_int = 7;
455pub const CSSM_WORDID_BIOMETRIC: c_int = 8;
457pub const CSSM_WORDID_C: c_int = 9;
459pub const CSSM_WORDID_CANCELED: c_int = 10;
461pub const CSSM_WORDID_CERT: c_int = 11;
463pub const CSSM_WORDID_COMMENT: c_int = 12;
465pub const CSSM_WORDID_CRL: c_int = 13;
467pub const CSSM_WORDID_CUSTOM: c_int = 14;
469pub const CSSM_WORDID_D: c_int = 15;
471pub const CSSM_WORDID_DATE: c_int = 16;
473pub const CSSM_WORDID_DB_DELETE: c_int = 17;
475pub const CSSM_WORDID_DB_EXEC_STORED_QUERY: c_int = 18;
477pub const CSSM_WORDID_DB_INSERT: c_int = 19;
479pub const CSSM_WORDID_DB_MODIFY: c_int = 20;
481pub const CSSM_WORDID_DB_READ: c_int = 21;
483pub const CSSM_WORDID_DBS_CREATE: c_int = 22;
485pub const CSSM_WORDID_DBS_DELETE: c_int = 23;
487pub const CSSM_WORDID_DECRYPT: c_int = 24;
489pub const CSSM_WORDID_DELETE: c_int = 25;
491pub const CSSM_WORDID_DELTA_CRL: c_int = 26;
493pub const CSSM_WORDID_DER: c_int = 27;
495pub const CSSM_WORDID_DERIVE: c_int = 28;
497pub const CSSM_WORDID_DISPLAY: c_int = 29;
499pub const CSSM_WORDID_DO: c_int = 30;
501pub const CSSM_WORDID_DSA: c_int = 31;
503pub const CSSM_WORDID_DSA_SHA1: c_int = 32;
505pub const CSSM_WORDID_E: c_int = 33;
507pub const CSSM_WORDID_ELGAMAL: c_int = 34;
509pub const CSSM_WORDID_ENCRYPT: c_int = 35;
511pub const CSSM_WORDID_ENTRY: c_int = 36;
513pub const CSSM_WORDID_EXPORT_CLEAR: c_int = 37;
515pub const CSSM_WORDID_EXPORT_WRAPPED: c_int = 38;
517pub const CSSM_WORDID_G: c_int = 39;
519pub const CSSM_WORDID_GE: c_int = 40;
521pub const CSSM_WORDID_GENKEY: c_int = 41;
523pub const CSSM_WORDID_HASH: c_int = 42;
525pub const CSSM_WORDID_HASHED_PASSWORD: c_int = 43;
527pub const CSSM_WORDID_HASHED_SUBJECT: c_int = 44;
529pub const CSSM_WORDID_HAVAL: c_int = 45;
531pub const CSSM_WORDID_IBCHASH: c_int = 46;
533pub const CSSM_WORDID_IMPORT_CLEAR: c_int = 47;
535pub const CSSM_WORDID_IMPORT_WRAPPED: c_int = 48;
537pub const CSSM_WORDID_INTEL: c_int = 49;
539pub const CSSM_WORDID_ISSUER: c_int = 50;
541pub const CSSM_WORDID_ISSUER_INFO: c_int = 51;
543pub const CSSM_WORDID_K_OF_N: c_int = 52;
545pub const CSSM_WORDID_KEA: c_int = 53;
547pub const CSSM_WORDID_KEYHOLDER: c_int = 54;
549pub const CSSM_WORDID_L: c_int = 55;
551pub const CSSM_WORDID_LE: c_int = 56;
553pub const CSSM_WORDID_LOGIN: c_int = 57;
555pub const CSSM_WORDID_LOGIN_NAME: c_int = 58;
557pub const CSSM_WORDID_MAC: c_int = 59;
559pub const CSSM_WORDID_MD2: c_int = 60;
561pub const CSSM_WORDID_MD2WITHRSA: c_int = 61;
563pub const CSSM_WORDID_MD4: c_int = 62;
565pub const CSSM_WORDID_MD5: c_int = 63;
567pub const CSSM_WORDID_MD5WITHRSA: c_int = 64;
569pub const CSSM_WORDID_N: c_int = 65;
571pub const CSSM_WORDID_NAME: c_int = 66;
573pub const CSSM_WORDID_NDR: c_int = 67;
575pub const CSSM_WORDID_NHASH: c_int = 68;
577pub const CSSM_WORDID_NOT_AFTER: c_int = 69;
579pub const CSSM_WORDID_NOT_BEFORE: c_int = 70;
581pub const CSSM_WORDID_NULL: c_int = 71;
583pub const CSSM_WORDID_NUMERIC: c_int = 72;
585pub const CSSM_WORDID_OBJECT_HASH: c_int = 73;
587pub const CSSM_WORDID_ONE_TIME: c_int = 74;
589pub const CSSM_WORDID_ONLINE: c_int = 75;
591pub const CSSM_WORDID_OWNER: c_int = 76;
593pub const CSSM_WORDID_P: c_int = 77;
595pub const CSSM_WORDID_PAM_NAME: c_int = 78;
597pub const CSSM_WORDID_PASSWORD: c_int = 79;
599pub const CSSM_WORDID_PGP: c_int = 80;
601pub const CSSM_WORDID_PREFIX: c_int = 81;
603pub const CSSM_WORDID_PRIVATE_KEY: c_int = 82;
605pub const CSSM_WORDID_PROMPTED_BIOMETRIC: c_int = 83;
607pub const CSSM_WORDID_PROMPTED_PASSWORD: c_int = 84;
609pub const CSSM_WORDID_PROPAGATE: c_int = 85;
611pub const CSSM_WORDID_PROTECTED_BIOMETRIC: c_int = 86;
613pub const CSSM_WORDID_PROTECTED_PASSWORD: c_int = 87;
615pub const CSSM_WORDID_PROTECTED_PIN: c_int = 88;
617pub const CSSM_WORDID_PUBLIC_KEY: c_int = 89;
619pub const CSSM_WORDID_PUBLIC_KEY_FROM_CERT: c_int = 90;
621pub const CSSM_WORDID_Q: c_int = 91;
623pub const CSSM_WORDID_RANGE: c_int = 92;
625pub const CSSM_WORDID_REVAL: c_int = 93;
627pub const CSSM_WORDID_RIPEMAC: c_int = 94;
629pub const CSSM_WORDID_RIPEMD: c_int = 95;
631pub const CSSM_WORDID_RIPEMD160: c_int = 96;
633pub const CSSM_WORDID_RSA: c_int = 97;
635pub const CSSM_WORDID_RSA_ISO9796: c_int = 98;
637pub const CSSM_WORDID_RSA_PKCS: c_int = 99;
639pub const CSSM_WORDID_RSA_PKCS_MD5: c_int = 100;
641pub const CSSM_WORDID_RSA_PKCS_SHA1: c_int = 101;
643pub const CSSM_WORDID_RSA_PKCS1: c_int = 102;
645pub const CSSM_WORDID_RSA_PKCS1_MD5: c_int = 103;
647pub const CSSM_WORDID_RSA_PKCS1_SHA1: c_int = 104;
649pub const CSSM_WORDID_RSA_PKCS1_SIG: c_int = 105;
651pub const CSSM_WORDID_RSA_RAW: c_int = 106;
653pub const CSSM_WORDID_SDSIV1: c_int = 107;
655pub const CSSM_WORDID_SEQUENCE: c_int = 108;
657pub const CSSM_WORDID_SET: c_int = 109;
659pub const CSSM_WORDID_SEXPR: c_int = 110;
661pub const CSSM_WORDID_SHA1: c_int = 111;
663pub const CSSM_WORDID_SHA1WITHDSA: c_int = 112;
665pub const CSSM_WORDID_SHA1WITHECDSA: c_int = 113;
667pub const CSSM_WORDID_SHA1WITHRSA: c_int = 114;
669pub const CSSM_WORDID_SIGN: c_int = 115;
671pub const CSSM_WORDID_SIGNATURE: c_int = 116;
673pub const CSSM_WORDID_SIGNED_NONCE: c_int = 117;
675pub const CSSM_WORDID_SIGNED_SECRET: c_int = 118;
677pub const CSSM_WORDID_SPKI: c_int = 119;
679pub const CSSM_WORDID_SUBJECT: c_int = 120;
681pub const CSSM_WORDID_SUBJECT_INFO: c_int = 121;
683pub const CSSM_WORDID_TAG: c_int = 122;
685pub const CSSM_WORDID_THRESHOLD: c_int = 123;
687pub const CSSM_WORDID_TIME: c_int = 124;
689pub const CSSM_WORDID_URI: c_int = 125;
691pub const CSSM_WORDID_VERSION: c_int = 126;
693pub const CSSM_WORDID_X509_ATTRIBUTE: c_int = 127;
695pub const CSSM_WORDID_X509V1: c_int = 128;
697pub const CSSM_WORDID_X509V2: c_int = 129;
699pub const CSSM_WORDID_X509V3: c_int = 130;
701pub const CSSM_WORDID_X9_ATTRIBUTE: c_int = 131;
703pub const CSSM_WORDID_VENDOR_START: c_int = 65536;
705pub const CSSM_WORDID_VENDOR_END: c_int = 2147418112;
707
708#[cfg(feature = "cssmconfig")]
710pub type CSSM_LIST_ELEMENT_TYPE = uint32;
711
712#[cfg(feature = "cssmconfig")]
714pub type CSSM_LIST_ELEMENT_TYPE_PTR = *mut uint32;
715
716pub const CSSM_LIST_ELEMENT_DATUM: c_uint = 0;
718pub const CSSM_LIST_ELEMENT_SUBLIST: c_uint = 1;
720pub const CSSM_LIST_ELEMENT_WORDID: c_uint = 2;
722
723#[cfg(feature = "cssmconfig")]
725pub type CSSM_LIST_TYPE = uint32;
726
727#[cfg(feature = "cssmconfig")]
729pub type CSSM_LIST_TYPE_PTR = *mut uint32;
730
731pub const CSSM_LIST_TYPE_UNKNOWN: c_uint = 0;
733pub const CSSM_LIST_TYPE_CUSTOM: c_uint = 1;
735pub const CSSM_LIST_TYPE_SEXPR: c_uint = 2;
737
738pub type CSSM_LIST_ELEMENT_PTR = *mut cssm_list_element;
740
741#[cfg(feature = "cssmconfig")]
743#[repr(C)]
744#[derive(Clone, Copy, Debug, PartialEq)]
745pub struct cssm_list {
746 pub ListType: CSSM_LIST_TYPE,
747 pub Head: CSSM_LIST_ELEMENT_PTR,
748 pub Tail: CSSM_LIST_ELEMENT_PTR,
749}
750
751#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
752unsafe impl Encode for cssm_list {
753 const ENCODING: Encoding = Encoding::Struct(
754 "cssm_list",
755 &[
756 <CSSM_LIST_TYPE>::ENCODING,
757 <CSSM_LIST_ELEMENT_PTR>::ENCODING,
758 <CSSM_LIST_ELEMENT_PTR>::ENCODING,
759 ],
760 );
761}
762
763#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
764unsafe impl RefEncode for cssm_list {
765 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
766}
767
768#[cfg(feature = "cssmconfig")]
770pub type CSSM_LIST = cssm_list;
771
772#[cfg(feature = "cssmconfig")]
774pub type CSSM_LIST_PTR = *mut cssm_list;
775
776pub type CSSM_LIST_ELEMENT = cssm_list_element;
778
779#[cfg(feature = "cssmconfig")]
781#[deprecated]
782#[repr(C)]
783#[derive(Clone, Copy, Debug, PartialEq)]
784pub struct CSSM_TUPLE {
785 pub Issuer: CSSM_LIST,
786 pub Subject: CSSM_LIST,
787 pub Delegate: CSSM_BOOL,
788 pub AuthorizationTag: CSSM_LIST,
789 pub ValidityPeriod: CSSM_LIST,
790}
791
792#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
793unsafe impl Encode for CSSM_TUPLE {
794 const ENCODING: Encoding = Encoding::Struct(
795 "?",
796 &[
797 <CSSM_LIST>::ENCODING,
798 <CSSM_LIST>::ENCODING,
799 <CSSM_BOOL>::ENCODING,
800 <CSSM_LIST>::ENCODING,
801 <CSSM_LIST>::ENCODING,
802 ],
803 );
804}
805
806#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
807unsafe impl RefEncode for CSSM_TUPLE {
808 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
809}
810
811#[cfg(feature = "cssmconfig")]
813pub type CSSM_TUPLE_PTR = *mut CSSM_TUPLE;
814
815#[cfg(feature = "cssmconfig")]
817#[deprecated]
818#[repr(C)]
819#[derive(Clone, Copy, Debug, PartialEq)]
820pub struct cssm_tuplegroup {
821 pub NumberOfTuples: uint32,
822 pub Tuples: CSSM_TUPLE_PTR,
823}
824
825#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
826unsafe impl Encode for cssm_tuplegroup {
827 const ENCODING: Encoding = Encoding::Struct(
828 "cssm_tuplegroup",
829 &[<uint32>::ENCODING, <CSSM_TUPLE_PTR>::ENCODING],
830 );
831}
832
833#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
834unsafe impl RefEncode for cssm_tuplegroup {
835 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
836}
837
838#[cfg(feature = "cssmconfig")]
840pub type CSSM_TUPLEGROUP = cssm_tuplegroup;
841
842#[cfg(feature = "cssmconfig")]
844pub type CSSM_TUPLEGROUP_PTR = *mut cssm_tuplegroup;
845
846#[cfg(feature = "cssmconfig")]
848pub type CSSM_SAMPLE_TYPE = CSSM_WORDID_TYPE;
849
850pub const CSSM_SAMPLE_TYPE_PASSWORD: c_uint = 79;
852pub const CSSM_SAMPLE_TYPE_HASHED_PASSWORD: c_uint = 43;
854pub const CSSM_SAMPLE_TYPE_PROTECTED_PASSWORD: c_uint = 87;
856pub const CSSM_SAMPLE_TYPE_PROMPTED_PASSWORD: c_uint = 84;
858pub const CSSM_SAMPLE_TYPE_SIGNED_NONCE: c_uint = 117;
860pub const CSSM_SAMPLE_TYPE_SIGNED_SECRET: c_uint = 118;
862pub const CSSM_SAMPLE_TYPE_BIOMETRIC: c_uint = 8;
864pub const CSSM_SAMPLE_TYPE_PROTECTED_BIOMETRIC: c_uint = 86;
866pub const CSSM_SAMPLE_TYPE_PROMPTED_BIOMETRIC: c_uint = 83;
868pub const CSSM_SAMPLE_TYPE_THRESHOLD: c_uint = 123;
870
871#[cfg(feature = "cssmconfig")]
873#[deprecated]
874#[repr(C)]
875#[derive(Clone, Copy, Debug, PartialEq)]
876pub struct cssm_sample {
877 pub TypedSample: CSSM_LIST,
878 pub Verifier: *const CSSM_SUBSERVICE_UID,
879}
880
881#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
882unsafe impl Encode for cssm_sample {
883 const ENCODING: Encoding = Encoding::Struct(
884 "cssm_sample",
885 &[
886 <CSSM_LIST>::ENCODING,
887 <*const CSSM_SUBSERVICE_UID>::ENCODING,
888 ],
889 );
890}
891
892#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
893unsafe impl RefEncode for cssm_sample {
894 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
895}
896
897#[cfg(feature = "cssmconfig")]
899pub type CSSM_SAMPLE = cssm_sample;
900
901#[cfg(feature = "cssmconfig")]
903pub type CSSM_SAMPLE_PTR = *mut cssm_sample;
904
905#[cfg(feature = "cssmconfig")]
907#[deprecated]
908#[repr(C)]
909#[derive(Clone, Copy, Debug, PartialEq)]
910pub struct cssm_samplegroup {
911 pub NumberOfSamples: uint32,
912 pub Samples: *const CSSM_SAMPLE,
913}
914
915#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
916unsafe impl Encode for cssm_samplegroup {
917 const ENCODING: Encoding = Encoding::Struct(
918 "cssm_samplegroup",
919 &[<uint32>::ENCODING, <*const CSSM_SAMPLE>::ENCODING],
920 );
921}
922
923#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
924unsafe impl RefEncode for cssm_samplegroup {
925 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
926}
927
928#[cfg(feature = "cssmconfig")]
930pub type CSSM_SAMPLEGROUP = cssm_samplegroup;
931
932#[cfg(feature = "cssmconfig")]
934pub type CSSM_SAMPLEGROUP_PTR = *mut cssm_samplegroup;
935
936#[cfg(feature = "cssmconfig")]
938pub type CSSM_MALLOC = Option<unsafe extern "C-unwind" fn(CSSM_SIZE, *mut c_void) -> *mut c_void>;
939
940pub type CSSM_FREE = Option<unsafe extern "C-unwind" fn(*mut c_void, *mut c_void)>;
942
943#[cfg(feature = "cssmconfig")]
945pub type CSSM_REALLOC =
946 Option<unsafe extern "C-unwind" fn(*mut c_void, CSSM_SIZE, *mut c_void) -> *mut c_void>;
947
948#[cfg(feature = "cssmconfig")]
950pub type CSSM_CALLOC =
951 Option<unsafe extern "C-unwind" fn(uint32, CSSM_SIZE, *mut c_void) -> *mut c_void>;
952
953#[cfg(feature = "cssmconfig")]
955#[repr(C)]
956#[derive(Clone, Copy, Debug, PartialEq)]
957pub struct cssm_memory_funcs {
958 pub malloc_func: CSSM_MALLOC,
959 pub free_func: CSSM_FREE,
960 pub realloc_func: CSSM_REALLOC,
961 pub calloc_func: CSSM_CALLOC,
962 pub AllocRef: *mut c_void,
963}
964
965#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
966unsafe impl Encode for cssm_memory_funcs {
967 const ENCODING: Encoding = Encoding::Struct(
968 "cssm_memory_funcs",
969 &[
970 <CSSM_MALLOC>::ENCODING,
971 <CSSM_FREE>::ENCODING,
972 <CSSM_REALLOC>::ENCODING,
973 <CSSM_CALLOC>::ENCODING,
974 <*mut c_void>::ENCODING,
975 ],
976 );
977}
978
979#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
980unsafe impl RefEncode for cssm_memory_funcs {
981 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
982}
983
984#[cfg(feature = "cssmconfig")]
986pub type CSSM_MEMORY_FUNCS = cssm_memory_funcs;
987
988#[cfg(feature = "cssmconfig")]
990pub type CSSM_MEMORY_FUNCS_PTR = *mut cssm_memory_funcs;
991
992#[cfg(feature = "cssmconfig")]
994pub type CSSM_API_MEMORY_FUNCS = CSSM_MEMORY_FUNCS;
995
996#[cfg(feature = "cssmconfig")]
998pub type CSSM_API_MEMORY_FUNCS_PTR = *mut CSSM_API_MEMORY_FUNCS;
999
1000#[cfg(feature = "cssmconfig")]
1002pub type CSSM_CHALLENGE_CALLBACK = Option<
1003 unsafe extern "C-unwind" fn(
1004 *const CSSM_LIST,
1005 CSSM_SAMPLEGROUP_PTR,
1006 *mut c_void,
1007 *const CSSM_MEMORY_FUNCS,
1008 ) -> CSSM_RETURN,
1009>;
1010
1011#[cfg(feature = "cssmconfig")]
1013pub type CSSM_CERT_TYPE = uint32;
1014
1015#[cfg(feature = "cssmconfig")]
1017pub type CSSM_CERT_TYPE_PTR = *mut uint32;
1018
1019pub const CSSM_CERT_UNKNOWN: c_uint = 0;
1021pub const CSSM_CERT_X_509v1: c_uint = 1;
1023pub const CSSM_CERT_X_509v2: c_uint = 2;
1025pub const CSSM_CERT_X_509v3: c_uint = 3;
1027pub const CSSM_CERT_PGP: c_uint = 4;
1029pub const CSSM_CERT_SPKI: c_uint = 5;
1031pub const CSSM_CERT_SDSIv1: c_uint = 6;
1033pub const CSSM_CERT_Intel: c_uint = 8;
1035pub const CSSM_CERT_X_509_ATTRIBUTE: c_uint = 9;
1037pub const CSSM_CERT_X9_ATTRIBUTE: c_uint = 10;
1039pub const CSSM_CERT_TUPLE: c_uint = 11;
1041pub const CSSM_CERT_ACL_ENTRY: c_uint = 12;
1043pub const CSSM_CERT_MULTIPLE: c_uint = 32766;
1045pub const CSSM_CERT_LAST: c_uint = 32767;
1047pub const CSSM_CL_CUSTOM_CERT_TYPE: c_uint = 32768;
1049
1050#[cfg(feature = "cssmconfig")]
1052pub type CSSM_CERT_ENCODING = uint32;
1053
1054#[cfg(feature = "cssmconfig")]
1056pub type CSSM_CERT_ENCODING_PTR = *mut uint32;
1057
1058pub const CSSM_CERT_ENCODING_UNKNOWN: c_uint = 0;
1060pub const CSSM_CERT_ENCODING_CUSTOM: c_uint = 1;
1062pub const CSSM_CERT_ENCODING_BER: c_uint = 2;
1064pub const CSSM_CERT_ENCODING_DER: c_uint = 3;
1066pub const CSSM_CERT_ENCODING_NDR: c_uint = 4;
1068pub const CSSM_CERT_ENCODING_SEXPR: c_uint = 5;
1070pub const CSSM_CERT_ENCODING_PGP: c_uint = 6;
1072pub const CSSM_CERT_ENCODING_MULTIPLE: c_uint = 32766;
1074pub const CSSM_CERT_ENCODING_LAST: c_uint = 32767;
1076pub const CSSM_CL_CUSTOM_CERT_ENCODING: c_uint = 32768;
1078
1079#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1081#[deprecated]
1082#[repr(C)]
1083#[derive(Clone, Copy, Debug, PartialEq)]
1084pub struct cssm_encoded_cert {
1085 pub CertType: CSSM_CERT_TYPE,
1086 pub CertEncoding: CSSM_CERT_ENCODING,
1087 pub CertBlob: SecAsn1Item,
1088}
1089
1090#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1091unsafe impl Encode for cssm_encoded_cert {
1092 const ENCODING: Encoding = Encoding::Struct(
1093 "cssm_encoded_cert",
1094 &[
1095 <CSSM_CERT_TYPE>::ENCODING,
1096 <CSSM_CERT_ENCODING>::ENCODING,
1097 <SecAsn1Item>::ENCODING,
1098 ],
1099 );
1100}
1101
1102#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1103unsafe impl RefEncode for cssm_encoded_cert {
1104 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1105}
1106
1107#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1109pub type CSSM_ENCODED_CERT = cssm_encoded_cert;
1110
1111#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1113pub type CSSM_ENCODED_CERT_PTR = *mut cssm_encoded_cert;
1114
1115#[cfg(feature = "cssmconfig")]
1117pub type CSSM_CERT_PARSE_FORMAT = uint32;
1118
1119#[cfg(feature = "cssmconfig")]
1121pub type CSSM_CERT_PARSE_FORMAT_PTR = *mut uint32;
1122
1123pub const CSSM_CERT_PARSE_FORMAT_NONE: c_uint = 0;
1125pub const CSSM_CERT_PARSE_FORMAT_CUSTOM: c_uint = 1;
1127pub const CSSM_CERT_PARSE_FORMAT_SEXPR: c_uint = 2;
1129pub const CSSM_CERT_PARSE_FORMAT_COMPLEX: c_uint = 3;
1131pub const CSSM_CERT_PARSE_FORMAT_OID_NAMED: c_uint = 4;
1133pub const CSSM_CERT_PARSE_FORMAT_TUPLE: c_uint = 5;
1135pub const CSSM_CERT_PARSE_FORMAT_MULTIPLE: c_uint = 32766;
1137pub const CSSM_CERT_PARSE_FORMAT_LAST: c_uint = 32767;
1139pub const CSSM_CL_CUSTOM_CERT_PARSE_FORMAT: c_uint = 32768;
1141
1142#[cfg(feature = "cssmconfig")]
1144#[repr(C)]
1145#[derive(Clone, Copy, Debug, PartialEq)]
1146pub struct cssm_parsed_cert {
1147 pub CertType: CSSM_CERT_TYPE,
1148 pub ParsedCertFormat: CSSM_CERT_PARSE_FORMAT,
1149 pub ParsedCert: *mut c_void,
1150}
1151
1152#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1153unsafe impl Encode for cssm_parsed_cert {
1154 const ENCODING: Encoding = Encoding::Struct(
1155 "cssm_parsed_cert",
1156 &[
1157 <CSSM_CERT_TYPE>::ENCODING,
1158 <CSSM_CERT_PARSE_FORMAT>::ENCODING,
1159 <*mut c_void>::ENCODING,
1160 ],
1161 );
1162}
1163
1164#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1165unsafe impl RefEncode for cssm_parsed_cert {
1166 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1167}
1168
1169#[cfg(feature = "cssmconfig")]
1171pub type CSSM_PARSED_CERT = cssm_parsed_cert;
1172
1173#[cfg(feature = "cssmconfig")]
1175pub type CSSM_PARSED_CERT_PTR = *mut cssm_parsed_cert;
1176
1177#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1179#[deprecated]
1180#[repr(C)]
1181#[derive(Clone, Copy, Debug, PartialEq)]
1182pub struct cssm_cert_pair {
1183 pub EncodedCert: CSSM_ENCODED_CERT,
1184 pub ParsedCert: CSSM_PARSED_CERT,
1185}
1186
1187#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1188unsafe impl Encode for cssm_cert_pair {
1189 const ENCODING: Encoding = Encoding::Struct(
1190 "cssm_cert_pair",
1191 &[<CSSM_ENCODED_CERT>::ENCODING, <CSSM_PARSED_CERT>::ENCODING],
1192 );
1193}
1194
1195#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1196unsafe impl RefEncode for cssm_cert_pair {
1197 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1198}
1199
1200#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1202pub type CSSM_CERT_PAIR = cssm_cert_pair;
1203
1204#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1206pub type CSSM_CERT_PAIR_PTR = *mut cssm_cert_pair;
1207
1208#[cfg(feature = "cssmconfig")]
1210pub type CSSM_CERTGROUP_TYPE = uint32;
1211
1212#[cfg(feature = "cssmconfig")]
1214pub type CSSM_CERTGROUP_TYPE_PTR = *mut uint32;
1215
1216pub const CSSM_CERTGROUP_DATA: c_uint = 0;
1218pub const CSSM_CERTGROUP_ENCODED_CERT: c_uint = 1;
1220pub const CSSM_CERTGROUP_PARSED_CERT: c_uint = 2;
1222pub const CSSM_CERTGROUP_CERT_PAIR: c_uint = 3;
1224
1225#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1227#[repr(C)]
1228#[derive(Clone, Copy)]
1229pub union cssm_certgroup_GroupList {
1230 pub CertList: CSSM_DATA_PTR,
1231 pub EncodedCertList: CSSM_ENCODED_CERT_PTR,
1232 pub ParsedCertList: CSSM_PARSED_CERT_PTR,
1233 pub PairCertList: CSSM_CERT_PAIR_PTR,
1234}
1235
1236#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1237unsafe impl Encode for cssm_certgroup_GroupList {
1238 const ENCODING: Encoding = Encoding::Union(
1239 "?",
1240 &[
1241 <CSSM_DATA_PTR>::ENCODING,
1242 <CSSM_ENCODED_CERT_PTR>::ENCODING,
1243 <CSSM_PARSED_CERT_PTR>::ENCODING,
1244 <CSSM_CERT_PAIR_PTR>::ENCODING,
1245 ],
1246 );
1247}
1248
1249#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1250unsafe impl RefEncode for cssm_certgroup_GroupList {
1251 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1252}
1253
1254#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1256#[deprecated]
1257#[repr(C)]
1258#[derive(Clone, Copy)]
1259pub struct cssm_certgroup {
1260 pub CertType: CSSM_CERT_TYPE,
1261 pub CertEncoding: CSSM_CERT_ENCODING,
1262 pub NumCerts: uint32,
1263 pub GroupList: cssm_certgroup_GroupList,
1264 pub CertGroupType: CSSM_CERTGROUP_TYPE,
1265 pub Reserved: *mut c_void,
1266}
1267
1268#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1269unsafe impl Encode for cssm_certgroup {
1270 const ENCODING: Encoding = Encoding::Struct(
1271 "cssm_certgroup",
1272 &[
1273 <CSSM_CERT_TYPE>::ENCODING,
1274 <CSSM_CERT_ENCODING>::ENCODING,
1275 <uint32>::ENCODING,
1276 <cssm_certgroup_GroupList>::ENCODING,
1277 <CSSM_CERTGROUP_TYPE>::ENCODING,
1278 <*mut c_void>::ENCODING,
1279 ],
1280 );
1281}
1282
1283#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1284unsafe impl RefEncode for cssm_certgroup {
1285 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1286}
1287
1288#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1290pub type CSSM_CERTGROUP = cssm_certgroup;
1291
1292#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1294pub type CSSM_CERTGROUP_PTR = *mut cssm_certgroup;
1295
1296#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1298#[deprecated]
1299#[repr(C)]
1300#[derive(Clone, Copy)]
1301pub struct cssm_base_certs {
1302 pub TPHandle: CSSM_TP_HANDLE,
1303 pub CLHandle: CSSM_CL_HANDLE,
1304 pub Certs: CSSM_CERTGROUP,
1305}
1306
1307#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1308unsafe impl Encode for cssm_base_certs {
1309 const ENCODING: Encoding = Encoding::Struct(
1310 "cssm_base_certs",
1311 &[
1312 <CSSM_TP_HANDLE>::ENCODING,
1313 <CSSM_CL_HANDLE>::ENCODING,
1314 <CSSM_CERTGROUP>::ENCODING,
1315 ],
1316 );
1317}
1318
1319#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1320unsafe impl RefEncode for cssm_base_certs {
1321 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1322}
1323
1324#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1326pub type CSSM_BASE_CERTS = cssm_base_certs;
1327
1328#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1330pub type CSSM_BASE_CERTS_PTR = *mut cssm_base_certs;
1331
1332#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1334#[deprecated]
1335#[repr(C)]
1336#[derive(Clone, Copy)]
1337pub struct cssm_access_credentials {
1338 pub EntryTag: CSSM_STRING,
1339 pub BaseCerts: CSSM_BASE_CERTS,
1340 pub Samples: CSSM_SAMPLEGROUP,
1341 pub Callback: CSSM_CHALLENGE_CALLBACK,
1342 pub CallerCtx: *mut c_void,
1343}
1344
1345#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1346unsafe impl Encode for cssm_access_credentials {
1347 const ENCODING: Encoding = Encoding::Struct(
1348 "cssm_access_credentials",
1349 &[
1350 <CSSM_STRING>::ENCODING,
1351 <CSSM_BASE_CERTS>::ENCODING,
1352 <CSSM_SAMPLEGROUP>::ENCODING,
1353 <CSSM_CHALLENGE_CALLBACK>::ENCODING,
1354 <*mut c_void>::ENCODING,
1355 ],
1356 );
1357}
1358
1359#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1360unsafe impl RefEncode for cssm_access_credentials {
1361 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1362}
1363
1364#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1366pub type CSSM_ACCESS_CREDENTIALS = cssm_access_credentials;
1367
1368#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1370pub type CSSM_ACCESS_CREDENTIALS_PTR = *mut cssm_access_credentials;
1371
1372#[cfg(feature = "cssmconfig")]
1374pub type CSSM_ACL_SUBJECT_TYPE = sint32;
1375
1376pub const CSSM_ACL_SUBJECT_TYPE_ANY: c_uint = 1;
1378pub const CSSM_ACL_SUBJECT_TYPE_THRESHOLD: c_uint = 123;
1380pub const CSSM_ACL_SUBJECT_TYPE_PASSWORD: c_uint = 79;
1382pub const CSSM_ACL_SUBJECT_TYPE_PROTECTED_PASSWORD: c_uint = 87;
1384pub const CSSM_ACL_SUBJECT_TYPE_PROMPTED_PASSWORD: c_uint = 84;
1386pub const CSSM_ACL_SUBJECT_TYPE_PUBLIC_KEY: c_uint = 89;
1388pub const CSSM_ACL_SUBJECT_TYPE_HASHED_SUBJECT: c_uint = 44;
1390pub const CSSM_ACL_SUBJECT_TYPE_BIOMETRIC: c_uint = 8;
1392pub const CSSM_ACL_SUBJECT_TYPE_PROTECTED_BIOMETRIC: c_uint = 86;
1394pub const CSSM_ACL_SUBJECT_TYPE_PROMPTED_BIOMETRIC: c_uint = 83;
1396pub const CSSM_ACL_SUBJECT_TYPE_LOGIN_NAME: c_uint = 58;
1398pub const CSSM_ACL_SUBJECT_TYPE_EXT_PAM_NAME: c_uint = 78;
1400
1401#[cfg(feature = "cssmconfig")]
1403pub type CSSM_ACL_AUTHORIZATION_TAG = sint32;
1404
1405pub const CSSM_ACL_AUTHORIZATION_TAG_VENDOR_DEFINED_START: c_uint = 65536;
1407pub const CSSM_ACL_AUTHORIZATION_ANY: c_uint = 1;
1409pub const CSSM_ACL_AUTHORIZATION_LOGIN: c_uint = 57;
1411pub const CSSM_ACL_AUTHORIZATION_GENKEY: c_uint = 41;
1413pub const CSSM_ACL_AUTHORIZATION_DELETE: c_uint = 25;
1415pub const CSSM_ACL_AUTHORIZATION_EXPORT_WRAPPED: c_uint = 38;
1417pub const CSSM_ACL_AUTHORIZATION_EXPORT_CLEAR: c_uint = 37;
1419pub const CSSM_ACL_AUTHORIZATION_IMPORT_WRAPPED: c_uint = 48;
1421pub const CSSM_ACL_AUTHORIZATION_IMPORT_CLEAR: c_uint = 47;
1423pub const CSSM_ACL_AUTHORIZATION_SIGN: c_uint = 115;
1425pub const CSSM_ACL_AUTHORIZATION_ENCRYPT: c_uint = 35;
1427pub const CSSM_ACL_AUTHORIZATION_DECRYPT: c_uint = 24;
1429pub const CSSM_ACL_AUTHORIZATION_MAC: c_uint = 59;
1431pub const CSSM_ACL_AUTHORIZATION_DERIVE: c_uint = 28;
1433pub const CSSM_ACL_AUTHORIZATION_DBS_CREATE: c_uint = 22;
1435pub const CSSM_ACL_AUTHORIZATION_DBS_DELETE: c_uint = 23;
1437pub const CSSM_ACL_AUTHORIZATION_DB_READ: c_uint = 21;
1439pub const CSSM_ACL_AUTHORIZATION_DB_INSERT: c_uint = 19;
1441pub const CSSM_ACL_AUTHORIZATION_DB_MODIFY: c_uint = 20;
1443pub const CSSM_ACL_AUTHORIZATION_DB_DELETE: c_uint = 17;
1445
1446#[cfg(feature = "cssmconfig")]
1448#[repr(C)]
1449#[derive(Clone, Copy, Debug, PartialEq)]
1450pub struct cssm_authorizationgroup {
1451 pub NumberOfAuthTags: uint32,
1452 pub AuthTags: *mut CSSM_ACL_AUTHORIZATION_TAG,
1453}
1454
1455#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1456unsafe impl Encode for cssm_authorizationgroup {
1457 const ENCODING: Encoding = Encoding::Struct(
1458 "cssm_authorizationgroup",
1459 &[
1460 <uint32>::ENCODING,
1461 <*mut CSSM_ACL_AUTHORIZATION_TAG>::ENCODING,
1462 ],
1463 );
1464}
1465
1466#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1467unsafe impl RefEncode for cssm_authorizationgroup {
1468 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1469}
1470
1471#[cfg(feature = "cssmconfig")]
1473pub type CSSM_AUTHORIZATIONGROUP = cssm_authorizationgroup;
1474
1475#[cfg(feature = "cssmconfig")]
1477pub type CSSM_AUTHORIZATIONGROUP_PTR = *mut cssm_authorizationgroup;
1478
1479#[cfg(feature = "SecAsn1Types")]
1481#[deprecated]
1482#[repr(C)]
1483#[derive(Clone, Copy, Debug, PartialEq)]
1484pub struct cssm_acl_validity_period {
1485 pub StartDate: SecAsn1Item,
1486 pub EndDate: SecAsn1Item,
1487}
1488
1489#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
1490unsafe impl Encode for cssm_acl_validity_period {
1491 const ENCODING: Encoding = Encoding::Struct(
1492 "cssm_acl_validity_period",
1493 &[<SecAsn1Item>::ENCODING, <SecAsn1Item>::ENCODING],
1494 );
1495}
1496
1497#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
1498unsafe impl RefEncode for cssm_acl_validity_period {
1499 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1500}
1501
1502#[cfg(feature = "SecAsn1Types")]
1504pub type CSSM_ACL_VALIDITY_PERIOD = cssm_acl_validity_period;
1505
1506#[cfg(feature = "SecAsn1Types")]
1508pub type CSSM_ACL_VALIDITY_PERIOD_PTR = *mut cssm_acl_validity_period;
1509
1510#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1512#[deprecated]
1513#[repr(C)]
1514#[derive(Clone, Copy, Debug, PartialEq)]
1515pub struct cssm_acl_entry_prototype {
1516 pub TypedSubject: CSSM_LIST,
1517 pub Delegate: CSSM_BOOL,
1518 pub Authorization: CSSM_AUTHORIZATIONGROUP,
1519 pub TimeRange: CSSM_ACL_VALIDITY_PERIOD,
1520 pub EntryTag: CSSM_STRING,
1521}
1522
1523#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1524unsafe impl Encode for cssm_acl_entry_prototype {
1525 const ENCODING: Encoding = Encoding::Struct(
1526 "cssm_acl_entry_prototype",
1527 &[
1528 <CSSM_LIST>::ENCODING,
1529 <CSSM_BOOL>::ENCODING,
1530 <CSSM_AUTHORIZATIONGROUP>::ENCODING,
1531 <CSSM_ACL_VALIDITY_PERIOD>::ENCODING,
1532 <CSSM_STRING>::ENCODING,
1533 ],
1534 );
1535}
1536
1537#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1538unsafe impl RefEncode for cssm_acl_entry_prototype {
1539 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1540}
1541
1542#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1544pub type CSSM_ACL_ENTRY_PROTOTYPE = cssm_acl_entry_prototype;
1545
1546#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1548pub type CSSM_ACL_ENTRY_PROTOTYPE_PTR = *mut cssm_acl_entry_prototype;
1549
1550#[cfg(feature = "cssmconfig")]
1552#[deprecated]
1553#[repr(C)]
1554#[derive(Clone, Copy, Debug, PartialEq)]
1555pub struct cssm_acl_owner_prototype {
1556 pub TypedSubject: CSSM_LIST,
1557 pub Delegate: CSSM_BOOL,
1558}
1559
1560#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1561unsafe impl Encode for cssm_acl_owner_prototype {
1562 const ENCODING: Encoding = Encoding::Struct(
1563 "cssm_acl_owner_prototype",
1564 &[<CSSM_LIST>::ENCODING, <CSSM_BOOL>::ENCODING],
1565 );
1566}
1567
1568#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1569unsafe impl RefEncode for cssm_acl_owner_prototype {
1570 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1571}
1572
1573#[cfg(feature = "cssmconfig")]
1575pub type CSSM_ACL_OWNER_PROTOTYPE = cssm_acl_owner_prototype;
1576
1577#[cfg(feature = "cssmconfig")]
1579pub type CSSM_ACL_OWNER_PROTOTYPE_PTR = *mut cssm_acl_owner_prototype;
1580
1581#[cfg(feature = "cssmconfig")]
1583pub type CSSM_ACL_SUBJECT_CALLBACK = Option<
1584 unsafe extern "C-unwind" fn(
1585 *const CSSM_LIST,
1586 CSSM_LIST_PTR,
1587 *mut c_void,
1588 *const CSSM_MEMORY_FUNCS,
1589 ) -> CSSM_RETURN,
1590>;
1591
1592#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1594#[deprecated]
1595#[repr(C)]
1596#[derive(Clone, Copy, Debug, PartialEq)]
1597pub struct cssm_acl_entry_input {
1598 pub Prototype: CSSM_ACL_ENTRY_PROTOTYPE,
1599 pub Callback: CSSM_ACL_SUBJECT_CALLBACK,
1600 pub CallerContext: *mut c_void,
1601}
1602
1603#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1604unsafe impl Encode for cssm_acl_entry_input {
1605 const ENCODING: Encoding = Encoding::Struct(
1606 "cssm_acl_entry_input",
1607 &[
1608 <CSSM_ACL_ENTRY_PROTOTYPE>::ENCODING,
1609 <CSSM_ACL_SUBJECT_CALLBACK>::ENCODING,
1610 <*mut c_void>::ENCODING,
1611 ],
1612 );
1613}
1614
1615#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1616unsafe impl RefEncode for cssm_acl_entry_input {
1617 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1618}
1619
1620#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1622pub type CSSM_ACL_ENTRY_INPUT = cssm_acl_entry_input;
1623
1624#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1626pub type CSSM_ACL_ENTRY_INPUT_PTR = *mut cssm_acl_entry_input;
1627
1628#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1630#[deprecated]
1631#[repr(C)]
1632#[derive(Clone, Copy, Debug, PartialEq)]
1633pub struct cssm_resource_control_context {
1634 pub AccessCred: CSSM_ACCESS_CREDENTIALS_PTR,
1635 pub InitialAclEntry: CSSM_ACL_ENTRY_INPUT,
1636}
1637
1638#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1639unsafe impl Encode for cssm_resource_control_context {
1640 const ENCODING: Encoding = Encoding::Struct(
1641 "cssm_resource_control_context",
1642 &[
1643 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
1644 <CSSM_ACL_ENTRY_INPUT>::ENCODING,
1645 ],
1646 );
1647}
1648
1649#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1650unsafe impl RefEncode for cssm_resource_control_context {
1651 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1652}
1653
1654#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1656pub type CSSM_RESOURCE_CONTROL_CONTEXT = cssm_resource_control_context;
1657
1658#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1660pub type CSSM_RESOURCE_CONTROL_CONTEXT_PTR = *mut cssm_resource_control_context;
1661
1662#[cfg(feature = "cssmconfig")]
1664pub type CSSM_ACL_HANDLE = CSSM_HANDLE;
1665
1666#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1668#[deprecated]
1669#[repr(C)]
1670#[derive(Clone, Copy, Debug, PartialEq)]
1671pub struct cssm_acl_entry_info {
1672 pub EntryPublicInfo: CSSM_ACL_ENTRY_PROTOTYPE,
1673 pub EntryHandle: CSSM_ACL_HANDLE,
1674}
1675
1676#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1677unsafe impl Encode for cssm_acl_entry_info {
1678 const ENCODING: Encoding = Encoding::Struct(
1679 "cssm_acl_entry_info",
1680 &[
1681 <CSSM_ACL_ENTRY_PROTOTYPE>::ENCODING,
1682 <CSSM_ACL_HANDLE>::ENCODING,
1683 ],
1684 );
1685}
1686
1687#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1688unsafe impl RefEncode for cssm_acl_entry_info {
1689 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1690}
1691
1692#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1694pub type CSSM_ACL_ENTRY_INFO = cssm_acl_entry_info;
1695
1696#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1698pub type CSSM_ACL_ENTRY_INFO_PTR = *mut cssm_acl_entry_info;
1699
1700#[cfg(feature = "cssmconfig")]
1702pub type CSSM_ACL_EDIT_MODE = uint32;
1703
1704pub const CSSM_ACL_EDIT_MODE_ADD: c_uint = 1;
1706pub const CSSM_ACL_EDIT_MODE_DELETE: c_uint = 2;
1708pub const CSSM_ACL_EDIT_MODE_REPLACE: c_uint = 3;
1710
1711#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1713#[deprecated]
1714#[repr(C)]
1715#[derive(Clone, Copy, Debug, PartialEq)]
1716pub struct cssm_acl_edit {
1717 pub EditMode: CSSM_ACL_EDIT_MODE,
1718 pub OldEntryHandle: CSSM_ACL_HANDLE,
1719 pub NewEntry: *const CSSM_ACL_ENTRY_INPUT,
1720}
1721
1722#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1723unsafe impl Encode for cssm_acl_edit {
1724 const ENCODING: Encoding = Encoding::Struct(
1725 "cssm_acl_edit",
1726 &[
1727 <CSSM_ACL_EDIT_MODE>::ENCODING,
1728 <CSSM_ACL_HANDLE>::ENCODING,
1729 <*const CSSM_ACL_ENTRY_INPUT>::ENCODING,
1730 ],
1731 );
1732}
1733
1734#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1735unsafe impl RefEncode for cssm_acl_edit {
1736 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1737}
1738
1739#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1741pub type CSSM_ACL_EDIT = cssm_acl_edit;
1742
1743#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1745pub type CSSM_ACL_EDIT_PTR = *mut cssm_acl_edit;
1746
1747pub type CSSM_PROC_ADDR = Option<unsafe extern "C-unwind" fn()>;
1749
1750pub type CSSM_PROC_ADDR_PTR = *mut CSSM_PROC_ADDR;
1752
1753#[repr(C)]
1755#[derive(Clone, Copy, Debug, PartialEq)]
1756pub struct cssm_func_name_addr {
1757 pub Name: CSSM_STRING,
1758 pub Address: CSSM_PROC_ADDR,
1759}
1760
1761#[cfg(feature = "objc2")]
1762unsafe impl Encode for cssm_func_name_addr {
1763 const ENCODING: Encoding = Encoding::Struct(
1764 "cssm_func_name_addr",
1765 &[<CSSM_STRING>::ENCODING, <CSSM_PROC_ADDR>::ENCODING],
1766 );
1767}
1768
1769#[cfg(feature = "objc2")]
1770unsafe impl RefEncode for cssm_func_name_addr {
1771 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1772}
1773
1774pub type CSSM_FUNC_NAME_ADDR = cssm_func_name_addr;
1776
1777pub type CSSM_FUNC_NAME_ADDR_PTR = *mut cssm_func_name_addr;
1779
1780#[cfg(feature = "cssmconfig")]
1782#[repr(C)]
1783#[derive(Clone, Copy, Debug, PartialEq)]
1784pub struct cssm_date {
1785 pub Year: [uint8; 4],
1786 pub Month: [uint8; 2],
1787 pub Day: [uint8; 2],
1788}
1789
1790#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1791unsafe impl Encode for cssm_date {
1792 const ENCODING: Encoding = Encoding::Struct(
1793 "cssm_date",
1794 &[
1795 <[uint8; 4]>::ENCODING,
1796 <[uint8; 2]>::ENCODING,
1797 <[uint8; 2]>::ENCODING,
1798 ],
1799 );
1800}
1801
1802#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1803unsafe impl RefEncode for cssm_date {
1804 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1805}
1806
1807#[cfg(feature = "cssmconfig")]
1809pub type CSSM_DATE = cssm_date;
1810
1811#[cfg(feature = "cssmconfig")]
1813pub type CSSM_DATE_PTR = *mut cssm_date;
1814
1815#[cfg(feature = "cssmconfig")]
1817#[repr(C)]
1818#[derive(Clone, Copy, Debug, PartialEq)]
1819pub struct cssm_range {
1820 pub Min: uint32,
1821 pub Max: uint32,
1822}
1823
1824#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1825unsafe impl Encode for cssm_range {
1826 const ENCODING: Encoding =
1827 Encoding::Struct("cssm_range", &[<uint32>::ENCODING, <uint32>::ENCODING]);
1828}
1829
1830#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1831unsafe impl RefEncode for cssm_range {
1832 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1833}
1834
1835#[cfg(feature = "cssmconfig")]
1837pub type CSSM_RANGE = cssm_range;
1838
1839#[cfg(feature = "cssmconfig")]
1841pub type CSSM_RANGE_PTR = *mut cssm_range;
1842
1843#[cfg(feature = "cssmconfig")]
1845#[repr(C)]
1846#[derive(Clone, Copy, Debug, PartialEq)]
1847pub struct cssm_query_size_data {
1848 pub SizeInputBlock: uint32,
1849 pub SizeOutputBlock: uint32,
1850}
1851
1852#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1853unsafe impl Encode for cssm_query_size_data {
1854 const ENCODING: Encoding = Encoding::Struct(
1855 "cssm_query_size_data",
1856 &[<uint32>::ENCODING, <uint32>::ENCODING],
1857 );
1858}
1859
1860#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1861unsafe impl RefEncode for cssm_query_size_data {
1862 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1863}
1864
1865#[cfg(feature = "cssmconfig")]
1867pub type CSSM_QUERY_SIZE_DATA = cssm_query_size_data;
1868
1869#[cfg(feature = "cssmconfig")]
1871pub type CSSM_QUERY_SIZE_DATA_PTR = *mut cssm_query_size_data;
1872
1873#[cfg(feature = "cssmconfig")]
1875pub type CSSM_HEADERVERSION = uint32;
1876
1877pub const CSSM_KEYHEADER_VERSION: c_uint = 2;
1879
1880#[cfg(feature = "cssmconfig")]
1882#[repr(C)]
1883#[derive(Clone, Copy, Debug, PartialEq)]
1884pub struct cssm_key_size {
1885 pub LogicalKeySizeInBits: uint32,
1886 pub EffectiveKeySizeInBits: uint32,
1887}
1888
1889#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1890unsafe impl Encode for cssm_key_size {
1891 const ENCODING: Encoding =
1892 Encoding::Struct("cssm_key_size", &[<uint32>::ENCODING, <uint32>::ENCODING]);
1893}
1894
1895#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1896unsafe impl RefEncode for cssm_key_size {
1897 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1898}
1899
1900#[cfg(feature = "cssmconfig")]
1902pub type CSSM_KEY_SIZE = cssm_key_size;
1903
1904#[cfg(feature = "cssmconfig")]
1906pub type CSSM_KEY_SIZE_PTR = *mut cssm_key_size;
1907
1908#[cfg(feature = "cssmconfig")]
1910pub type CSSM_KEYBLOB_TYPE = uint32;
1911
1912pub const CSSM_KEYBLOB_RAW: c_uint = 0;
1914pub const CSSM_KEYBLOB_REFERENCE: c_uint = 2;
1916pub const CSSM_KEYBLOB_WRAPPED: c_uint = 3;
1918pub const CSSM_KEYBLOB_OTHER: c_uint = 4294967295;
1920
1921#[cfg(feature = "cssmconfig")]
1923pub type CSSM_KEYBLOB_FORMAT = uint32;
1924
1925pub const CSSM_KEYBLOB_RAW_FORMAT_NONE: c_uint = 0;
1927pub const CSSM_KEYBLOB_RAW_FORMAT_PKCS1: c_uint = 1;
1929pub const CSSM_KEYBLOB_RAW_FORMAT_PKCS3: c_uint = 2;
1931pub const CSSM_KEYBLOB_RAW_FORMAT_MSCAPI: c_uint = 3;
1933pub const CSSM_KEYBLOB_RAW_FORMAT_PGP: c_uint = 4;
1935pub const CSSM_KEYBLOB_RAW_FORMAT_FIPS186: c_uint = 5;
1937pub const CSSM_KEYBLOB_RAW_FORMAT_BSAFE: c_uint = 6;
1939pub const CSSM_KEYBLOB_RAW_FORMAT_CCA: c_uint = 9;
1941pub const CSSM_KEYBLOB_RAW_FORMAT_PKCS8: c_uint = 10;
1943pub const CSSM_KEYBLOB_RAW_FORMAT_SPKI: c_uint = 11;
1945pub const CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING: c_uint = 12;
1947pub const CSSM_KEYBLOB_RAW_FORMAT_OTHER: c_uint = 4294967295;
1949
1950pub const CSSM_KEYBLOB_WRAPPED_FORMAT_NONE: c_uint = 0;
1952pub const CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS8: c_uint = 1;
1954pub const CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS7: c_uint = 2;
1956pub const CSSM_KEYBLOB_WRAPPED_FORMAT_MSCAPI: c_uint = 3;
1958pub const CSSM_KEYBLOB_WRAPPED_FORMAT_OTHER: c_uint = 4294967295;
1960
1961pub const CSSM_KEYBLOB_REF_FORMAT_INTEGER: c_uint = 0;
1963pub const CSSM_KEYBLOB_REF_FORMAT_STRING: c_uint = 1;
1965pub const CSSM_KEYBLOB_REF_FORMAT_SPKI: c_uint = 2;
1967pub const CSSM_KEYBLOB_REF_FORMAT_OTHER: c_uint = 4294967295;
1969
1970#[cfg(feature = "cssmconfig")]
1972pub type CSSM_KEYCLASS = uint32;
1973
1974pub const CSSM_KEYCLASS_PUBLIC_KEY: c_uint = 0;
1976pub const CSSM_KEYCLASS_PRIVATE_KEY: c_uint = 1;
1978pub const CSSM_KEYCLASS_SESSION_KEY: c_uint = 2;
1980pub const CSSM_KEYCLASS_SECRET_PART: c_uint = 3;
1982pub const CSSM_KEYCLASS_OTHER: c_uint = 4294967295;
1984
1985#[cfg(feature = "cssmconfig")]
1987pub type CSSM_KEYATTR_FLAGS = uint32;
1988
1989pub const CSSM_KEYATTR_RETURN_DEFAULT: c_uint = 0;
1991pub const CSSM_KEYATTR_RETURN_DATA: c_uint = 268435456;
1993pub const CSSM_KEYATTR_RETURN_REF: c_uint = 536870912;
1995pub const CSSM_KEYATTR_RETURN_NONE: c_uint = 1073741824;
1997pub const CSSM_KEYATTR_PERMANENT: c_uint = 1;
1999pub const CSSM_KEYATTR_PRIVATE: c_uint = 2;
2001pub const CSSM_KEYATTR_MODIFIABLE: c_uint = 4;
2003pub const CSSM_KEYATTR_SENSITIVE: c_uint = 8;
2005pub const CSSM_KEYATTR_EXTRACTABLE: c_uint = 32;
2007pub const CSSM_KEYATTR_ALWAYS_SENSITIVE: c_uint = 16;
2009pub const CSSM_KEYATTR_NEVER_EXTRACTABLE: c_uint = 64;
2011
2012#[cfg(feature = "cssmconfig")]
2014pub type CSSM_KEYUSE = uint32;
2015
2016pub const CSSM_KEYUSE_ANY: c_uint = 2147483648;
2018pub const CSSM_KEYUSE_ENCRYPT: c_uint = 1;
2020pub const CSSM_KEYUSE_DECRYPT: c_uint = 2;
2022pub const CSSM_KEYUSE_SIGN: c_uint = 4;
2024pub const CSSM_KEYUSE_VERIFY: c_uint = 8;
2026pub const CSSM_KEYUSE_SIGN_RECOVER: c_uint = 16;
2028pub const CSSM_KEYUSE_VERIFY_RECOVER: c_uint = 32;
2030pub const CSSM_KEYUSE_WRAP: c_uint = 64;
2032pub const CSSM_KEYUSE_UNWRAP: c_uint = 128;
2034pub const CSSM_KEYUSE_DERIVE: c_uint = 256;
2036
2037#[cfg(feature = "cssmconfig")]
2039pub type CSSM_ALGORITHMS = uint32;
2040
2041pub const CSSM_ALGID_NONE: c_uint = 0;
2043pub const CSSM_ALGID_CUSTOM: c_uint = 1;
2045pub const CSSM_ALGID_DH: c_uint = 2;
2047pub const CSSM_ALGID_PH: c_uint = 3;
2049pub const CSSM_ALGID_KEA: c_uint = 4;
2051pub const CSSM_ALGID_MD2: c_uint = 5;
2053pub const CSSM_ALGID_MD4: c_uint = 6;
2055pub const CSSM_ALGID_MD5: c_uint = 7;
2057pub const CSSM_ALGID_SHA1: c_uint = 8;
2059pub const CSSM_ALGID_NHASH: c_uint = 9;
2061pub const CSSM_ALGID_HAVAL: c_uint = 10;
2063pub const CSSM_ALGID_RIPEMD: c_uint = 11;
2065pub const CSSM_ALGID_IBCHASH: c_uint = 12;
2067pub const CSSM_ALGID_RIPEMAC: c_uint = 13;
2069pub const CSSM_ALGID_DES: c_uint = 14;
2071pub const CSSM_ALGID_DESX: c_uint = 15;
2073pub const CSSM_ALGID_RDES: c_uint = 16;
2075pub const CSSM_ALGID_3DES_3KEY_EDE: c_uint = 17;
2077pub const CSSM_ALGID_3DES_2KEY_EDE: c_uint = 18;
2079pub const CSSM_ALGID_3DES_1KEY_EEE: c_uint = 19;
2081pub const CSSM_ALGID_3DES_3KEY: c_uint = 17;
2083pub const CSSM_ALGID_3DES_3KEY_EEE: c_uint = 20;
2085pub const CSSM_ALGID_3DES_2KEY: c_uint = 18;
2087pub const CSSM_ALGID_3DES_2KEY_EEE: c_uint = 21;
2089pub const CSSM_ALGID_3DES_1KEY: c_uint = 20;
2091pub const CSSM_ALGID_IDEA: c_uint = 22;
2093pub const CSSM_ALGID_RC2: c_uint = 23;
2095pub const CSSM_ALGID_RC5: c_uint = 24;
2097pub const CSSM_ALGID_RC4: c_uint = 25;
2099pub const CSSM_ALGID_SEAL: c_uint = 26;
2101pub const CSSM_ALGID_CAST: c_uint = 27;
2103pub const CSSM_ALGID_BLOWFISH: c_uint = 28;
2105pub const CSSM_ALGID_SKIPJACK: c_uint = 29;
2107pub const CSSM_ALGID_LUCIFER: c_uint = 30;
2109pub const CSSM_ALGID_MADRYGA: c_uint = 31;
2111pub const CSSM_ALGID_FEAL: c_uint = 32;
2113pub const CSSM_ALGID_REDOC: c_uint = 33;
2115pub const CSSM_ALGID_REDOC3: c_uint = 34;
2117pub const CSSM_ALGID_LOKI: c_uint = 35;
2119pub const CSSM_ALGID_KHUFU: c_uint = 36;
2121pub const CSSM_ALGID_KHAFRE: c_uint = 37;
2123pub const CSSM_ALGID_MMB: c_uint = 38;
2125pub const CSSM_ALGID_GOST: c_uint = 39;
2127pub const CSSM_ALGID_SAFER: c_uint = 40;
2129pub const CSSM_ALGID_CRAB: c_uint = 41;
2131pub const CSSM_ALGID_RSA: c_uint = 42;
2133pub const CSSM_ALGID_DSA: c_uint = 43;
2135pub const CSSM_ALGID_MD5WithRSA: c_uint = 44;
2137pub const CSSM_ALGID_MD2WithRSA: c_uint = 45;
2139pub const CSSM_ALGID_ElGamal: c_uint = 46;
2141pub const CSSM_ALGID_MD2Random: c_uint = 47;
2143pub const CSSM_ALGID_MD5Random: c_uint = 48;
2145pub const CSSM_ALGID_SHARandom: c_uint = 49;
2147pub const CSSM_ALGID_DESRandom: c_uint = 50;
2149pub const CSSM_ALGID_SHA1WithRSA: c_uint = 51;
2151pub const CSSM_ALGID_CDMF: c_uint = 52;
2153pub const CSSM_ALGID_CAST3: c_uint = 53;
2155pub const CSSM_ALGID_CAST5: c_uint = 54;
2157pub const CSSM_ALGID_GenericSecret: c_uint = 55;
2159pub const CSSM_ALGID_ConcatBaseAndKey: c_uint = 56;
2161pub const CSSM_ALGID_ConcatKeyAndBase: c_uint = 57;
2163pub const CSSM_ALGID_ConcatBaseAndData: c_uint = 58;
2165pub const CSSM_ALGID_ConcatDataAndBase: c_uint = 59;
2167pub const CSSM_ALGID_XORBaseAndData: c_uint = 60;
2169pub const CSSM_ALGID_ExtractFromKey: c_uint = 61;
2171pub const CSSM_ALGID_SSL3PrePrimaryGen: c_uint = 62;
2173#[deprecated]
2175pub const CSSM_ALGID_SSL3PreMasterGen: c_uint = 62;
2176pub const CSSM_ALGID_SSL3PrimaryDerive: c_uint = 63;
2178#[deprecated]
2180pub const CSSM_ALGID_SSL3MasterDerive: c_uint = 63;
2181pub const CSSM_ALGID_SSL3KeyAndMacDerive: c_uint = 64;
2183pub const CSSM_ALGID_SSL3MD5_MAC: c_uint = 65;
2185pub const CSSM_ALGID_SSL3SHA1_MAC: c_uint = 66;
2187pub const CSSM_ALGID_PKCS5_PBKDF1_MD5: c_uint = 67;
2189pub const CSSM_ALGID_PKCS5_PBKDF1_MD2: c_uint = 68;
2191pub const CSSM_ALGID_PKCS5_PBKDF1_SHA1: c_uint = 69;
2193pub const CSSM_ALGID_WrapLynks: c_uint = 70;
2195pub const CSSM_ALGID_WrapSET_OAEP: c_uint = 71;
2197pub const CSSM_ALGID_BATON: c_uint = 72;
2199pub const CSSM_ALGID_ECDSA: c_uint = 73;
2201pub const CSSM_ALGID_MAYFLY: c_uint = 74;
2203pub const CSSM_ALGID_JUNIPER: c_uint = 75;
2205pub const CSSM_ALGID_FASTHASH: c_uint = 76;
2207pub const CSSM_ALGID_3DES: c_uint = 77;
2209pub const CSSM_ALGID_SSL3MD5: c_uint = 78;
2211pub const CSSM_ALGID_SSL3SHA1: c_uint = 79;
2213pub const CSSM_ALGID_FortezzaTimestamp: c_uint = 80;
2215pub const CSSM_ALGID_SHA1WithDSA: c_uint = 81;
2217pub const CSSM_ALGID_SHA1WithECDSA: c_uint = 82;
2219pub const CSSM_ALGID_DSA_BSAFE: c_uint = 83;
2221pub const CSSM_ALGID_ECDH: c_uint = 84;
2223pub const CSSM_ALGID_ECMQV: c_uint = 85;
2225pub const CSSM_ALGID_PKCS12_SHA1_PBE: c_uint = 86;
2227pub const CSSM_ALGID_ECNRA: c_uint = 87;
2229pub const CSSM_ALGID_SHA1WithECNRA: c_uint = 88;
2231pub const CSSM_ALGID_ECES: c_uint = 89;
2233pub const CSSM_ALGID_ECAES: c_uint = 90;
2235pub const CSSM_ALGID_SHA1HMAC: c_uint = 91;
2237pub const CSSM_ALGID_FIPS186Random: c_uint = 92;
2239pub const CSSM_ALGID_ECC: c_uint = 93;
2241pub const CSSM_ALGID_MQV: c_uint = 94;
2243pub const CSSM_ALGID_NRA: c_uint = 95;
2245pub const CSSM_ALGID_IntelPlatformRandom: c_uint = 96;
2247pub const CSSM_ALGID_UTC: c_uint = 97;
2249pub const CSSM_ALGID_HAVAL3: c_uint = 98;
2251pub const CSSM_ALGID_HAVAL4: c_uint = 99;
2253pub const CSSM_ALGID_HAVAL5: c_uint = 100;
2255pub const CSSM_ALGID_TIGER: c_uint = 101;
2257pub const CSSM_ALGID_MD5HMAC: c_uint = 102;
2259pub const CSSM_ALGID_PKCS5_PBKDF2: c_uint = 103;
2261pub const CSSM_ALGID_RUNNING_COUNTER: c_uint = 104;
2263pub const CSSM_ALGID_LAST: c_uint = 2147483647;
2265pub const CSSM_ALGID_VENDOR_DEFINED: c_uint = 2147483648;
2267
2268#[cfg(feature = "cssmconfig")]
2270pub type CSSM_ENCRYPT_MODE = uint32;
2271
2272pub const CSSM_ALGMODE_NONE: c_uint = 0;
2274pub const CSSM_ALGMODE_CUSTOM: c_uint = 1;
2276pub const CSSM_ALGMODE_ECB: c_uint = 2;
2278pub const CSSM_ALGMODE_ECBPad: c_uint = 3;
2280pub const CSSM_ALGMODE_CBC: c_uint = 4;
2282pub const CSSM_ALGMODE_CBC_IV8: c_uint = 5;
2284pub const CSSM_ALGMODE_CBCPadIV8: c_uint = 6;
2286pub const CSSM_ALGMODE_CFB: c_uint = 7;
2288pub const CSSM_ALGMODE_CFB_IV8: c_uint = 8;
2290pub const CSSM_ALGMODE_CFBPadIV8: c_uint = 9;
2292pub const CSSM_ALGMODE_OFB: c_uint = 10;
2294pub const CSSM_ALGMODE_OFB_IV8: c_uint = 11;
2296pub const CSSM_ALGMODE_OFBPadIV8: c_uint = 12;
2298pub const CSSM_ALGMODE_COUNTER: c_uint = 13;
2300pub const CSSM_ALGMODE_BC: c_uint = 14;
2302pub const CSSM_ALGMODE_PCBC: c_uint = 15;
2304pub const CSSM_ALGMODE_CBCC: c_uint = 16;
2306pub const CSSM_ALGMODE_OFBNLF: c_uint = 17;
2308pub const CSSM_ALGMODE_PBC: c_uint = 18;
2310pub const CSSM_ALGMODE_PFB: c_uint = 19;
2312pub const CSSM_ALGMODE_CBCPD: c_uint = 20;
2314pub const CSSM_ALGMODE_PUBLIC_KEY: c_uint = 21;
2316pub const CSSM_ALGMODE_PRIVATE_KEY: c_uint = 22;
2318pub const CSSM_ALGMODE_SHUFFLE: c_uint = 23;
2320pub const CSSM_ALGMODE_ECB64: c_uint = 24;
2322pub const CSSM_ALGMODE_CBC64: c_uint = 25;
2324pub const CSSM_ALGMODE_OFB64: c_uint = 26;
2326pub const CSSM_ALGMODE_CFB32: c_uint = 28;
2328pub const CSSM_ALGMODE_CFB16: c_uint = 29;
2330pub const CSSM_ALGMODE_CFB8: c_uint = 30;
2332pub const CSSM_ALGMODE_WRAP: c_uint = 31;
2334pub const CSSM_ALGMODE_PRIVATE_WRAP: c_uint = 32;
2336pub const CSSM_ALGMODE_RELAYX: c_uint = 33;
2338pub const CSSM_ALGMODE_ECB128: c_uint = 34;
2340pub const CSSM_ALGMODE_ECB96: c_uint = 35;
2342pub const CSSM_ALGMODE_CBC128: c_uint = 36;
2344pub const CSSM_ALGMODE_OAEP_HASH: c_uint = 37;
2346pub const CSSM_ALGMODE_PKCS1_EME_V15: c_uint = 38;
2348pub const CSSM_ALGMODE_PKCS1_EME_OAEP: c_uint = 39;
2350pub const CSSM_ALGMODE_PKCS1_EMSA_V15: c_uint = 40;
2352pub const CSSM_ALGMODE_ISO_9796: c_uint = 41;
2354pub const CSSM_ALGMODE_X9_31: c_uint = 42;
2356pub const CSSM_ALGMODE_LAST: c_uint = 2147483647;
2358pub const CSSM_ALGMODE_VENDOR_DEFINED: c_uint = 2147483648;
2360
2361#[cfg(feature = "cssmconfig")]
2363#[deprecated]
2364#[repr(C)]
2365#[derive(Clone, Copy, Debug, PartialEq)]
2366pub struct cssm_keyheader {
2367 pub HeaderVersion: CSSM_HEADERVERSION,
2368 pub CspId: CSSM_GUID,
2369 pub BlobType: CSSM_KEYBLOB_TYPE,
2370 pub Format: CSSM_KEYBLOB_FORMAT,
2371 pub AlgorithmId: CSSM_ALGORITHMS,
2372 pub KeyClass: CSSM_KEYCLASS,
2373 pub LogicalKeySizeInBits: uint32,
2374 pub KeyAttr: CSSM_KEYATTR_FLAGS,
2375 pub KeyUsage: CSSM_KEYUSE,
2376 pub StartDate: CSSM_DATE,
2377 pub EndDate: CSSM_DATE,
2378 pub WrapAlgorithmId: CSSM_ALGORITHMS,
2379 pub WrapMode: CSSM_ENCRYPT_MODE,
2380 pub Reserved: uint32,
2381}
2382
2383#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2384unsafe impl Encode for cssm_keyheader {
2385 const ENCODING: Encoding = Encoding::Struct(
2386 "cssm_keyheader",
2387 &[
2388 <CSSM_HEADERVERSION>::ENCODING,
2389 <CSSM_GUID>::ENCODING,
2390 <CSSM_KEYBLOB_TYPE>::ENCODING,
2391 <CSSM_KEYBLOB_FORMAT>::ENCODING,
2392 <CSSM_ALGORITHMS>::ENCODING,
2393 <CSSM_KEYCLASS>::ENCODING,
2394 <uint32>::ENCODING,
2395 <CSSM_KEYATTR_FLAGS>::ENCODING,
2396 <CSSM_KEYUSE>::ENCODING,
2397 <CSSM_DATE>::ENCODING,
2398 <CSSM_DATE>::ENCODING,
2399 <CSSM_ALGORITHMS>::ENCODING,
2400 <CSSM_ENCRYPT_MODE>::ENCODING,
2401 <uint32>::ENCODING,
2402 ],
2403 );
2404}
2405
2406#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2407unsafe impl RefEncode for cssm_keyheader {
2408 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2409}
2410
2411#[cfg(feature = "cssmconfig")]
2413pub type CSSM_KEYHEADER = cssm_keyheader;
2414
2415#[cfg(feature = "cssmconfig")]
2417pub type CSSM_KEYHEADER_PTR = *mut cssm_keyheader;
2418
2419#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2421#[deprecated]
2422#[repr(C)]
2423#[derive(Clone, Copy, Debug, PartialEq)]
2424pub struct cssm_key {
2425 pub KeyHeader: CSSM_KEYHEADER,
2426 pub KeyData: SecAsn1Item,
2427}
2428
2429#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
2430unsafe impl Encode for cssm_key {
2431 const ENCODING: Encoding = Encoding::Struct(
2432 "cssm_key",
2433 &[<CSSM_KEYHEADER>::ENCODING, <SecAsn1Item>::ENCODING],
2434 );
2435}
2436
2437#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
2438unsafe impl RefEncode for cssm_key {
2439 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2440}
2441
2442#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2444pub type CSSM_KEY = cssm_key;
2445
2446#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2448pub type CSSM_KEY_PTR = *mut cssm_key;
2449
2450#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2452pub type CSSM_WRAP_KEY = CSSM_KEY;
2453
2454#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2456pub type CSSM_WRAP_KEY_PTR = *mut CSSM_KEY;
2457
2458#[cfg(feature = "cssmconfig")]
2460pub type CSSM_CSPTYPE = uint32;
2461
2462pub const CSSM_CSP_SOFTWARE: c_uint = 1;
2464pub const CSSM_CSP_HARDWARE: c_uint = 2;
2466pub const CSSM_CSP_HYBRID: c_uint = 3;
2468
2469#[cfg(feature = "cssmconfig")]
2471#[repr(C)]
2472#[derive(Clone, Copy, Debug, PartialEq)]
2473pub struct cssm_dl_db_handle {
2474 pub DLHandle: CSSM_DL_HANDLE,
2475 pub DBHandle: CSSM_DB_HANDLE,
2476}
2477
2478#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2479unsafe impl Encode for cssm_dl_db_handle {
2480 const ENCODING: Encoding = Encoding::Struct(
2481 "cssm_dl_db_handle",
2482 &[<CSSM_DL_HANDLE>::ENCODING, <CSSM_DB_HANDLE>::ENCODING],
2483 );
2484}
2485
2486#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2487unsafe impl RefEncode for cssm_dl_db_handle {
2488 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2489}
2490
2491#[cfg(feature = "cssmconfig")]
2493pub type CSSM_DL_DB_HANDLE = cssm_dl_db_handle;
2494
2495#[cfg(feature = "cssmconfig")]
2497pub type CSSM_DL_DB_HANDLE_PTR = *mut cssm_dl_db_handle;
2498
2499#[cfg(feature = "cssmconfig")]
2501pub type CSSM_CONTEXT_TYPE = uint32;
2502
2503pub const CSSM_ALGCLASS_NONE: c_uint = 0;
2505pub const CSSM_ALGCLASS_CUSTOM: c_uint = 1;
2507pub const CSSM_ALGCLASS_SIGNATURE: c_uint = 2;
2509pub const CSSM_ALGCLASS_SYMMETRIC: c_uint = 3;
2511pub const CSSM_ALGCLASS_DIGEST: c_uint = 4;
2513pub const CSSM_ALGCLASS_RANDOMGEN: c_uint = 5;
2515pub const CSSM_ALGCLASS_UNIQUEGEN: c_uint = 6;
2517pub const CSSM_ALGCLASS_MAC: c_uint = 7;
2519pub const CSSM_ALGCLASS_ASYMMETRIC: c_uint = 8;
2521pub const CSSM_ALGCLASS_KEYGEN: c_uint = 9;
2523pub const CSSM_ALGCLASS_DERIVEKEY: c_uint = 10;
2525
2526pub const CSSM_ATTRIBUTE_DATA_NONE: c_uint = 0;
2528pub const CSSM_ATTRIBUTE_DATA_UINT32: c_uint = 268435456;
2530pub const CSSM_ATTRIBUTE_DATA_CSSM_DATA: c_uint = 536870912;
2532pub const CSSM_ATTRIBUTE_DATA_CRYPTO_DATA: c_uint = 805306368;
2534pub const CSSM_ATTRIBUTE_DATA_KEY: c_uint = 1073741824;
2536pub const CSSM_ATTRIBUTE_DATA_STRING: c_uint = 1342177280;
2538pub const CSSM_ATTRIBUTE_DATA_DATE: c_uint = 1610612736;
2540pub const CSSM_ATTRIBUTE_DATA_RANGE: c_uint = 1879048192;
2542pub const CSSM_ATTRIBUTE_DATA_ACCESS_CREDENTIALS: c_uint = 2147483648;
2544pub const CSSM_ATTRIBUTE_DATA_VERSION: c_uint = 16777216;
2546pub const CSSM_ATTRIBUTE_DATA_DL_DB_HANDLE: c_uint = 33554432;
2548pub const CSSM_ATTRIBUTE_DATA_KR_PROFILE: c_uint = 50331648;
2550pub const CSSM_ATTRIBUTE_TYPE_MASK: c_uint = 4278190080;
2552
2553#[cfg(feature = "cssmconfig")]
2555pub type CSSM_ATTRIBUTE_TYPE = uint32;
2556
2557pub const CSSM_ATTRIBUTE_NONE: c_uint = 0;
2559pub const CSSM_ATTRIBUTE_CUSTOM: c_uint = 536870913;
2561pub const CSSM_ATTRIBUTE_DESCRIPTION: c_uint = 1342177282;
2563pub const CSSM_ATTRIBUTE_KEY: c_uint = 1073741827;
2565pub const CSSM_ATTRIBUTE_INIT_VECTOR: c_uint = 536870916;
2567pub const CSSM_ATTRIBUTE_SALT: c_uint = 536870917;
2569pub const CSSM_ATTRIBUTE_PADDING: c_uint = 268435462;
2571pub const CSSM_ATTRIBUTE_RANDOM: c_uint = 536870919;
2573pub const CSSM_ATTRIBUTE_SEED: c_uint = 805306376;
2575pub const CSSM_ATTRIBUTE_PASSPHRASE: c_uint = 805306377;
2577pub const CSSM_ATTRIBUTE_KEY_LENGTH: c_uint = 268435466;
2579pub const CSSM_ATTRIBUTE_KEY_LENGTH_RANGE: c_uint = 1879048203;
2581pub const CSSM_ATTRIBUTE_BLOCK_SIZE: c_uint = 268435468;
2583pub const CSSM_ATTRIBUTE_OUTPUT_SIZE: c_uint = 268435469;
2585pub const CSSM_ATTRIBUTE_ROUNDS: c_uint = 268435470;
2587pub const CSSM_ATTRIBUTE_IV_SIZE: c_uint = 268435471;
2589pub const CSSM_ATTRIBUTE_ALG_PARAMS: c_uint = 536870928;
2591pub const CSSM_ATTRIBUTE_LABEL: c_uint = 536870929;
2593pub const CSSM_ATTRIBUTE_KEY_TYPE: c_uint = 268435474;
2595pub const CSSM_ATTRIBUTE_MODE: c_uint = 268435475;
2597pub const CSSM_ATTRIBUTE_EFFECTIVE_BITS: c_uint = 268435476;
2599pub const CSSM_ATTRIBUTE_START_DATE: c_uint = 1610612757;
2601pub const CSSM_ATTRIBUTE_END_DATE: c_uint = 1610612758;
2603pub const CSSM_ATTRIBUTE_KEYUSAGE: c_uint = 268435479;
2605pub const CSSM_ATTRIBUTE_KEYATTR: c_uint = 268435480;
2607pub const CSSM_ATTRIBUTE_VERSION: c_uint = 16777241;
2609pub const CSSM_ATTRIBUTE_PRIME: c_uint = 536870938;
2611pub const CSSM_ATTRIBUTE_BASE: c_uint = 536870939;
2613pub const CSSM_ATTRIBUTE_SUBPRIME: c_uint = 536870940;
2615pub const CSSM_ATTRIBUTE_ALG_ID: c_uint = 268435485;
2617pub const CSSM_ATTRIBUTE_ITERATION_COUNT: c_uint = 268435486;
2619pub const CSSM_ATTRIBUTE_ROUNDS_RANGE: c_uint = 1879048223;
2621pub const CSSM_ATTRIBUTE_KRPROFILE_LOCAL: c_uint = 50331680;
2623pub const CSSM_ATTRIBUTE_KRPROFILE_REMOTE: c_uint = 50331681;
2625pub const CSSM_ATTRIBUTE_CSP_HANDLE: c_uint = 268435490;
2627pub const CSSM_ATTRIBUTE_DL_DB_HANDLE: c_uint = 33554467;
2629pub const CSSM_ATTRIBUTE_ACCESS_CREDENTIALS: c_uint = 2147483684;
2631pub const CSSM_ATTRIBUTE_PUBLIC_KEY_FORMAT: c_uint = 268435493;
2633pub const CSSM_ATTRIBUTE_PRIVATE_KEY_FORMAT: c_uint = 268435494;
2635pub const CSSM_ATTRIBUTE_SYMMETRIC_KEY_FORMAT: c_uint = 268435495;
2637pub const CSSM_ATTRIBUTE_WRAPPED_KEY_FORMAT: c_uint = 268435496;
2639
2640#[cfg(feature = "cssmconfig")]
2642pub type CSSM_PADDING = uint32;
2643
2644pub const CSSM_PADDING_NONE: c_uint = 0;
2646pub const CSSM_PADDING_CUSTOM: c_uint = 1;
2648pub const CSSM_PADDING_ZERO: c_uint = 2;
2650pub const CSSM_PADDING_ONE: c_uint = 3;
2652pub const CSSM_PADDING_ALTERNATE: c_uint = 4;
2654pub const CSSM_PADDING_FF: c_uint = 5;
2656pub const CSSM_PADDING_PKCS5: c_uint = 6;
2658pub const CSSM_PADDING_PKCS7: c_uint = 7;
2660pub const CSSM_PADDING_CIPHERSTEALING: c_uint = 8;
2662pub const CSSM_PADDING_RANDOM: c_uint = 9;
2664pub const CSSM_PADDING_PKCS1: c_uint = 10;
2666pub const CSSM_PADDING_SIGRAW: c_uint = 11;
2668pub const CSSM_PADDING_VENDOR_DEFINED: c_uint = 2147483648;
2670
2671#[cfg(feature = "cssmconfig")]
2673pub type CSSM_KEY_TYPE = CSSM_ALGORITHMS;
2674
2675#[cfg(all(
2677 feature = "SecAsn1Types",
2678 feature = "cssmconfig",
2679 feature = "cssmkrapi"
2680))]
2681#[deprecated]
2682#[repr(C)]
2683#[derive(Clone, Copy)]
2684pub union cssm_context_attribute_value {
2685 pub String: *mut c_char,
2686 pub Uint32: uint32,
2687 pub AccessCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
2688 pub Key: CSSM_KEY_PTR,
2689 pub Data: CSSM_DATA_PTR,
2690 pub Padding: CSSM_PADDING,
2691 pub Date: CSSM_DATE_PTR,
2692 pub Range: CSSM_RANGE_PTR,
2693 pub CryptoData: CSSM_CRYPTO_DATA_PTR,
2694 pub Version: CSSM_VERSION_PTR,
2695 pub DLDBHandle: CSSM_DL_DB_HANDLE_PTR,
2696 pub KRProfile: *mut cssm_kr_profile,
2697}
2698
2699#[cfg(all(
2700 feature = "SecAsn1Types",
2701 feature = "cssmconfig",
2702 feature = "cssmkrapi",
2703 feature = "objc2"
2704))]
2705unsafe impl Encode for cssm_context_attribute_value {
2706 const ENCODING: Encoding = Encoding::Union(
2707 "cssm_context_attribute_value",
2708 &[
2709 <*mut c_char>::ENCODING,
2710 <uint32>::ENCODING,
2711 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
2712 <CSSM_KEY_PTR>::ENCODING,
2713 <CSSM_DATA_PTR>::ENCODING,
2714 <CSSM_PADDING>::ENCODING,
2715 <CSSM_DATE_PTR>::ENCODING,
2716 <CSSM_RANGE_PTR>::ENCODING,
2717 <CSSM_CRYPTO_DATA_PTR>::ENCODING,
2718 <CSSM_VERSION_PTR>::ENCODING,
2719 <CSSM_DL_DB_HANDLE_PTR>::ENCODING,
2720 <*mut cssm_kr_profile>::ENCODING,
2721 ],
2722 );
2723}
2724
2725#[cfg(all(
2726 feature = "SecAsn1Types",
2727 feature = "cssmconfig",
2728 feature = "cssmkrapi",
2729 feature = "objc2"
2730))]
2731unsafe impl RefEncode for cssm_context_attribute_value {
2732 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2733}
2734
2735#[cfg(all(
2737 feature = "SecAsn1Types",
2738 feature = "cssmconfig",
2739 feature = "cssmkrapi"
2740))]
2741#[deprecated]
2742#[repr(C)]
2743#[derive(Clone, Copy)]
2744pub struct cssm_context_attribute {
2745 pub AttributeType: CSSM_ATTRIBUTE_TYPE,
2746 pub AttributeLength: uint32,
2747 pub Attribute: cssm_context_attribute_value,
2748}
2749
2750#[cfg(all(
2751 feature = "SecAsn1Types",
2752 feature = "cssmconfig",
2753 feature = "cssmkrapi",
2754 feature = "objc2"
2755))]
2756unsafe impl Encode for cssm_context_attribute {
2757 const ENCODING: Encoding = Encoding::Struct(
2758 "cssm_context_attribute",
2759 &[
2760 <CSSM_ATTRIBUTE_TYPE>::ENCODING,
2761 <uint32>::ENCODING,
2762 <cssm_context_attribute_value>::ENCODING,
2763 ],
2764 );
2765}
2766
2767#[cfg(all(
2768 feature = "SecAsn1Types",
2769 feature = "cssmconfig",
2770 feature = "cssmkrapi",
2771 feature = "objc2"
2772))]
2773unsafe impl RefEncode for cssm_context_attribute {
2774 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2775}
2776
2777#[cfg(all(
2779 feature = "SecAsn1Types",
2780 feature = "cssmconfig",
2781 feature = "cssmkrapi"
2782))]
2783pub type CSSM_CONTEXT_ATTRIBUTE = cssm_context_attribute;
2784
2785#[cfg(all(
2787 feature = "SecAsn1Types",
2788 feature = "cssmconfig",
2789 feature = "cssmkrapi"
2790))]
2791pub type CSSM_CONTEXT_ATTRIBUTE_PTR = *mut cssm_context_attribute;
2792
2793#[cfg(all(
2795 feature = "SecAsn1Types",
2796 feature = "cssmconfig",
2797 feature = "cssmkrapi"
2798))]
2799#[deprecated]
2800#[repr(C)]
2801#[derive(Clone, Copy, Debug, PartialEq)]
2802pub struct cssm_context {
2803 pub ContextType: CSSM_CONTEXT_TYPE,
2804 pub AlgorithmType: CSSM_ALGORITHMS,
2805 pub NumberOfAttributes: uint32,
2806 pub ContextAttributes: CSSM_CONTEXT_ATTRIBUTE_PTR,
2807 pub CSPHandle: CSSM_CSP_HANDLE,
2808 pub Privileged: CSSM_BOOL,
2809 pub EncryptionProhibited: uint32,
2810 pub WorkFactor: uint32,
2811 pub Reserved: uint32,
2812}
2813
2814#[cfg(all(
2815 feature = "SecAsn1Types",
2816 feature = "cssmconfig",
2817 feature = "cssmkrapi",
2818 feature = "objc2"
2819))]
2820unsafe impl Encode for cssm_context {
2821 const ENCODING: Encoding = Encoding::Struct(
2822 "cssm_context",
2823 &[
2824 <CSSM_CONTEXT_TYPE>::ENCODING,
2825 <CSSM_ALGORITHMS>::ENCODING,
2826 <uint32>::ENCODING,
2827 <CSSM_CONTEXT_ATTRIBUTE_PTR>::ENCODING,
2828 <CSSM_CSP_HANDLE>::ENCODING,
2829 <CSSM_BOOL>::ENCODING,
2830 <uint32>::ENCODING,
2831 <uint32>::ENCODING,
2832 <uint32>::ENCODING,
2833 ],
2834 );
2835}
2836
2837#[cfg(all(
2838 feature = "SecAsn1Types",
2839 feature = "cssmconfig",
2840 feature = "cssmkrapi",
2841 feature = "objc2"
2842))]
2843unsafe impl RefEncode for cssm_context {
2844 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2845}
2846
2847#[cfg(all(
2849 feature = "SecAsn1Types",
2850 feature = "cssmconfig",
2851 feature = "cssmkrapi"
2852))]
2853pub type CSSM_CONTEXT = cssm_context;
2854
2855#[cfg(all(
2857 feature = "SecAsn1Types",
2858 feature = "cssmconfig",
2859 feature = "cssmkrapi"
2860))]
2861pub type CSSM_CONTEXT_PTR = *mut cssm_context;
2862
2863#[cfg(feature = "cssmconfig")]
2865pub type CSSM_SC_FLAGS = uint32;
2866
2867pub const CSSM_CSP_TOK_RNG: c_uint = 1;
2869pub const CSSM_CSP_TOK_CLOCK_EXISTS: c_uint = 64;
2871
2872#[cfg(feature = "cssmconfig")]
2874pub type CSSM_CSP_READER_FLAGS = uint32;
2875
2876pub const CSSM_CSP_RDR_TOKENPRESENT: c_uint = 1;
2878pub const CSSM_CSP_RDR_EXISTS: c_uint = 2;
2880pub const CSSM_CSP_RDR_HW: c_uint = 4;
2882
2883#[cfg(feature = "cssmconfig")]
2885pub type CSSM_CSP_FLAGS = uint32;
2886
2887pub const CSSM_CSP_TOK_WRITE_PROTECTED: c_uint = 2;
2889pub const CSSM_CSP_TOK_LOGIN_REQUIRED: c_uint = 4;
2891pub const CSSM_CSP_TOK_USER_PIN_INITIALIZED: c_uint = 8;
2893pub const CSSM_CSP_TOK_PROT_AUTHENTICATION: c_uint = 256;
2895pub const CSSM_CSP_TOK_USER_PIN_EXPIRED: c_uint = 1048576;
2897pub const CSSM_CSP_TOK_SESSION_KEY_PASSWORD: c_uint = 2097152;
2899pub const CSSM_CSP_TOK_PRIVATE_KEY_PASSWORD: c_uint = 4194304;
2901pub const CSSM_CSP_STORES_PRIVATE_KEYS: c_uint = 16777216;
2903pub const CSSM_CSP_STORES_PUBLIC_KEYS: c_uint = 33554432;
2905pub const CSSM_CSP_STORES_SESSION_KEYS: c_uint = 67108864;
2907pub const CSSM_CSP_STORES_CERTIFICATES: c_uint = 134217728;
2909pub const CSSM_CSP_STORES_GENERIC: c_uint = 268435456;
2911
2912#[cfg(feature = "cssmconfig")]
2914pub type CSSM_PKCS_OAEP_MGF = uint32;
2915
2916pub const CSSM_PKCS_OAEP_MGF_NONE: c_uint = 0;
2918pub const CSSM_PKCS_OAEP_MGF1_SHA1: c_uint = 1;
2920pub const CSSM_PKCS_OAEP_MGF1_MD5: c_uint = 2;
2922
2923#[cfg(feature = "cssmconfig")]
2925pub type CSSM_PKCS_OAEP_PSOURCE = uint32;
2926
2927pub const CSSM_PKCS_OAEP_PSOURCE_NONE: c_uint = 0;
2929pub const CSSM_PKCS_OAEP_PSOURCE_Pspecified: c_uint = 1;
2931
2932#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2934#[deprecated]
2935#[repr(C)]
2936#[derive(Clone, Copy, Debug, PartialEq)]
2937pub struct cssm_pkcs1_oaep_params {
2938 pub HashAlgorithm: uint32,
2939 pub HashParams: SecAsn1Item,
2940 pub MGF: CSSM_PKCS_OAEP_MGF,
2941 pub MGFParams: SecAsn1Item,
2942 pub PSource: CSSM_PKCS_OAEP_PSOURCE,
2943 pub PSourceParams: SecAsn1Item,
2944}
2945
2946#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
2947unsafe impl Encode for cssm_pkcs1_oaep_params {
2948 const ENCODING: Encoding = Encoding::Struct(
2949 "cssm_pkcs1_oaep_params",
2950 &[
2951 <uint32>::ENCODING,
2952 <SecAsn1Item>::ENCODING,
2953 <CSSM_PKCS_OAEP_MGF>::ENCODING,
2954 <SecAsn1Item>::ENCODING,
2955 <CSSM_PKCS_OAEP_PSOURCE>::ENCODING,
2956 <SecAsn1Item>::ENCODING,
2957 ],
2958 );
2959}
2960
2961#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
2962unsafe impl RefEncode for cssm_pkcs1_oaep_params {
2963 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2964}
2965
2966#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2968pub type CSSM_PKCS1_OAEP_PARAMS = cssm_pkcs1_oaep_params;
2969
2970#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2972pub type CSSM_PKCS1_OAEP_PARAMS_PTR = *mut cssm_pkcs1_oaep_params;
2973
2974#[cfg(feature = "cssmconfig")]
2976#[repr(C)]
2977#[derive(Clone, Copy, Debug, PartialEq)]
2978pub struct cssm_csp_operational_statistics {
2979 pub UserAuthenticated: CSSM_BOOL,
2980 pub DeviceFlags: CSSM_CSP_FLAGS,
2981 pub TokenMaxSessionCount: uint32,
2982 pub TokenOpenedSessionCount: uint32,
2983 pub TokenMaxRWSessionCount: uint32,
2984 pub TokenOpenedRWSessionCount: uint32,
2985 pub TokenTotalPublicMem: uint32,
2986 pub TokenFreePublicMem: uint32,
2987 pub TokenTotalPrivateMem: uint32,
2988 pub TokenFreePrivateMem: uint32,
2989}
2990
2991#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2992unsafe impl Encode for cssm_csp_operational_statistics {
2993 const ENCODING: Encoding = Encoding::Struct(
2994 "cssm_csp_operational_statistics",
2995 &[
2996 <CSSM_BOOL>::ENCODING,
2997 <CSSM_CSP_FLAGS>::ENCODING,
2998 <uint32>::ENCODING,
2999 <uint32>::ENCODING,
3000 <uint32>::ENCODING,
3001 <uint32>::ENCODING,
3002 <uint32>::ENCODING,
3003 <uint32>::ENCODING,
3004 <uint32>::ENCODING,
3005 <uint32>::ENCODING,
3006 ],
3007 );
3008}
3009
3010#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3011unsafe impl RefEncode for cssm_csp_operational_statistics {
3012 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3013}
3014
3015#[cfg(feature = "cssmconfig")]
3017pub type CSSM_CSP_OPERATIONAL_STATISTICS = cssm_csp_operational_statistics;
3018
3019#[cfg(feature = "cssmconfig")]
3021pub type CSSM_CSP_OPERATIONAL_STATISTICS_PTR = *mut cssm_csp_operational_statistics;
3022
3023pub const CSSM_VALUE_NOT_AVAILABLE: c_int = -1;
3025
3026#[cfg(feature = "SecAsn1Types")]
3028#[deprecated]
3029#[repr(C)]
3030#[derive(Clone, Copy, Debug, PartialEq)]
3031pub struct cssm_pkcs5_pbkdf1_params {
3032 pub Passphrase: SecAsn1Item,
3033 pub InitVector: SecAsn1Item,
3034}
3035
3036#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3037unsafe impl Encode for cssm_pkcs5_pbkdf1_params {
3038 const ENCODING: Encoding = Encoding::Struct(
3039 "cssm_pkcs5_pbkdf1_params",
3040 &[<SecAsn1Item>::ENCODING, <SecAsn1Item>::ENCODING],
3041 );
3042}
3043
3044#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3045unsafe impl RefEncode for cssm_pkcs5_pbkdf1_params {
3046 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3047}
3048
3049#[cfg(feature = "SecAsn1Types")]
3051pub type CSSM_PKCS5_PBKDF1_PARAMS = cssm_pkcs5_pbkdf1_params;
3052
3053#[cfg(feature = "SecAsn1Types")]
3055pub type CSSM_PKCS5_PBKDF1_PARAMS_PTR = *mut cssm_pkcs5_pbkdf1_params;
3056
3057#[cfg(feature = "cssmconfig")]
3059pub type CSSM_PKCS5_PBKDF2_PRF = uint32;
3060
3061pub const CSSM_PKCS5_PBKDF2_PRF_HMAC_SHA1: c_uint = 0;
3063
3064#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3066#[deprecated]
3067#[repr(C)]
3068#[derive(Clone, Copy, Debug, PartialEq)]
3069pub struct cssm_pkcs5_pbkdf2_params {
3070 pub Passphrase: SecAsn1Item,
3071 pub PseudoRandomFunction: CSSM_PKCS5_PBKDF2_PRF,
3072}
3073
3074#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3075unsafe impl Encode for cssm_pkcs5_pbkdf2_params {
3076 const ENCODING: Encoding = Encoding::Struct(
3077 "cssm_pkcs5_pbkdf2_params",
3078 &[<SecAsn1Item>::ENCODING, <CSSM_PKCS5_PBKDF2_PRF>::ENCODING],
3079 );
3080}
3081
3082#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3083unsafe impl RefEncode for cssm_pkcs5_pbkdf2_params {
3084 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3085}
3086
3087#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3089pub type CSSM_PKCS5_PBKDF2_PARAMS = cssm_pkcs5_pbkdf2_params;
3090
3091#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3093pub type CSSM_PKCS5_PBKDF2_PARAMS_PTR = *mut cssm_pkcs5_pbkdf2_params;
3094
3095#[cfg(feature = "SecAsn1Types")]
3097#[deprecated]
3098#[repr(C)]
3099#[derive(Clone, Copy, Debug, PartialEq)]
3100pub struct cssm_kea_derive_params {
3101 pub Rb: SecAsn1Item,
3102 pub Yb: SecAsn1Item,
3103}
3104
3105#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3106unsafe impl Encode for cssm_kea_derive_params {
3107 const ENCODING: Encoding = Encoding::Struct(
3108 "cssm_kea_derive_params",
3109 &[<SecAsn1Item>::ENCODING, <SecAsn1Item>::ENCODING],
3110 );
3111}
3112
3113#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3114unsafe impl RefEncode for cssm_kea_derive_params {
3115 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3116}
3117
3118#[cfg(feature = "SecAsn1Types")]
3120pub type CSSM_KEA_DERIVE_PARAMS = cssm_kea_derive_params;
3121
3122#[cfg(feature = "SecAsn1Types")]
3124pub type CSSM_KEA_DERIVE_PARAMS_PTR = *mut cssm_kea_derive_params;
3125
3126#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3128#[deprecated]
3129#[repr(C)]
3130#[derive(Clone, Copy, Debug, PartialEq)]
3131pub struct cssm_tp_authority_id {
3132 pub AuthorityCert: *mut SecAsn1Item,
3133 pub AuthorityLocation: CSSM_NET_ADDRESS_PTR,
3134}
3135
3136#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3137unsafe impl Encode for cssm_tp_authority_id {
3138 const ENCODING: Encoding = Encoding::Struct(
3139 "cssm_tp_authority_id",
3140 &[
3141 <*mut SecAsn1Item>::ENCODING,
3142 <CSSM_NET_ADDRESS_PTR>::ENCODING,
3143 ],
3144 );
3145}
3146
3147#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3148unsafe impl RefEncode for cssm_tp_authority_id {
3149 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3150}
3151
3152#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3154pub type CSSM_TP_AUTHORITY_ID = cssm_tp_authority_id;
3155
3156#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3158pub type CSSM_TP_AUTHORITY_ID_PTR = *mut cssm_tp_authority_id;
3159
3160#[cfg(feature = "cssmconfig")]
3162pub type CSSM_TP_AUTHORITY_REQUEST_TYPE = uint32;
3163
3164#[cfg(feature = "cssmconfig")]
3166pub type CSSM_TP_AUTHORITY_REQUEST_TYPE_PTR = *mut uint32;
3167
3168pub const CSSM_TP_AUTHORITY_REQUEST_CERTISSUE: c_uint = 1;
3170pub const CSSM_TP_AUTHORITY_REQUEST_CERTREVOKE: c_uint = 2;
3172pub const CSSM_TP_AUTHORITY_REQUEST_CERTSUSPEND: c_uint = 3;
3174pub const CSSM_TP_AUTHORITY_REQUEST_CERTRESUME: c_uint = 4;
3176pub const CSSM_TP_AUTHORITY_REQUEST_CERTVERIFY: c_uint = 5;
3178pub const CSSM_TP_AUTHORITY_REQUEST_CERTNOTARIZE: c_uint = 6;
3180pub const CSSM_TP_AUTHORITY_REQUEST_CERTUSERECOVER: c_uint = 7;
3182pub const CSSM_TP_AUTHORITY_REQUEST_CRLISSUE: c_uint = 256;
3184
3185#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3187pub type CSSM_TP_VERIFICATION_RESULTS_CALLBACK = Option<
3188 unsafe extern "C-unwind" fn(CSSM_MODULE_HANDLE, *mut c_void, CSSM_DATA_PTR) -> CSSM_RETURN,
3189>;
3190
3191#[cfg(feature = "SecAsn1Types")]
3193pub type CSSM_OID_PTR = *mut SecAsn1Oid;
3194
3195#[cfg(feature = "SecAsn1Types")]
3197#[deprecated]
3198#[repr(C)]
3199#[derive(Clone, Copy, Debug, PartialEq)]
3200pub struct cssm_field {
3201 pub FieldOid: SecAsn1Oid,
3202 pub FieldValue: SecAsn1Item,
3203}
3204
3205#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3206unsafe impl Encode for cssm_field {
3207 const ENCODING: Encoding = Encoding::Struct(
3208 "cssm_field",
3209 &[<SecAsn1Oid>::ENCODING, <SecAsn1Item>::ENCODING],
3210 );
3211}
3212
3213#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3214unsafe impl RefEncode for cssm_field {
3215 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3216}
3217
3218#[cfg(feature = "SecAsn1Types")]
3220pub type CSSM_FIELD = cssm_field;
3221
3222#[cfg(feature = "SecAsn1Types")]
3224pub type CSSM_FIELD_PTR = *mut cssm_field;
3225
3226#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3228#[deprecated]
3229#[repr(C)]
3230#[derive(Clone, Copy, Debug, PartialEq)]
3231pub struct cssm_tp_policyinfo {
3232 pub NumberOfPolicyIds: uint32,
3233 pub PolicyIds: CSSM_FIELD_PTR,
3234 pub PolicyControl: *mut c_void,
3235}
3236
3237#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3238unsafe impl Encode for cssm_tp_policyinfo {
3239 const ENCODING: Encoding = Encoding::Struct(
3240 "cssm_tp_policyinfo",
3241 &[
3242 <uint32>::ENCODING,
3243 <CSSM_FIELD_PTR>::ENCODING,
3244 <*mut c_void>::ENCODING,
3245 ],
3246 );
3247}
3248
3249#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3250unsafe impl RefEncode for cssm_tp_policyinfo {
3251 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3252}
3253
3254#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3256pub type CSSM_TP_POLICYINFO = cssm_tp_policyinfo;
3257
3258#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3260pub type CSSM_TP_POLICYINFO_PTR = *mut cssm_tp_policyinfo;
3261
3262#[cfg(feature = "cssmconfig")]
3264pub type CSSM_TP_SERVICES = uint32;
3265
3266pub const CSSM_TP_KEY_ARCHIVE: c_uint = 1;
3268pub const CSSM_TP_CERT_PUBLISH: c_uint = 2;
3270pub const CSSM_TP_CERT_NOTIFY_RENEW: c_uint = 4;
3272pub const CSSM_TP_CERT_DIR_UPDATE: c_uint = 8;
3274pub const CSSM_TP_CRL_DISTRIBUTE: c_uint = 16;
3276
3277#[cfg(feature = "cssmconfig")]
3279pub type CSSM_TP_ACTION = uint32;
3280
3281pub const CSSM_TP_ACTION_DEFAULT: c_uint = 0;
3283
3284#[cfg(feature = "cssmconfig")]
3286pub type CSSM_TP_STOP_ON = uint32;
3287
3288pub const CSSM_TP_STOP_ON_POLICY: c_uint = 0;
3290pub const CSSM_TP_STOP_ON_NONE: c_uint = 1;
3292pub const CSSM_TP_STOP_ON_FIRST_PASS: c_uint = 2;
3294pub const CSSM_TP_STOP_ON_FIRST_FAIL: c_uint = 3;
3296
3297pub type CSSM_TIMESTRING = *mut c_char;
3299
3300#[cfg(feature = "cssmconfig")]
3302#[deprecated]
3303#[repr(C)]
3304#[derive(Clone, Copy, Debug, PartialEq)]
3305pub struct cssm_dl_db_list {
3306 pub NumHandles: uint32,
3307 pub DLDBHandle: CSSM_DL_DB_HANDLE_PTR,
3308}
3309
3310#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3311unsafe impl Encode for cssm_dl_db_list {
3312 const ENCODING: Encoding = Encoding::Struct(
3313 "cssm_dl_db_list",
3314 &[<uint32>::ENCODING, <CSSM_DL_DB_HANDLE_PTR>::ENCODING],
3315 );
3316}
3317
3318#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3319unsafe impl RefEncode for cssm_dl_db_list {
3320 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3321}
3322
3323#[cfg(feature = "cssmconfig")]
3325pub type CSSM_DL_DB_LIST = cssm_dl_db_list;
3326
3327#[cfg(feature = "cssmconfig")]
3329pub type CSSM_DL_DB_LIST_PTR = *mut cssm_dl_db_list;
3330
3331#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3333#[deprecated]
3334#[repr(C)]
3335#[derive(Clone, Copy, Debug, PartialEq)]
3336pub struct cssm_tp_callerauth_context {
3337 pub Policy: CSSM_TP_POLICYINFO,
3338 pub VerifyTime: CSSM_TIMESTRING,
3339 pub VerificationAbortOn: CSSM_TP_STOP_ON,
3340 pub CallbackWithVerifiedCert: CSSM_TP_VERIFICATION_RESULTS_CALLBACK,
3341 pub NumberOfAnchorCerts: uint32,
3342 pub AnchorCerts: CSSM_DATA_PTR,
3343 pub DBList: CSSM_DL_DB_LIST_PTR,
3344 pub CallerCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
3345}
3346
3347#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3348unsafe impl Encode for cssm_tp_callerauth_context {
3349 const ENCODING: Encoding = Encoding::Struct(
3350 "cssm_tp_callerauth_context",
3351 &[
3352 <CSSM_TP_POLICYINFO>::ENCODING,
3353 <CSSM_TIMESTRING>::ENCODING,
3354 <CSSM_TP_STOP_ON>::ENCODING,
3355 <CSSM_TP_VERIFICATION_RESULTS_CALLBACK>::ENCODING,
3356 <uint32>::ENCODING,
3357 <CSSM_DATA_PTR>::ENCODING,
3358 <CSSM_DL_DB_LIST_PTR>::ENCODING,
3359 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
3360 ],
3361 );
3362}
3363
3364#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3365unsafe impl RefEncode for cssm_tp_callerauth_context {
3366 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3367}
3368
3369#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3371pub type CSSM_TP_CALLERAUTH_CONTEXT = cssm_tp_callerauth_context;
3372
3373#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3375pub type CSSM_TP_CALLERAUTH_CONTEXT_PTR = *mut cssm_tp_callerauth_context;
3376
3377#[cfg(feature = "cssmconfig")]
3379pub type CSSM_CRL_PARSE_FORMAT = uint32;
3380
3381#[cfg(feature = "cssmconfig")]
3383pub type CSSM_CRL_PARSE_FORMAT_PTR = *mut uint32;
3384
3385pub const CSSM_CRL_PARSE_FORMAT_NONE: c_uint = 0;
3387pub const CSSM_CRL_PARSE_FORMAT_CUSTOM: c_uint = 1;
3389pub const CSSM_CRL_PARSE_FORMAT_SEXPR: c_uint = 2;
3391pub const CSSM_CRL_PARSE_FORMAT_COMPLEX: c_uint = 3;
3393pub const CSSM_CRL_PARSE_FORMAT_OID_NAMED: c_uint = 4;
3395pub const CSSM_CRL_PARSE_FORMAT_TUPLE: c_uint = 5;
3397pub const CSSM_CRL_PARSE_FORMAT_MULTIPLE: c_uint = 32766;
3399pub const CSSM_CRL_PARSE_FORMAT_LAST: c_uint = 32767;
3401pub const CSSM_CL_CUSTOM_CRL_PARSE_FORMAT: c_uint = 32768;
3403
3404#[cfg(feature = "cssmconfig")]
3406pub type CSSM_CRL_TYPE = uint32;
3407
3408#[cfg(feature = "cssmconfig")]
3410pub type CSSM_CRL_TYPE_PTR = *mut uint32;
3411
3412pub const CSSM_CRL_TYPE_UNKNOWN: c_uint = 0;
3414pub const CSSM_CRL_TYPE_X_509v1: c_uint = 1;
3416pub const CSSM_CRL_TYPE_X_509v2: c_uint = 2;
3418pub const CSSM_CRL_TYPE_SPKI: c_uint = 3;
3420pub const CSSM_CRL_TYPE_MULTIPLE: c_uint = 32766;
3422
3423#[cfg(feature = "cssmconfig")]
3425pub type CSSM_CRL_ENCODING = uint32;
3426
3427#[cfg(feature = "cssmconfig")]
3429pub type CSSM_CRL_ENCODING_PTR = *mut uint32;
3430
3431pub const CSSM_CRL_ENCODING_UNKNOWN: c_uint = 0;
3433pub const CSSM_CRL_ENCODING_CUSTOM: c_uint = 1;
3435pub const CSSM_CRL_ENCODING_BER: c_uint = 2;
3437pub const CSSM_CRL_ENCODING_DER: c_uint = 3;
3439pub const CSSM_CRL_ENCODING_BLOOM: c_uint = 4;
3441pub const CSSM_CRL_ENCODING_SEXPR: c_uint = 5;
3443pub const CSSM_CRL_ENCODING_MULTIPLE: c_uint = 32766;
3445
3446#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3448#[deprecated]
3449#[repr(C)]
3450#[derive(Clone, Copy, Debug, PartialEq)]
3451pub struct cssm_encoded_crl {
3452 pub CrlType: CSSM_CRL_TYPE,
3453 pub CrlEncoding: CSSM_CRL_ENCODING,
3454 pub CrlBlob: SecAsn1Item,
3455}
3456
3457#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3458unsafe impl Encode for cssm_encoded_crl {
3459 const ENCODING: Encoding = Encoding::Struct(
3460 "cssm_encoded_crl",
3461 &[
3462 <CSSM_CRL_TYPE>::ENCODING,
3463 <CSSM_CRL_ENCODING>::ENCODING,
3464 <SecAsn1Item>::ENCODING,
3465 ],
3466 );
3467}
3468
3469#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3470unsafe impl RefEncode for cssm_encoded_crl {
3471 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3472}
3473
3474#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3476pub type CSSM_ENCODED_CRL = cssm_encoded_crl;
3477
3478#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3480pub type CSSM_ENCODED_CRL_PTR = *mut cssm_encoded_crl;
3481
3482#[cfg(feature = "cssmconfig")]
3484#[repr(C)]
3485#[derive(Clone, Copy, Debug, PartialEq)]
3486pub struct cssm_parsed_crl {
3487 pub CrlType: CSSM_CRL_TYPE,
3488 pub ParsedCrlFormat: CSSM_CRL_PARSE_FORMAT,
3489 pub ParsedCrl: *mut c_void,
3490}
3491
3492#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3493unsafe impl Encode for cssm_parsed_crl {
3494 const ENCODING: Encoding = Encoding::Struct(
3495 "cssm_parsed_crl",
3496 &[
3497 <CSSM_CRL_TYPE>::ENCODING,
3498 <CSSM_CRL_PARSE_FORMAT>::ENCODING,
3499 <*mut c_void>::ENCODING,
3500 ],
3501 );
3502}
3503
3504#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3505unsafe impl RefEncode for cssm_parsed_crl {
3506 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3507}
3508
3509#[cfg(feature = "cssmconfig")]
3511pub type CSSM_PARSED_CRL = cssm_parsed_crl;
3512
3513#[cfg(feature = "cssmconfig")]
3515pub type CSSM_PARSED_CRL_PTR = *mut cssm_parsed_crl;
3516
3517#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3519#[deprecated]
3520#[repr(C)]
3521#[derive(Clone, Copy, Debug, PartialEq)]
3522pub struct cssm_crl_pair {
3523 pub EncodedCrl: CSSM_ENCODED_CRL,
3524 pub ParsedCrl: CSSM_PARSED_CRL,
3525}
3526
3527#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3528unsafe impl Encode for cssm_crl_pair {
3529 const ENCODING: Encoding = Encoding::Struct(
3530 "cssm_crl_pair",
3531 &[<CSSM_ENCODED_CRL>::ENCODING, <CSSM_PARSED_CRL>::ENCODING],
3532 );
3533}
3534
3535#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3536unsafe impl RefEncode for cssm_crl_pair {
3537 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3538}
3539
3540#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3542pub type CSSM_CRL_PAIR = cssm_crl_pair;
3543
3544#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3546pub type CSSM_CRL_PAIR_PTR = *mut cssm_crl_pair;
3547
3548#[cfg(feature = "cssmconfig")]
3550pub type CSSM_CRLGROUP_TYPE = uint32;
3551
3552#[cfg(feature = "cssmconfig")]
3554pub type CSSM_CRLGROUP_TYPE_PTR = *mut uint32;
3555
3556pub const CSSM_CRLGROUP_DATA: c_uint = 0;
3558pub const CSSM_CRLGROUP_ENCODED_CRL: c_uint = 1;
3560pub const CSSM_CRLGROUP_PARSED_CRL: c_uint = 2;
3562pub const CSSM_CRLGROUP_CRL_PAIR: c_uint = 3;
3564
3565#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3567#[repr(C)]
3568#[derive(Clone, Copy)]
3569pub union cssm_crlgroup_GroupCrlList {
3570 pub CrlList: CSSM_DATA_PTR,
3571 pub EncodedCrlList: CSSM_ENCODED_CRL_PTR,
3572 pub ParsedCrlList: CSSM_PARSED_CRL_PTR,
3573 pub PairCrlList: CSSM_CRL_PAIR_PTR,
3574}
3575
3576#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3577unsafe impl Encode for cssm_crlgroup_GroupCrlList {
3578 const ENCODING: Encoding = Encoding::Union(
3579 "?",
3580 &[
3581 <CSSM_DATA_PTR>::ENCODING,
3582 <CSSM_ENCODED_CRL_PTR>::ENCODING,
3583 <CSSM_PARSED_CRL_PTR>::ENCODING,
3584 <CSSM_CRL_PAIR_PTR>::ENCODING,
3585 ],
3586 );
3587}
3588
3589#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3590unsafe impl RefEncode for cssm_crlgroup_GroupCrlList {
3591 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3592}
3593
3594#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3596#[deprecated]
3597#[repr(C)]
3598#[derive(Clone, Copy)]
3599pub struct cssm_crlgroup {
3600 pub CrlType: CSSM_CRL_TYPE,
3601 pub CrlEncoding: CSSM_CRL_ENCODING,
3602 pub NumberOfCrls: uint32,
3603 pub GroupCrlList: cssm_crlgroup_GroupCrlList,
3604 pub CrlGroupType: CSSM_CRLGROUP_TYPE,
3605}
3606
3607#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3608unsafe impl Encode for cssm_crlgroup {
3609 const ENCODING: Encoding = Encoding::Struct(
3610 "cssm_crlgroup",
3611 &[
3612 <CSSM_CRL_TYPE>::ENCODING,
3613 <CSSM_CRL_ENCODING>::ENCODING,
3614 <uint32>::ENCODING,
3615 <cssm_crlgroup_GroupCrlList>::ENCODING,
3616 <CSSM_CRLGROUP_TYPE>::ENCODING,
3617 ],
3618 );
3619}
3620
3621#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3622unsafe impl RefEncode for cssm_crlgroup {
3623 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3624}
3625
3626#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3628pub type CSSM_CRLGROUP = cssm_crlgroup;
3629
3630#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3632pub type CSSM_CRLGROUP_PTR = *mut cssm_crlgroup;
3633
3634#[cfg(feature = "SecAsn1Types")]
3636#[deprecated]
3637#[repr(C)]
3638#[derive(Clone, Copy, Debug, PartialEq)]
3639pub struct cssm_fieldgroup {
3640 pub NumberOfFields: c_int,
3641 pub Fields: CSSM_FIELD_PTR,
3642}
3643
3644#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3645unsafe impl Encode for cssm_fieldgroup {
3646 const ENCODING: Encoding = Encoding::Struct(
3647 "cssm_fieldgroup",
3648 &[<c_int>::ENCODING, <CSSM_FIELD_PTR>::ENCODING],
3649 );
3650}
3651
3652#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3653unsafe impl RefEncode for cssm_fieldgroup {
3654 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3655}
3656
3657#[cfg(feature = "SecAsn1Types")]
3659pub type CSSM_FIELDGROUP = cssm_fieldgroup;
3660
3661#[cfg(feature = "SecAsn1Types")]
3663pub type CSSM_FIELDGROUP_PTR = *mut cssm_fieldgroup;
3664
3665#[cfg(feature = "cssmconfig")]
3667pub type CSSM_EVIDENCE_FORM = uint32;
3668
3669pub const CSSM_EVIDENCE_FORM_UNSPECIFIC: c_uint = 0;
3671pub const CSSM_EVIDENCE_FORM_CERT: c_uint = 1;
3673pub const CSSM_EVIDENCE_FORM_CRL: c_uint = 2;
3675pub const CSSM_EVIDENCE_FORM_CERT_ID: c_uint = 3;
3677pub const CSSM_EVIDENCE_FORM_CRL_ID: c_uint = 4;
3679pub const CSSM_EVIDENCE_FORM_VERIFIER_TIME: c_uint = 5;
3681pub const CSSM_EVIDENCE_FORM_CRL_THISTIME: c_uint = 6;
3683pub const CSSM_EVIDENCE_FORM_CRL_NEXTTIME: c_uint = 7;
3685pub const CSSM_EVIDENCE_FORM_POLICYINFO: c_uint = 8;
3687pub const CSSM_EVIDENCE_FORM_TUPLEGROUP: c_uint = 9;
3689
3690#[cfg(feature = "cssmconfig")]
3692#[deprecated]
3693#[repr(C)]
3694#[derive(Clone, Copy, Debug, PartialEq)]
3695pub struct cssm_evidence {
3696 pub EvidenceForm: CSSM_EVIDENCE_FORM,
3697 pub Evidence: *mut c_void,
3698}
3699
3700#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3701unsafe impl Encode for cssm_evidence {
3702 const ENCODING: Encoding = Encoding::Struct(
3703 "cssm_evidence",
3704 &[<CSSM_EVIDENCE_FORM>::ENCODING, <*mut c_void>::ENCODING],
3705 );
3706}
3707
3708#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3709unsafe impl RefEncode for cssm_evidence {
3710 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3711}
3712
3713#[cfg(feature = "cssmconfig")]
3715pub type CSSM_EVIDENCE = cssm_evidence;
3716
3717#[cfg(feature = "cssmconfig")]
3719pub type CSSM_EVIDENCE_PTR = *mut cssm_evidence;
3720
3721#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3723#[deprecated]
3724#[repr(C)]
3725#[derive(Clone, Copy)]
3726pub struct cssm_tp_verify_context {
3727 pub Action: CSSM_TP_ACTION,
3728 pub ActionData: SecAsn1Item,
3729 pub Crls: CSSM_CRLGROUP,
3730 pub Cred: CSSM_TP_CALLERAUTH_CONTEXT_PTR,
3731}
3732
3733#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3734unsafe impl Encode for cssm_tp_verify_context {
3735 const ENCODING: Encoding = Encoding::Struct(
3736 "cssm_tp_verify_context",
3737 &[
3738 <CSSM_TP_ACTION>::ENCODING,
3739 <SecAsn1Item>::ENCODING,
3740 <CSSM_CRLGROUP>::ENCODING,
3741 <CSSM_TP_CALLERAUTH_CONTEXT_PTR>::ENCODING,
3742 ],
3743 );
3744}
3745
3746#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3747unsafe impl RefEncode for cssm_tp_verify_context {
3748 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3749}
3750
3751#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3753pub type CSSM_TP_VERIFY_CONTEXT = cssm_tp_verify_context;
3754
3755#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3757pub type CSSM_TP_VERIFY_CONTEXT_PTR = *mut cssm_tp_verify_context;
3758
3759#[cfg(feature = "cssmconfig")]
3761#[deprecated]
3762#[repr(C)]
3763#[derive(Clone, Copy, Debug, PartialEq)]
3764pub struct cssm_tp_verify_context_result {
3765 pub NumberOfEvidences: uint32,
3766 pub Evidence: CSSM_EVIDENCE_PTR,
3767}
3768
3769#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3770unsafe impl Encode for cssm_tp_verify_context_result {
3771 const ENCODING: Encoding = Encoding::Struct(
3772 "cssm_tp_verify_context_result",
3773 &[<uint32>::ENCODING, <CSSM_EVIDENCE_PTR>::ENCODING],
3774 );
3775}
3776
3777#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3778unsafe impl RefEncode for cssm_tp_verify_context_result {
3779 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3780}
3781
3782#[cfg(feature = "cssmconfig")]
3784pub type CSSM_TP_VERIFY_CONTEXT_RESULT = cssm_tp_verify_context_result;
3785
3786#[cfg(feature = "cssmconfig")]
3788pub type CSSM_TP_VERIFY_CONTEXT_RESULT_PTR = *mut cssm_tp_verify_context_result;
3789
3790#[cfg(feature = "cssmconfig")]
3792#[deprecated]
3793#[repr(C)]
3794#[derive(Clone, Copy, Debug, PartialEq)]
3795pub struct cssm_tp_request_set {
3796 pub NumberOfRequests: uint32,
3797 pub Requests: *mut c_void,
3798}
3799
3800#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3801unsafe impl Encode for cssm_tp_request_set {
3802 const ENCODING: Encoding = Encoding::Struct(
3803 "cssm_tp_request_set",
3804 &[<uint32>::ENCODING, <*mut c_void>::ENCODING],
3805 );
3806}
3807
3808#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3809unsafe impl RefEncode for cssm_tp_request_set {
3810 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3811}
3812
3813#[cfg(feature = "cssmconfig")]
3815pub type CSSM_TP_REQUEST_SET = cssm_tp_request_set;
3816
3817#[cfg(feature = "cssmconfig")]
3819pub type CSSM_TP_REQUEST_SET_PTR = *mut cssm_tp_request_set;
3820
3821#[cfg(feature = "cssmconfig")]
3823#[repr(C)]
3824#[derive(Clone, Copy, Debug, PartialEq)]
3825pub struct cssm_tp_result_set {
3826 pub NumberOfResults: uint32,
3827 pub Results: *mut c_void,
3828}
3829
3830#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3831unsafe impl Encode for cssm_tp_result_set {
3832 const ENCODING: Encoding = Encoding::Struct(
3833 "cssm_tp_result_set",
3834 &[<uint32>::ENCODING, <*mut c_void>::ENCODING],
3835 );
3836}
3837
3838#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3839unsafe impl RefEncode for cssm_tp_result_set {
3840 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3841}
3842
3843#[cfg(feature = "cssmconfig")]
3845pub type CSSM_TP_RESULT_SET = cssm_tp_result_set;
3846
3847#[cfg(feature = "cssmconfig")]
3849pub type CSSM_TP_RESULT_SET_PTR = *mut cssm_tp_result_set;
3850
3851#[cfg(feature = "cssmconfig")]
3853pub type CSSM_TP_CONFIRM_STATUS = uint32;
3854
3855#[cfg(feature = "cssmconfig")]
3857pub type CSSM_TP_CONFIRM_STATUS_PTR = *mut uint32;
3858
3859pub const CSSM_TP_CONFIRM_STATUS_UNKNOWN: c_uint = 0;
3861pub const CSSM_TP_CONFIRM_ACCEPT: c_uint = 1;
3863pub const CSSM_TP_CONFIRM_REJECT: c_uint = 2;
3865
3866#[cfg(feature = "cssmconfig")]
3868#[deprecated]
3869#[repr(C)]
3870#[derive(Clone, Copy, Debug, PartialEq)]
3871pub struct cssm_tp_confirm_response {
3872 pub NumberOfResponses: uint32,
3873 pub Responses: CSSM_TP_CONFIRM_STATUS_PTR,
3874}
3875
3876#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3877unsafe impl Encode for cssm_tp_confirm_response {
3878 const ENCODING: Encoding = Encoding::Struct(
3879 "cssm_tp_confirm_response",
3880 &[<uint32>::ENCODING, <CSSM_TP_CONFIRM_STATUS_PTR>::ENCODING],
3881 );
3882}
3883
3884#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3885unsafe impl RefEncode for cssm_tp_confirm_response {
3886 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3887}
3888
3889#[cfg(feature = "cssmconfig")]
3891pub type CSSM_TP_CONFIRM_RESPONSE = cssm_tp_confirm_response;
3892
3893#[cfg(feature = "cssmconfig")]
3895pub type CSSM_TP_CONFIRM_RESPONSE_PTR = *mut cssm_tp_confirm_response;
3896
3897pub const CSSM_ESTIMATED_TIME_UNKNOWN: c_int = -1;
3899
3900pub const CSSM_ELAPSED_TIME_UNKNOWN: c_int = -1;
3902pub const CSSM_ELAPSED_TIME_COMPLETE: c_int = -2;
3904
3905#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3907#[deprecated]
3908#[repr(C)]
3909#[derive(Clone, Copy, Debug, PartialEq)]
3910pub struct cssm_tp_certissue_input {
3911 pub CSPSubserviceUid: CSSM_SUBSERVICE_UID,
3912 pub CLHandle: CSSM_CL_HANDLE,
3913 pub NumberOfTemplateFields: uint32,
3914 pub SubjectCertFields: CSSM_FIELD_PTR,
3915 pub MoreServiceRequests: CSSM_TP_SERVICES,
3916 pub NumberOfServiceControls: uint32,
3917 pub ServiceControls: CSSM_FIELD_PTR,
3918 pub UserCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
3919}
3920
3921#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3922unsafe impl Encode for cssm_tp_certissue_input {
3923 const ENCODING: Encoding = Encoding::Struct(
3924 "cssm_tp_certissue_input",
3925 &[
3926 <CSSM_SUBSERVICE_UID>::ENCODING,
3927 <CSSM_CL_HANDLE>::ENCODING,
3928 <uint32>::ENCODING,
3929 <CSSM_FIELD_PTR>::ENCODING,
3930 <CSSM_TP_SERVICES>::ENCODING,
3931 <uint32>::ENCODING,
3932 <CSSM_FIELD_PTR>::ENCODING,
3933 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
3934 ],
3935 );
3936}
3937
3938#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3939unsafe impl RefEncode for cssm_tp_certissue_input {
3940 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3941}
3942
3943#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3945pub type CSSM_TP_CERTISSUE_INPUT = cssm_tp_certissue_input;
3946
3947#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3949pub type CSSM_TP_CERTISSUE_INPUT_PTR = *mut cssm_tp_certissue_input;
3950
3951#[cfg(feature = "cssmconfig")]
3953pub type CSSM_TP_CERTISSUE_STATUS = uint32;
3954
3955pub const CSSM_TP_CERTISSUE_STATUS_UNKNOWN: c_uint = 0;
3957pub const CSSM_TP_CERTISSUE_OK: c_uint = 1;
3959pub const CSSM_TP_CERTISSUE_OKWITHCERTMODS: c_uint = 2;
3961pub const CSSM_TP_CERTISSUE_OKWITHSERVICEMODS: c_uint = 3;
3963pub const CSSM_TP_CERTISSUE_REJECTED: c_uint = 4;
3965pub const CSSM_TP_CERTISSUE_NOT_AUTHORIZED: c_uint = 5;
3967pub const CSSM_TP_CERTISSUE_WILL_BE_REVOKED: c_uint = 6;
3969
3970#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3972#[deprecated]
3973#[repr(C)]
3974#[derive(Clone, Copy, Debug, PartialEq)]
3975pub struct cssm_tp_certissue_output {
3976 pub IssueStatus: CSSM_TP_CERTISSUE_STATUS,
3977 pub CertGroup: CSSM_CERTGROUP_PTR,
3978 pub PerformedServiceRequests: CSSM_TP_SERVICES,
3979}
3980
3981#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3982unsafe impl Encode for cssm_tp_certissue_output {
3983 const ENCODING: Encoding = Encoding::Struct(
3984 "cssm_tp_certissue_output",
3985 &[
3986 <CSSM_TP_CERTISSUE_STATUS>::ENCODING,
3987 <CSSM_CERTGROUP_PTR>::ENCODING,
3988 <CSSM_TP_SERVICES>::ENCODING,
3989 ],
3990 );
3991}
3992
3993#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3994unsafe impl RefEncode for cssm_tp_certissue_output {
3995 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3996}
3997
3998#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4000pub type CSSM_TP_CERTISSUE_OUTPUT = cssm_tp_certissue_output;
4001
4002#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4004pub type CSSM_TP_CERTISSUE_OUTPUT_PTR = *mut cssm_tp_certissue_output;
4005
4006#[cfg(feature = "cssmconfig")]
4008pub type CSSM_TP_CERTCHANGE_ACTION = uint32;
4009
4010pub const CSSM_TP_CERTCHANGE_NONE: c_uint = 0;
4012pub const CSSM_TP_CERTCHANGE_REVOKE: c_uint = 1;
4014pub const CSSM_TP_CERTCHANGE_HOLD: c_uint = 2;
4016pub const CSSM_TP_CERTCHANGE_RELEASE: c_uint = 3;
4018
4019#[cfg(feature = "cssmconfig")]
4021pub type CSSM_TP_CERTCHANGE_REASON = uint32;
4022
4023pub const CSSM_TP_CERTCHANGE_REASON_UNKNOWN: c_uint = 0;
4025pub const CSSM_TP_CERTCHANGE_REASON_KEYCOMPROMISE: c_uint = 1;
4027pub const CSSM_TP_CERTCHANGE_REASON_CACOMPROMISE: c_uint = 2;
4029pub const CSSM_TP_CERTCHANGE_REASON_CEASEOPERATION: c_uint = 3;
4031pub const CSSM_TP_CERTCHANGE_REASON_AFFILIATIONCHANGE: c_uint = 4;
4033pub const CSSM_TP_CERTCHANGE_REASON_SUPERCEDED: c_uint = 5;
4035pub const CSSM_TP_CERTCHANGE_REASON_SUSPECTEDCOMPROMISE: c_uint = 6;
4037pub const CSSM_TP_CERTCHANGE_REASON_HOLDRELEASE: c_uint = 7;
4039
4040#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4042#[deprecated]
4043#[repr(C)]
4044#[derive(Clone, Copy, Debug, PartialEq)]
4045pub struct cssm_tp_certchange_input {
4046 pub Action: CSSM_TP_CERTCHANGE_ACTION,
4047 pub Reason: CSSM_TP_CERTCHANGE_REASON,
4048 pub CLHandle: CSSM_CL_HANDLE,
4049 pub Cert: CSSM_DATA_PTR,
4050 pub ChangeInfo: CSSM_FIELD_PTR,
4051 pub StartTime: CSSM_TIMESTRING,
4052 pub CallerCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4053}
4054
4055#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4056unsafe impl Encode for cssm_tp_certchange_input {
4057 const ENCODING: Encoding = Encoding::Struct(
4058 "cssm_tp_certchange_input",
4059 &[
4060 <CSSM_TP_CERTCHANGE_ACTION>::ENCODING,
4061 <CSSM_TP_CERTCHANGE_REASON>::ENCODING,
4062 <CSSM_CL_HANDLE>::ENCODING,
4063 <CSSM_DATA_PTR>::ENCODING,
4064 <CSSM_FIELD_PTR>::ENCODING,
4065 <CSSM_TIMESTRING>::ENCODING,
4066 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4067 ],
4068 );
4069}
4070
4071#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4072unsafe impl RefEncode for cssm_tp_certchange_input {
4073 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4074}
4075
4076#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4078pub type CSSM_TP_CERTCHANGE_INPUT = cssm_tp_certchange_input;
4079
4080#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4082pub type CSSM_TP_CERTCHANGE_INPUT_PTR = *mut cssm_tp_certchange_input;
4083
4084#[cfg(feature = "cssmconfig")]
4086pub type CSSM_TP_CERTCHANGE_STATUS = uint32;
4087
4088pub const CSSM_TP_CERTCHANGE_STATUS_UNKNOWN: c_uint = 0;
4090pub const CSSM_TP_CERTCHANGE_OK: c_uint = 1;
4092pub const CSSM_TP_CERTCHANGE_OKWITHNEWTIME: c_uint = 2;
4094pub const CSSM_TP_CERTCHANGE_WRONGCA: c_uint = 3;
4096pub const CSSM_TP_CERTCHANGE_REJECTED: c_uint = 4;
4098pub const CSSM_TP_CERTCHANGE_NOT_AUTHORIZED: c_uint = 5;
4100
4101#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4103#[deprecated]
4104#[repr(C)]
4105#[derive(Clone, Copy, Debug, PartialEq)]
4106pub struct cssm_tp_certchange_output {
4107 pub ActionStatus: CSSM_TP_CERTCHANGE_STATUS,
4108 pub RevokeInfo: CSSM_FIELD,
4109}
4110
4111#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4112unsafe impl Encode for cssm_tp_certchange_output {
4113 const ENCODING: Encoding = Encoding::Struct(
4114 "cssm_tp_certchange_output",
4115 &[
4116 <CSSM_TP_CERTCHANGE_STATUS>::ENCODING,
4117 <CSSM_FIELD>::ENCODING,
4118 ],
4119 );
4120}
4121
4122#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4123unsafe impl RefEncode for cssm_tp_certchange_output {
4124 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4125}
4126
4127#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4129pub type CSSM_TP_CERTCHANGE_OUTPUT = cssm_tp_certchange_output;
4130
4131#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4133pub type CSSM_TP_CERTCHANGE_OUTPUT_PTR = *mut cssm_tp_certchange_output;
4134
4135#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4137#[deprecated]
4138#[repr(C)]
4139#[derive(Clone, Copy, Debug, PartialEq)]
4140pub struct cssm_tp_certverify_input {
4141 pub CLHandle: CSSM_CL_HANDLE,
4142 pub Cert: CSSM_DATA_PTR,
4143 pub VerifyContext: CSSM_TP_VERIFY_CONTEXT_PTR,
4144}
4145
4146#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4147unsafe impl Encode for cssm_tp_certverify_input {
4148 const ENCODING: Encoding = Encoding::Struct(
4149 "cssm_tp_certverify_input",
4150 &[
4151 <CSSM_CL_HANDLE>::ENCODING,
4152 <CSSM_DATA_PTR>::ENCODING,
4153 <CSSM_TP_VERIFY_CONTEXT_PTR>::ENCODING,
4154 ],
4155 );
4156}
4157
4158#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4159unsafe impl RefEncode for cssm_tp_certverify_input {
4160 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4161}
4162
4163#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4165pub type CSSM_TP_CERTVERIFY_INPUT = cssm_tp_certverify_input;
4166
4167#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4169pub type CSSM_TP_CERTVERIFY_INPUT_PTR = *mut cssm_tp_certverify_input;
4170
4171#[cfg(feature = "cssmconfig")]
4173pub type CSSM_TP_CERTVERIFY_STATUS = uint32;
4174
4175pub const CSSM_TP_CERTVERIFY_UNKNOWN: c_uint = 0;
4177pub const CSSM_TP_CERTVERIFY_VALID: c_uint = 1;
4179pub const CSSM_TP_CERTVERIFY_INVALID: c_uint = 2;
4181pub const CSSM_TP_CERTVERIFY_REVOKED: c_uint = 3;
4183pub const CSSM_TP_CERTVERIFY_SUSPENDED: c_uint = 4;
4185pub const CSSM_TP_CERTVERIFY_EXPIRED: c_uint = 5;
4187pub const CSSM_TP_CERTVERIFY_NOT_VALID_YET: c_uint = 6;
4189pub const CSSM_TP_CERTVERIFY_INVALID_AUTHORITY: c_uint = 7;
4191pub const CSSM_TP_CERTVERIFY_INVALID_SIGNATURE: c_uint = 8;
4193pub const CSSM_TP_CERTVERIFY_INVALID_CERT_VALUE: c_uint = 9;
4195pub const CSSM_TP_CERTVERIFY_INVALID_CERTGROUP: c_uint = 10;
4197pub const CSSM_TP_CERTVERIFY_INVALID_POLICY: c_uint = 11;
4199pub const CSSM_TP_CERTVERIFY_INVALID_POLICY_IDS: c_uint = 12;
4201pub const CSSM_TP_CERTVERIFY_INVALID_BASIC_CONSTRAINTS: c_uint = 13;
4203pub const CSSM_TP_CERTVERIFY_INVALID_CRL_DIST_PT: c_uint = 14;
4205pub const CSSM_TP_CERTVERIFY_INVALID_NAME_TREE: c_uint = 15;
4207pub const CSSM_TP_CERTVERIFY_UNKNOWN_CRITICAL_EXT: c_uint = 16;
4209
4210#[cfg(feature = "cssmconfig")]
4212#[deprecated]
4213#[repr(C)]
4214#[derive(Clone, Copy, Debug, PartialEq)]
4215pub struct cssm_tp_certverify_output {
4216 pub VerifyStatus: CSSM_TP_CERTVERIFY_STATUS,
4217 pub NumberOfEvidence: uint32,
4218 pub Evidence: CSSM_EVIDENCE_PTR,
4219}
4220
4221#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4222unsafe impl Encode for cssm_tp_certverify_output {
4223 const ENCODING: Encoding = Encoding::Struct(
4224 "cssm_tp_certverify_output",
4225 &[
4226 <CSSM_TP_CERTVERIFY_STATUS>::ENCODING,
4227 <uint32>::ENCODING,
4228 <CSSM_EVIDENCE_PTR>::ENCODING,
4229 ],
4230 );
4231}
4232
4233#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4234unsafe impl RefEncode for cssm_tp_certverify_output {
4235 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4236}
4237
4238#[cfg(feature = "cssmconfig")]
4240pub type CSSM_TP_CERTVERIFY_OUTPUT = cssm_tp_certverify_output;
4241
4242#[cfg(feature = "cssmconfig")]
4244pub type CSSM_TP_CERTVERIFY_OUTPUT_PTR = *mut cssm_tp_certverify_output;
4245
4246#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4248#[deprecated]
4249#[repr(C)]
4250#[derive(Clone, Copy, Debug, PartialEq)]
4251pub struct cssm_tp_certnotarize_input {
4252 pub CLHandle: CSSM_CL_HANDLE,
4253 pub NumberOfFields: uint32,
4254 pub MoreFields: CSSM_FIELD_PTR,
4255 pub SignScope: CSSM_FIELD_PTR,
4256 pub ScopeSize: uint32,
4257 pub MoreServiceRequests: CSSM_TP_SERVICES,
4258 pub NumberOfServiceControls: uint32,
4259 pub ServiceControls: CSSM_FIELD_PTR,
4260 pub UserCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4261}
4262
4263#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4264unsafe impl Encode for cssm_tp_certnotarize_input {
4265 const ENCODING: Encoding = Encoding::Struct(
4266 "cssm_tp_certnotarize_input",
4267 &[
4268 <CSSM_CL_HANDLE>::ENCODING,
4269 <uint32>::ENCODING,
4270 <CSSM_FIELD_PTR>::ENCODING,
4271 <CSSM_FIELD_PTR>::ENCODING,
4272 <uint32>::ENCODING,
4273 <CSSM_TP_SERVICES>::ENCODING,
4274 <uint32>::ENCODING,
4275 <CSSM_FIELD_PTR>::ENCODING,
4276 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4277 ],
4278 );
4279}
4280
4281#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4282unsafe impl RefEncode for cssm_tp_certnotarize_input {
4283 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4284}
4285
4286#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4288pub type CSSM_TP_CERTNOTARIZE_INPUT = cssm_tp_certnotarize_input;
4289
4290#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4292pub type CSSM_TP_CERTNOTARIZE_INPUT_PTR = *mut cssm_tp_certnotarize_input;
4293
4294#[cfg(feature = "cssmconfig")]
4296pub type CSSM_TP_CERTNOTARIZE_STATUS = uint32;
4297
4298pub const CSSM_TP_CERTNOTARIZE_STATUS_UNKNOWN: c_uint = 0;
4300pub const CSSM_TP_CERTNOTARIZE_OK: c_uint = 1;
4302pub const CSSM_TP_CERTNOTARIZE_OKWITHOUTFIELDS: c_uint = 2;
4304pub const CSSM_TP_CERTNOTARIZE_OKWITHSERVICEMODS: c_uint = 3;
4306pub const CSSM_TP_CERTNOTARIZE_REJECTED: c_uint = 4;
4308pub const CSSM_TP_CERTNOTARIZE_NOT_AUTHORIZED: c_uint = 5;
4310
4311#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4313#[deprecated]
4314#[repr(C)]
4315#[derive(Clone, Copy, Debug, PartialEq)]
4316pub struct cssm_tp_certnotarize_output {
4317 pub NotarizeStatus: CSSM_TP_CERTNOTARIZE_STATUS,
4318 pub NotarizedCertGroup: CSSM_CERTGROUP_PTR,
4319 pub PerformedServiceRequests: CSSM_TP_SERVICES,
4320}
4321
4322#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4323unsafe impl Encode for cssm_tp_certnotarize_output {
4324 const ENCODING: Encoding = Encoding::Struct(
4325 "cssm_tp_certnotarize_output",
4326 &[
4327 <CSSM_TP_CERTNOTARIZE_STATUS>::ENCODING,
4328 <CSSM_CERTGROUP_PTR>::ENCODING,
4329 <CSSM_TP_SERVICES>::ENCODING,
4330 ],
4331 );
4332}
4333
4334#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4335unsafe impl RefEncode for cssm_tp_certnotarize_output {
4336 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4337}
4338
4339#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4341pub type CSSM_TP_CERTNOTARIZE_OUTPUT = cssm_tp_certnotarize_output;
4342
4343#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4345pub type CSSM_TP_CERTNOTARIZE_OUTPUT_PTR = *mut cssm_tp_certnotarize_output;
4346
4347#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4349#[deprecated]
4350#[repr(C)]
4351#[derive(Clone, Copy, Debug, PartialEq)]
4352pub struct cssm_tp_certreclaim_input {
4353 pub CLHandle: CSSM_CL_HANDLE,
4354 pub NumberOfSelectionFields: uint32,
4355 pub SelectionFields: CSSM_FIELD_PTR,
4356 pub UserCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4357}
4358
4359#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4360unsafe impl Encode for cssm_tp_certreclaim_input {
4361 const ENCODING: Encoding = Encoding::Struct(
4362 "cssm_tp_certreclaim_input",
4363 &[
4364 <CSSM_CL_HANDLE>::ENCODING,
4365 <uint32>::ENCODING,
4366 <CSSM_FIELD_PTR>::ENCODING,
4367 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4368 ],
4369 );
4370}
4371
4372#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4373unsafe impl RefEncode for cssm_tp_certreclaim_input {
4374 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4375}
4376
4377#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4379pub type CSSM_TP_CERTRECLAIM_INPUT = cssm_tp_certreclaim_input;
4380
4381#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4383pub type CSSM_TP_CERTRECLAIM_INPUT_PTR = *mut cssm_tp_certreclaim_input;
4384
4385#[cfg(feature = "cssmconfig")]
4387pub type CSSM_TP_CERTRECLAIM_STATUS = uint32;
4388
4389pub const CSSM_TP_CERTRECLAIM_STATUS_UNKNOWN: c_uint = 0;
4391pub const CSSM_TP_CERTRECLAIM_OK: c_uint = 1;
4393pub const CSSM_TP_CERTRECLAIM_NOMATCH: c_uint = 2;
4395pub const CSSM_TP_CERTRECLAIM_REJECTED: c_uint = 3;
4397pub const CSSM_TP_CERTRECLAIM_NOT_AUTHORIZED: c_uint = 4;
4399
4400#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4402#[deprecated]
4403#[repr(C)]
4404#[derive(Clone, Copy, Debug, PartialEq)]
4405pub struct cssm_tp_certreclaim_output {
4406 pub ReclaimStatus: CSSM_TP_CERTRECLAIM_STATUS,
4407 pub ReclaimedCertGroup: CSSM_CERTGROUP_PTR,
4408 pub KeyCacheHandle: CSSM_LONG_HANDLE,
4409}
4410
4411#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4412unsafe impl Encode for cssm_tp_certreclaim_output {
4413 const ENCODING: Encoding = Encoding::Struct(
4414 "cssm_tp_certreclaim_output",
4415 &[
4416 <CSSM_TP_CERTRECLAIM_STATUS>::ENCODING,
4417 <CSSM_CERTGROUP_PTR>::ENCODING,
4418 <CSSM_LONG_HANDLE>::ENCODING,
4419 ],
4420 );
4421}
4422
4423#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4424unsafe impl RefEncode for cssm_tp_certreclaim_output {
4425 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4426}
4427
4428#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4430pub type CSSM_TP_CERTRECLAIM_OUTPUT = cssm_tp_certreclaim_output;
4431
4432#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4434pub type CSSM_TP_CERTRECLAIM_OUTPUT_PTR = *mut cssm_tp_certreclaim_output;
4435
4436#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4438#[deprecated]
4439#[repr(C)]
4440#[derive(Clone, Copy, Debug, PartialEq)]
4441pub struct cssm_tp_crlissue_input {
4442 pub CLHandle: CSSM_CL_HANDLE,
4443 pub CrlIdentifier: uint32,
4444 pub CrlThisTime: CSSM_TIMESTRING,
4445 pub PolicyIdentifier: CSSM_FIELD_PTR,
4446 pub CallerCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4447}
4448
4449#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4450unsafe impl Encode for cssm_tp_crlissue_input {
4451 const ENCODING: Encoding = Encoding::Struct(
4452 "cssm_tp_crlissue_input",
4453 &[
4454 <CSSM_CL_HANDLE>::ENCODING,
4455 <uint32>::ENCODING,
4456 <CSSM_TIMESTRING>::ENCODING,
4457 <CSSM_FIELD_PTR>::ENCODING,
4458 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4459 ],
4460 );
4461}
4462
4463#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4464unsafe impl RefEncode for cssm_tp_crlissue_input {
4465 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4466}
4467
4468#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4470pub type CSSM_TP_CRLISSUE_INPUT = cssm_tp_crlissue_input;
4471
4472#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4474pub type CSSM_TP_CRLISSUE_INPUT_PTR = *mut cssm_tp_crlissue_input;
4475
4476#[cfg(feature = "cssmconfig")]
4478pub type CSSM_TP_CRLISSUE_STATUS = uint32;
4479
4480pub const CSSM_TP_CRLISSUE_STATUS_UNKNOWN: c_uint = 0;
4482pub const CSSM_TP_CRLISSUE_OK: c_uint = 1;
4484pub const CSSM_TP_CRLISSUE_NOT_CURRENT: c_uint = 2;
4486pub const CSSM_TP_CRLISSUE_INVALID_DOMAIN: c_uint = 3;
4488pub const CSSM_TP_CRLISSUE_UNKNOWN_IDENTIFIER: c_uint = 4;
4490pub const CSSM_TP_CRLISSUE_REJECTED: c_uint = 5;
4492pub const CSSM_TP_CRLISSUE_NOT_AUTHORIZED: c_uint = 6;
4494
4495#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4497#[deprecated]
4498#[repr(C)]
4499#[derive(Clone, Copy, Debug, PartialEq)]
4500pub struct cssm_tp_crlissue_output {
4501 pub IssueStatus: CSSM_TP_CRLISSUE_STATUS,
4502 pub Crl: CSSM_ENCODED_CRL_PTR,
4503 pub CrlNextTime: CSSM_TIMESTRING,
4504}
4505
4506#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4507unsafe impl Encode for cssm_tp_crlissue_output {
4508 const ENCODING: Encoding = Encoding::Struct(
4509 "cssm_tp_crlissue_output",
4510 &[
4511 <CSSM_TP_CRLISSUE_STATUS>::ENCODING,
4512 <CSSM_ENCODED_CRL_PTR>::ENCODING,
4513 <CSSM_TIMESTRING>::ENCODING,
4514 ],
4515 );
4516}
4517
4518#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4519unsafe impl RefEncode for cssm_tp_crlissue_output {
4520 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4521}
4522
4523#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4525pub type CSSM_TP_CRLISSUE_OUTPUT = cssm_tp_crlissue_output;
4526
4527#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4529pub type CSSM_TP_CRLISSUE_OUTPUT_PTR = *mut cssm_tp_crlissue_output;
4530
4531#[cfg(feature = "cssmconfig")]
4533pub type CSSM_TP_FORM_TYPE = uint32;
4534
4535pub const CSSM_TP_FORM_TYPE_GENERIC: c_uint = 0;
4537pub const CSSM_TP_FORM_TYPE_REGISTRATION: c_uint = 1;
4539
4540#[cfg(feature = "cssmconfig")]
4542pub type CSSM_CL_TEMPLATE_TYPE = uint32;
4543
4544pub const CSSM_CL_TEMPLATE_INTERMEDIATE_CERT: c_uint = 1;
4546pub const CSSM_CL_TEMPLATE_PKIX_CERTTEMPLATE: c_uint = 2;
4548
4549#[cfg(feature = "cssmconfig")]
4551pub type CSSM_CERT_BUNDLE_TYPE = uint32;
4552
4553pub const CSSM_CERT_BUNDLE_UNKNOWN: c_uint = 0;
4555pub const CSSM_CERT_BUNDLE_CUSTOM: c_uint = 1;
4557pub const CSSM_CERT_BUNDLE_PKCS7_SIGNED_DATA: c_uint = 2;
4559pub const CSSM_CERT_BUNDLE_PKCS7_SIGNED_ENVELOPED_DATA: c_uint = 3;
4561pub const CSSM_CERT_BUNDLE_PKCS12: c_uint = 4;
4563pub const CSSM_CERT_BUNDLE_PFX: c_uint = 5;
4565pub const CSSM_CERT_BUNDLE_SPKI_SEQUENCE: c_uint = 6;
4567pub const CSSM_CERT_BUNDLE_PGP_KEYRING: c_uint = 7;
4569pub const CSSM_CERT_BUNDLE_LAST: c_uint = 32767;
4571pub const CSSM_CL_CUSTOM_CERT_BUNDLE_TYPE: c_uint = 32768;
4573
4574#[cfg(feature = "cssmconfig")]
4576pub type CSSM_CERT_BUNDLE_ENCODING = uint32;
4577
4578pub const CSSM_CERT_BUNDLE_ENCODING_UNKNOWN: c_uint = 0;
4580pub const CSSM_CERT_BUNDLE_ENCODING_CUSTOM: c_uint = 1;
4582pub const CSSM_CERT_BUNDLE_ENCODING_BER: c_uint = 2;
4584pub const CSSM_CERT_BUNDLE_ENCODING_DER: c_uint = 3;
4586pub const CSSM_CERT_BUNDLE_ENCODING_SEXPR: c_uint = 4;
4588pub const CSSM_CERT_BUNDLE_ENCODING_PGP: c_uint = 5;
4590
4591#[cfg(feature = "cssmconfig")]
4593#[deprecated]
4594#[repr(C)]
4595#[derive(Clone, Copy, Debug, PartialEq)]
4596pub struct cssm_cert_bundle_header {
4597 pub BundleType: CSSM_CERT_BUNDLE_TYPE,
4598 pub BundleEncoding: CSSM_CERT_BUNDLE_ENCODING,
4599}
4600
4601#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4602unsafe impl Encode for cssm_cert_bundle_header {
4603 const ENCODING: Encoding = Encoding::Struct(
4604 "cssm_cert_bundle_header",
4605 &[
4606 <CSSM_CERT_BUNDLE_TYPE>::ENCODING,
4607 <CSSM_CERT_BUNDLE_ENCODING>::ENCODING,
4608 ],
4609 );
4610}
4611
4612#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4613unsafe impl RefEncode for cssm_cert_bundle_header {
4614 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4615}
4616
4617#[cfg(feature = "cssmconfig")]
4619pub type CSSM_CERT_BUNDLE_HEADER = cssm_cert_bundle_header;
4620
4621#[cfg(feature = "cssmconfig")]
4623pub type CSSM_CERT_BUNDLE_HEADER_PTR = *mut cssm_cert_bundle_header;
4624
4625#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4627#[deprecated]
4628#[repr(C)]
4629#[derive(Clone, Copy, Debug, PartialEq)]
4630pub struct cssm_cert_bundle {
4631 pub BundleHeader: CSSM_CERT_BUNDLE_HEADER,
4632 pub Bundle: SecAsn1Item,
4633}
4634
4635#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4636unsafe impl Encode for cssm_cert_bundle {
4637 const ENCODING: Encoding = Encoding::Struct(
4638 "cssm_cert_bundle",
4639 &[<CSSM_CERT_BUNDLE_HEADER>::ENCODING, <SecAsn1Item>::ENCODING],
4640 );
4641}
4642
4643#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4644unsafe impl RefEncode for cssm_cert_bundle {
4645 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4646}
4647
4648#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4650pub type CSSM_CERT_BUNDLE = cssm_cert_bundle;
4651
4652#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4654pub type CSSM_CERT_BUNDLE_PTR = *mut cssm_cert_bundle;
4655
4656pub const CSSM_FIELDVALUE_COMPLEX_DATA_TYPE: c_uint = 4294967295;
4658
4659#[cfg(feature = "cssmconfig")]
4661pub type CSSM_DB_ATTRIBUTE_NAME_FORMAT = uint32;
4662
4663#[cfg(feature = "cssmconfig")]
4665pub type CSSM_DB_ATTRIBUTE_NAME_FORMAT_PTR = *mut uint32;
4666
4667pub const CSSM_DB_ATTRIBUTE_NAME_AS_STRING: c_uint = 0;
4669pub const CSSM_DB_ATTRIBUTE_NAME_AS_OID: c_uint = 1;
4671pub const CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER: c_uint = 2;
4673
4674#[cfg(feature = "cssmconfig")]
4676pub type CSSM_DB_ATTRIBUTE_FORMAT = uint32;
4677
4678#[cfg(feature = "cssmconfig")]
4680pub type CSSM_DB_ATTRIBUTE_FORMAT_PTR = *mut uint32;
4681
4682pub const CSSM_DB_ATTRIBUTE_FORMAT_STRING: c_uint = 0;
4684pub const CSSM_DB_ATTRIBUTE_FORMAT_SINT32: c_uint = 1;
4686pub const CSSM_DB_ATTRIBUTE_FORMAT_UINT32: c_uint = 2;
4688pub const CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM: c_uint = 3;
4690pub const CSSM_DB_ATTRIBUTE_FORMAT_REAL: c_uint = 4;
4692pub const CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE: c_uint = 5;
4694pub const CSSM_DB_ATTRIBUTE_FORMAT_BLOB: c_uint = 6;
4696pub const CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32: c_uint = 7;
4698pub const CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX: c_uint = 8;
4700
4701#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4703#[deprecated]
4704#[repr(C)]
4705#[derive(Clone, Copy)]
4706pub union cssm_db_attribute_label {
4707 pub AttributeName: *mut c_char,
4708 pub AttributeOID: SecAsn1Oid,
4709 pub AttributeID: uint32,
4710}
4711
4712#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4713unsafe impl Encode for cssm_db_attribute_label {
4714 const ENCODING: Encoding = Encoding::Union(
4715 "cssm_db_attribute_label",
4716 &[
4717 <*mut c_char>::ENCODING,
4718 <SecAsn1Oid>::ENCODING,
4719 <uint32>::ENCODING,
4720 ],
4721 );
4722}
4723
4724#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4725unsafe impl RefEncode for cssm_db_attribute_label {
4726 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4727}
4728
4729#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4731#[deprecated]
4732#[repr(C)]
4733#[derive(Clone, Copy)]
4734pub struct cssm_db_attribute_info {
4735 pub AttributeNameFormat: CSSM_DB_ATTRIBUTE_NAME_FORMAT,
4736 pub Label: cssm_db_attribute_label,
4737 pub AttributeFormat: CSSM_DB_ATTRIBUTE_FORMAT,
4738}
4739
4740#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4741unsafe impl Encode for cssm_db_attribute_info {
4742 const ENCODING: Encoding = Encoding::Struct(
4743 "cssm_db_attribute_info",
4744 &[
4745 <CSSM_DB_ATTRIBUTE_NAME_FORMAT>::ENCODING,
4746 <cssm_db_attribute_label>::ENCODING,
4747 <CSSM_DB_ATTRIBUTE_FORMAT>::ENCODING,
4748 ],
4749 );
4750}
4751
4752#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4753unsafe impl RefEncode for cssm_db_attribute_info {
4754 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4755}
4756
4757#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4759pub type CSSM_DB_ATTRIBUTE_INFO = cssm_db_attribute_info;
4760
4761#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4763pub type CSSM_DB_ATTRIBUTE_INFO_PTR = *mut cssm_db_attribute_info;
4764
4765#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4767#[deprecated]
4768#[repr(C)]
4769#[derive(Clone, Copy)]
4770pub struct cssm_db_attribute_data {
4771 pub Info: CSSM_DB_ATTRIBUTE_INFO,
4772 pub NumberOfValues: uint32,
4773 pub Value: CSSM_DATA_PTR,
4774}
4775
4776#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4777unsafe impl Encode for cssm_db_attribute_data {
4778 const ENCODING: Encoding = Encoding::Struct(
4779 "cssm_db_attribute_data",
4780 &[
4781 <CSSM_DB_ATTRIBUTE_INFO>::ENCODING,
4782 <uint32>::ENCODING,
4783 <CSSM_DATA_PTR>::ENCODING,
4784 ],
4785 );
4786}
4787
4788#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4789unsafe impl RefEncode for cssm_db_attribute_data {
4790 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4791}
4792
4793#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4795pub type CSSM_DB_ATTRIBUTE_DATA = cssm_db_attribute_data;
4796
4797#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4799pub type CSSM_DB_ATTRIBUTE_DATA_PTR = *mut cssm_db_attribute_data;
4800
4801#[cfg(feature = "cssmconfig")]
4803pub type CSSM_DB_RECORDTYPE = uint32;
4804
4805pub const CSSM_DB_RECORDTYPE_SCHEMA_START: c_uint = 0;
4807pub const CSSM_DB_RECORDTYPE_SCHEMA_END: c_uint = 4;
4809pub const CSSM_DB_RECORDTYPE_OPEN_GROUP_START: c_uint = 10;
4811pub const CSSM_DB_RECORDTYPE_OPEN_GROUP_END: c_uint = 18;
4813pub const CSSM_DB_RECORDTYPE_APP_DEFINED_START: c_uint = 2147483648;
4815pub const CSSM_DB_RECORDTYPE_APP_DEFINED_END: c_uint = 4294967295;
4817pub const CSSM_DL_DB_SCHEMA_INFO: c_uint = 0;
4819pub const CSSM_DL_DB_SCHEMA_INDEXES: c_uint = 1;
4821pub const CSSM_DL_DB_SCHEMA_ATTRIBUTES: c_uint = 2;
4823pub const CSSM_DL_DB_SCHEMA_PARSING_MODULE: c_uint = 3;
4825pub const CSSM_DL_DB_RECORD_ANY: c_uint = 10;
4827pub const CSSM_DL_DB_RECORD_CERT: c_uint = 11;
4829pub const CSSM_DL_DB_RECORD_CRL: c_uint = 12;
4831pub const CSSM_DL_DB_RECORD_POLICY: c_uint = 13;
4833pub const CSSM_DL_DB_RECORD_GENERIC: c_uint = 14;
4835pub const CSSM_DL_DB_RECORD_PUBLIC_KEY: c_uint = 15;
4837pub const CSSM_DL_DB_RECORD_PRIVATE_KEY: c_uint = 16;
4839pub const CSSM_DL_DB_RECORD_SYMMETRIC_KEY: c_uint = 17;
4841pub const CSSM_DL_DB_RECORD_ALL_KEYS: c_uint = 18;
4843
4844pub const CSSM_DB_CERT_USE_TRUSTED: c_uint = 1;
4846pub const CSSM_DB_CERT_USE_SYSTEM: c_uint = 2;
4848pub const CSSM_DB_CERT_USE_OWNER: c_uint = 4;
4850pub const CSSM_DB_CERT_USE_REVOKED: c_uint = 8;
4852pub const CSSM_DB_CERT_USE_SIGNING: c_uint = 16;
4854pub const CSSM_DB_CERT_USE_PRIVACY: c_uint = 32;
4856
4857#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4859#[deprecated]
4860#[repr(C)]
4861#[derive(Clone, Copy, Debug, PartialEq)]
4862pub struct cssm_db_record_attribute_info {
4863 pub DataRecordType: CSSM_DB_RECORDTYPE,
4864 pub NumberOfAttributes: uint32,
4865 pub AttributeInfo: CSSM_DB_ATTRIBUTE_INFO_PTR,
4866}
4867
4868#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4869unsafe impl Encode for cssm_db_record_attribute_info {
4870 const ENCODING: Encoding = Encoding::Struct(
4871 "cssm_db_record_attribute_info",
4872 &[
4873 <CSSM_DB_RECORDTYPE>::ENCODING,
4874 <uint32>::ENCODING,
4875 <CSSM_DB_ATTRIBUTE_INFO_PTR>::ENCODING,
4876 ],
4877 );
4878}
4879
4880#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4881unsafe impl RefEncode for cssm_db_record_attribute_info {
4882 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4883}
4884
4885#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4887pub type CSSM_DB_RECORD_ATTRIBUTE_INFO = cssm_db_record_attribute_info;
4888
4889#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4891pub type CSSM_DB_RECORD_ATTRIBUTE_INFO_PTR = *mut cssm_db_record_attribute_info;
4892
4893#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4895#[deprecated]
4896#[repr(C)]
4897#[derive(Clone, Copy, Debug, PartialEq)]
4898pub struct cssm_db_record_attribute_data {
4899 pub DataRecordType: CSSM_DB_RECORDTYPE,
4900 pub SemanticInformation: uint32,
4901 pub NumberOfAttributes: uint32,
4902 pub AttributeData: CSSM_DB_ATTRIBUTE_DATA_PTR,
4903}
4904
4905#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4906unsafe impl Encode for cssm_db_record_attribute_data {
4907 const ENCODING: Encoding = Encoding::Struct(
4908 "cssm_db_record_attribute_data",
4909 &[
4910 <CSSM_DB_RECORDTYPE>::ENCODING,
4911 <uint32>::ENCODING,
4912 <uint32>::ENCODING,
4913 <CSSM_DB_ATTRIBUTE_DATA_PTR>::ENCODING,
4914 ],
4915 );
4916}
4917
4918#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4919unsafe impl RefEncode for cssm_db_record_attribute_data {
4920 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4921}
4922
4923#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4925pub type CSSM_DB_RECORD_ATTRIBUTE_DATA = cssm_db_record_attribute_data;
4926
4927#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4929pub type CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR = *mut cssm_db_record_attribute_data;
4930
4931#[cfg(feature = "cssmconfig")]
4933#[deprecated]
4934#[repr(C)]
4935#[derive(Clone, Copy, Debug, PartialEq)]
4936pub struct cssm_db_parsing_module_info {
4937 pub RecordType: CSSM_DB_RECORDTYPE,
4938 pub ModuleSubserviceUid: CSSM_SUBSERVICE_UID,
4939}
4940
4941#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4942unsafe impl Encode for cssm_db_parsing_module_info {
4943 const ENCODING: Encoding = Encoding::Struct(
4944 "cssm_db_parsing_module_info",
4945 &[
4946 <CSSM_DB_RECORDTYPE>::ENCODING,
4947 <CSSM_SUBSERVICE_UID>::ENCODING,
4948 ],
4949 );
4950}
4951
4952#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4953unsafe impl RefEncode for cssm_db_parsing_module_info {
4954 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4955}
4956
4957#[cfg(feature = "cssmconfig")]
4959pub type CSSM_DB_PARSING_MODULE_INFO = cssm_db_parsing_module_info;
4960
4961#[cfg(feature = "cssmconfig")]
4963pub type CSSM_DB_PARSING_MODULE_INFO_PTR = *mut cssm_db_parsing_module_info;
4964
4965#[cfg(feature = "cssmconfig")]
4967pub type CSSM_DB_INDEX_TYPE = uint32;
4968
4969pub const CSSM_DB_INDEX_UNIQUE: c_uint = 0;
4971pub const CSSM_DB_INDEX_NONUNIQUE: c_uint = 1;
4973
4974#[cfg(feature = "cssmconfig")]
4976pub type CSSM_DB_INDEXED_DATA_LOCATION = uint32;
4977
4978pub const CSSM_DB_INDEX_ON_UNKNOWN: c_uint = 0;
4980pub const CSSM_DB_INDEX_ON_ATTRIBUTE: c_uint = 1;
4982pub const CSSM_DB_INDEX_ON_RECORD: c_uint = 2;
4984
4985#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4987#[deprecated]
4988#[repr(C)]
4989#[derive(Clone, Copy)]
4990pub struct cssm_db_index_info {
4991 pub IndexType: CSSM_DB_INDEX_TYPE,
4992 pub IndexedDataLocation: CSSM_DB_INDEXED_DATA_LOCATION,
4993 pub Info: CSSM_DB_ATTRIBUTE_INFO,
4994}
4995
4996#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4997unsafe impl Encode for cssm_db_index_info {
4998 const ENCODING: Encoding = Encoding::Struct(
4999 "cssm_db_index_info",
5000 &[
5001 <CSSM_DB_INDEX_TYPE>::ENCODING,
5002 <CSSM_DB_INDEXED_DATA_LOCATION>::ENCODING,
5003 <CSSM_DB_ATTRIBUTE_INFO>::ENCODING,
5004 ],
5005 );
5006}
5007
5008#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5009unsafe impl RefEncode for cssm_db_index_info {
5010 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5011}
5012
5013#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5015pub type CSSM_DB_INDEX_INFO = cssm_db_index_info;
5016
5017#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5019pub type CSSM_DB_INDEX_INFO_PTR = *mut cssm_db_index_info;
5020
5021#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5023#[deprecated]
5024#[repr(C)]
5025#[derive(Clone, Copy)]
5026pub struct cssm_db_unique_record {
5027 pub RecordLocator: CSSM_DB_INDEX_INFO,
5028 pub RecordIdentifier: SecAsn1Item,
5029}
5030
5031#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5032unsafe impl Encode for cssm_db_unique_record {
5033 const ENCODING: Encoding = Encoding::Struct(
5034 "cssm_db_unique_record",
5035 &[<CSSM_DB_INDEX_INFO>::ENCODING, <SecAsn1Item>::ENCODING],
5036 );
5037}
5038
5039#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5040unsafe impl RefEncode for cssm_db_unique_record {
5041 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5042}
5043
5044#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5046pub type CSSM_DB_UNIQUE_RECORD = cssm_db_unique_record;
5047
5048#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5050pub type CSSM_DB_UNIQUE_RECORD_PTR = *mut cssm_db_unique_record;
5051
5052#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5054#[deprecated]
5055#[repr(C)]
5056#[derive(Clone, Copy, Debug, PartialEq)]
5057pub struct cssm_db_record_index_info {
5058 pub DataRecordType: CSSM_DB_RECORDTYPE,
5059 pub NumberOfIndexes: uint32,
5060 pub IndexInfo: CSSM_DB_INDEX_INFO_PTR,
5061}
5062
5063#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5064unsafe impl Encode for cssm_db_record_index_info {
5065 const ENCODING: Encoding = Encoding::Struct(
5066 "cssm_db_record_index_info",
5067 &[
5068 <CSSM_DB_RECORDTYPE>::ENCODING,
5069 <uint32>::ENCODING,
5070 <CSSM_DB_INDEX_INFO_PTR>::ENCODING,
5071 ],
5072 );
5073}
5074
5075#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5076unsafe impl RefEncode for cssm_db_record_index_info {
5077 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5078}
5079
5080#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5082pub type CSSM_DB_RECORD_INDEX_INFO = cssm_db_record_index_info;
5083
5084#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5086pub type CSSM_DB_RECORD_INDEX_INFO_PTR = *mut cssm_db_record_index_info;
5087
5088#[cfg(feature = "cssmconfig")]
5090pub type CSSM_DB_ACCESS_TYPE = uint32;
5091
5092#[cfg(feature = "cssmconfig")]
5094pub type CSSM_DB_ACCESS_TYPE_PTR = *mut uint32;
5095
5096pub const CSSM_DB_ACCESS_READ: c_uint = 1;
5098pub const CSSM_DB_ACCESS_WRITE: c_uint = 2;
5100pub const CSSM_DB_ACCESS_PRIVILEGED: c_uint = 4;
5102
5103#[cfg(feature = "cssmconfig")]
5105pub type CSSM_DB_MODIFY_MODE = uint32;
5106
5107pub const CSSM_DB_MODIFY_ATTRIBUTE_NONE: c_uint = 0;
5109pub const CSSM_DB_MODIFY_ATTRIBUTE_ADD: c_uint = 1;
5111pub const CSSM_DB_MODIFY_ATTRIBUTE_DELETE: c_uint = 2;
5113pub const CSSM_DB_MODIFY_ATTRIBUTE_REPLACE: c_uint = 3;
5115
5116#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5118#[deprecated]
5119#[repr(C)]
5120#[derive(Clone, Copy, Debug, PartialEq)]
5121pub struct cssm_dbinfo {
5122 pub NumberOfRecordTypes: uint32,
5123 pub DefaultParsingModules: CSSM_DB_PARSING_MODULE_INFO_PTR,
5124 pub RecordAttributeNames: CSSM_DB_RECORD_ATTRIBUTE_INFO_PTR,
5125 pub RecordIndexes: CSSM_DB_RECORD_INDEX_INFO_PTR,
5126 pub IsLocal: CSSM_BOOL,
5127 pub AccessPath: *mut c_char,
5128 pub Reserved: *mut c_void,
5129}
5130
5131#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5132unsafe impl Encode for cssm_dbinfo {
5133 const ENCODING: Encoding = Encoding::Struct(
5134 "cssm_dbinfo",
5135 &[
5136 <uint32>::ENCODING,
5137 <CSSM_DB_PARSING_MODULE_INFO_PTR>::ENCODING,
5138 <CSSM_DB_RECORD_ATTRIBUTE_INFO_PTR>::ENCODING,
5139 <CSSM_DB_RECORD_INDEX_INFO_PTR>::ENCODING,
5140 <CSSM_BOOL>::ENCODING,
5141 <*mut c_char>::ENCODING,
5142 <*mut c_void>::ENCODING,
5143 ],
5144 );
5145}
5146
5147#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5148unsafe impl RefEncode for cssm_dbinfo {
5149 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5150}
5151
5152#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5154pub type CSSM_DBINFO = cssm_dbinfo;
5155
5156#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5158pub type CSSM_DBINFO_PTR = *mut cssm_dbinfo;
5159
5160#[cfg(feature = "cssmconfig")]
5162pub type CSSM_DB_OPERATOR = uint32;
5163
5164#[cfg(feature = "cssmconfig")]
5166pub type CSSM_DB_OPERATOR_PTR = *mut uint32;
5167
5168pub const CSSM_DB_EQUAL: c_uint = 0;
5170pub const CSSM_DB_NOT_EQUAL: c_uint = 1;
5172pub const CSSM_DB_LESS_THAN: c_uint = 2;
5174pub const CSSM_DB_GREATER_THAN: c_uint = 3;
5176pub const CSSM_DB_CONTAINS: c_uint = 4;
5178pub const CSSM_DB_CONTAINS_INITIAL_SUBSTRING: c_uint = 5;
5180pub const CSSM_DB_CONTAINS_FINAL_SUBSTRING: c_uint = 6;
5182
5183#[cfg(feature = "cssmconfig")]
5185pub type CSSM_DB_CONJUNCTIVE = uint32;
5186
5187#[cfg(feature = "cssmconfig")]
5189pub type CSSM_DB_CONJUNCTIVE_PTR = *mut uint32;
5190
5191pub const CSSM_DB_NONE: c_uint = 0;
5193pub const CSSM_DB_AND: c_uint = 1;
5195pub const CSSM_DB_OR: c_uint = 2;
5197
5198#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5200#[deprecated]
5201#[repr(C)]
5202#[derive(Clone, Copy)]
5203pub struct cssm_selection_predicate {
5204 pub DbOperator: CSSM_DB_OPERATOR,
5205 pub Attribute: CSSM_DB_ATTRIBUTE_DATA,
5206}
5207
5208#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5209unsafe impl Encode for cssm_selection_predicate {
5210 const ENCODING: Encoding = Encoding::Struct(
5211 "cssm_selection_predicate",
5212 &[
5213 <CSSM_DB_OPERATOR>::ENCODING,
5214 <CSSM_DB_ATTRIBUTE_DATA>::ENCODING,
5215 ],
5216 );
5217}
5218
5219#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5220unsafe impl RefEncode for cssm_selection_predicate {
5221 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5222}
5223
5224#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5226pub type CSSM_SELECTION_PREDICATE = cssm_selection_predicate;
5227
5228#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5230pub type CSSM_SELECTION_PREDICATE_PTR = *mut cssm_selection_predicate;
5231
5232pub const CSSM_QUERY_TIMELIMIT_NONE: c_uint = 0;
5234
5235pub const CSSM_QUERY_SIZELIMIT_NONE: c_uint = 0;
5237
5238#[cfg(feature = "cssmconfig")]
5240#[deprecated]
5241#[repr(C)]
5242#[derive(Clone, Copy, Debug, PartialEq)]
5243pub struct cssm_query_limits {
5244 pub TimeLimit: uint32,
5245 pub SizeLimit: uint32,
5246}
5247
5248#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5249unsafe impl Encode for cssm_query_limits {
5250 const ENCODING: Encoding = Encoding::Struct(
5251 "cssm_query_limits",
5252 &[<uint32>::ENCODING, <uint32>::ENCODING],
5253 );
5254}
5255
5256#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5257unsafe impl RefEncode for cssm_query_limits {
5258 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5259}
5260
5261#[cfg(feature = "cssmconfig")]
5263pub type CSSM_QUERY_LIMITS = cssm_query_limits;
5264
5265#[cfg(feature = "cssmconfig")]
5267pub type CSSM_QUERY_LIMITS_PTR = *mut cssm_query_limits;
5268
5269#[cfg(feature = "cssmconfig")]
5271pub type CSSM_QUERY_FLAGS = uint32;
5272
5273pub const CSSM_QUERY_RETURN_DATA: c_uint = 1;
5275
5276#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5278#[deprecated]
5279#[repr(C)]
5280#[derive(Clone, Copy, Debug, PartialEq)]
5281pub struct cssm_query {
5282 pub RecordType: CSSM_DB_RECORDTYPE,
5283 pub Conjunctive: CSSM_DB_CONJUNCTIVE,
5284 pub NumSelectionPredicates: uint32,
5285 pub SelectionPredicate: CSSM_SELECTION_PREDICATE_PTR,
5286 pub QueryLimits: CSSM_QUERY_LIMITS,
5287 pub QueryFlags: CSSM_QUERY_FLAGS,
5288}
5289
5290#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5291unsafe impl Encode for cssm_query {
5292 const ENCODING: Encoding = Encoding::Struct(
5293 "cssm_query",
5294 &[
5295 <CSSM_DB_RECORDTYPE>::ENCODING,
5296 <CSSM_DB_CONJUNCTIVE>::ENCODING,
5297 <uint32>::ENCODING,
5298 <CSSM_SELECTION_PREDICATE_PTR>::ENCODING,
5299 <CSSM_QUERY_LIMITS>::ENCODING,
5300 <CSSM_QUERY_FLAGS>::ENCODING,
5301 ],
5302 );
5303}
5304
5305#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5306unsafe impl RefEncode for cssm_query {
5307 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5308}
5309
5310#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5312pub type CSSM_QUERY = cssm_query;
5313
5314#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5316pub type CSSM_QUERY_PTR = *mut cssm_query;
5317
5318#[cfg(feature = "cssmconfig")]
5320pub type CSSM_DLTYPE = uint32;
5321
5322#[cfg(feature = "cssmconfig")]
5324pub type CSSM_DLTYPE_PTR = *mut uint32;
5325
5326pub const CSSM_DL_UNKNOWN: c_uint = 0;
5328pub const CSSM_DL_CUSTOM: c_uint = 1;
5330pub const CSSM_DL_LDAP: c_uint = 2;
5332pub const CSSM_DL_ODBC: c_uint = 3;
5334pub const CSSM_DL_PKCS11: c_uint = 4;
5336pub const CSSM_DL_FFS: c_uint = 5;
5338pub const CSSM_DL_MEMORY: c_uint = 6;
5340pub const CSSM_DL_REMOTEDIR: c_uint = 7;
5342
5343pub type CSSM_DL_CUSTOM_ATTRIBUTES = *mut c_void;
5345
5346pub type CSSM_DL_LDAP_ATTRIBUTES = *mut c_void;
5348
5349pub type CSSM_DL_ODBC_ATTRIBUTES = *mut c_void;
5351
5352pub type CSSM_DL_FFS_ATTRIBUTES = *mut c_void;
5354
5355#[cfg(feature = "cssmconfig")]
5357#[repr(C)]
5358#[derive(Clone, Copy, Debug, PartialEq)]
5359pub struct cssm_dl_pkcs11_attributes {
5360 pub DeviceAccessFlags: uint32,
5361}
5362
5363#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5364unsafe impl Encode for cssm_dl_pkcs11_attributes {
5365 const ENCODING: Encoding = Encoding::Struct("cssm_dl_pkcs11_attributes", &[<uint32>::ENCODING]);
5366}
5367
5368#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5369unsafe impl RefEncode for cssm_dl_pkcs11_attributes {
5370 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5371}
5372
5373#[cfg(feature = "cssmconfig")]
5375pub type CSSM_DL_PKCS11_ATTRIBUTE = *mut cssm_dl_pkcs11_attributes;
5376
5377#[cfg(feature = "cssmconfig")]
5379pub type CSSM_DL_PKCS11_ATTRIBUTE_PTR = *mut cssm_dl_pkcs11_attributes;
5380
5381pub const CSSM_DB_DATASTORES_UNKNOWN: c_uint = 4294967295;
5383
5384#[cfg(feature = "cssmconfig")]
5386#[repr(C)]
5387#[derive(Clone, Copy, Debug, PartialEq)]
5388pub struct cssm_name_list {
5389 pub NumStrings: uint32,
5390 pub String: *mut *mut c_char,
5391}
5392
5393#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5394unsafe impl Encode for cssm_name_list {
5395 const ENCODING: Encoding = Encoding::Struct(
5396 "cssm_name_list",
5397 &[<uint32>::ENCODING, <*mut *mut c_char>::ENCODING],
5398 );
5399}
5400
5401#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5402unsafe impl RefEncode for cssm_name_list {
5403 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5404}
5405
5406#[cfg(feature = "cssmconfig")]
5408pub type CSSM_NAME_LIST = cssm_name_list;
5409
5410#[cfg(feature = "cssmconfig")]
5412pub type CSSM_NAME_LIST_PTR = *mut cssm_name_list;
5413
5414#[cfg(feature = "cssmconfig")]
5416pub type CSSM_DB_RETRIEVAL_MODES = uint32;
5417
5418pub const CSSM_DB_TRANSACTIONAL_MODE: c_uint = 0;
5420pub const CSSM_DB_FILESYSTEMSCAN_MODE: c_uint = 1;
5422
5423#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5425#[deprecated]
5426#[repr(C)]
5427#[derive(Clone, Copy, Debug, PartialEq)]
5428pub struct cssm_db_schema_attribute_info {
5429 pub AttributeId: uint32,
5430 pub AttributeName: *mut c_char,
5431 pub AttributeNameID: SecAsn1Oid,
5432 pub DataType: CSSM_DB_ATTRIBUTE_FORMAT,
5433}
5434
5435#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5436unsafe impl Encode for cssm_db_schema_attribute_info {
5437 const ENCODING: Encoding = Encoding::Struct(
5438 "cssm_db_schema_attribute_info",
5439 &[
5440 <uint32>::ENCODING,
5441 <*mut c_char>::ENCODING,
5442 <SecAsn1Oid>::ENCODING,
5443 <CSSM_DB_ATTRIBUTE_FORMAT>::ENCODING,
5444 ],
5445 );
5446}
5447
5448#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5449unsafe impl RefEncode for cssm_db_schema_attribute_info {
5450 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5451}
5452
5453#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5455pub type CSSM_DB_SCHEMA_ATTRIBUTE_INFO = cssm_db_schema_attribute_info;
5456
5457#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5459pub type CSSM_DB_SCHEMA_ATTRIBUTE_INFO_PTR = *mut cssm_db_schema_attribute_info;
5460
5461#[cfg(feature = "cssmconfig")]
5463#[repr(C)]
5464#[derive(Clone, Copy, Debug, PartialEq)]
5465pub struct cssm_db_schema_index_info {
5466 pub AttributeId: uint32,
5467 pub IndexId: uint32,
5468 pub IndexType: CSSM_DB_INDEX_TYPE,
5469 pub IndexedDataLocation: CSSM_DB_INDEXED_DATA_LOCATION,
5470}
5471
5472#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5473unsafe impl Encode for cssm_db_schema_index_info {
5474 const ENCODING: Encoding = Encoding::Struct(
5475 "cssm_db_schema_index_info",
5476 &[
5477 <uint32>::ENCODING,
5478 <uint32>::ENCODING,
5479 <CSSM_DB_INDEX_TYPE>::ENCODING,
5480 <CSSM_DB_INDEXED_DATA_LOCATION>::ENCODING,
5481 ],
5482 );
5483}
5484
5485#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5486unsafe impl RefEncode for cssm_db_schema_index_info {
5487 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5488}
5489
5490#[cfg(feature = "cssmconfig")]
5492pub type CSSM_DB_SCHEMA_INDEX_INFO = cssm_db_schema_index_info;
5493
5494#[cfg(feature = "cssmconfig")]
5496pub type CSSM_DB_SCHEMA_INDEX_INFO_PTR = *mut cssm_db_schema_index_info;