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#[deprecated]
85#[cfg(feature = "SecAsn1Types")]
86pub type CSSM_DATA_PTR = *mut SecAsn1Item;
87
88#[cfg(feature = "cssmconfig")]
90#[repr(C)]
91#[derive(Clone, Copy, Debug, PartialEq)]
92pub struct cssm_guid {
93 pub Data1: uint32,
94 pub Data2: uint16,
95 pub Data3: uint16,
96 pub Data4: [uint8; 8],
97}
98
99#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
100unsafe impl Encode for cssm_guid {
101 const ENCODING: Encoding = Encoding::Struct(
102 "cssm_guid",
103 &[
104 <uint32>::ENCODING,
105 <uint16>::ENCODING,
106 <uint16>::ENCODING,
107 <[uint8; 8]>::ENCODING,
108 ],
109 );
110}
111
112#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
113unsafe impl RefEncode for cssm_guid {
114 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
115}
116
117#[deprecated]
119#[cfg(feature = "cssmconfig")]
120pub type CSSM_GUID = cssm_guid;
121
122#[deprecated]
124#[cfg(feature = "cssmconfig")]
125pub type CSSM_GUID_PTR = *mut cssm_guid;
126
127#[cfg(feature = "cssmconfig")]
129pub type CSSM_BITMASK = uint32;
130
131#[cfg(feature = "cssmconfig")]
133pub type CSSM_KEY_HIERARCHY = CSSM_BITMASK;
134
135pub const CSSM_KEY_HIERARCHY_NONE: c_uint = 0;
137pub const CSSM_KEY_HIERARCHY_INTEG: c_uint = 1;
139pub const CSSM_KEY_HIERARCHY_EXPORT: c_uint = 2;
141
142#[cfg(feature = "cssmconfig")]
144pub type CSSM_PVC_MODE = CSSM_BITMASK;
145
146pub const CSSM_PVC_NONE: c_uint = 0;
148pub const CSSM_PVC_APP: c_uint = 1;
150pub const CSSM_PVC_SP: c_uint = 2;
152
153#[cfg(feature = "cssmconfig")]
155pub type CSSM_PRIVILEGE_SCOPE = uint32;
156
157pub const CSSM_PRIVILEGE_SCOPE_NONE: c_uint = 0;
159pub const CSSM_PRIVILEGE_SCOPE_PROCESS: c_uint = 1;
161pub const CSSM_PRIVILEGE_SCOPE_THREAD: c_uint = 2;
163
164#[cfg(feature = "cssmconfig")]
166#[repr(C)]
167#[derive(Clone, Copy, Debug, PartialEq)]
168pub struct cssm_version {
169 pub Major: uint32,
170 pub Minor: uint32,
171}
172
173#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
174unsafe impl Encode for cssm_version {
175 const ENCODING: Encoding =
176 Encoding::Struct("cssm_version", &[<uint32>::ENCODING, <uint32>::ENCODING]);
177}
178
179#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
180unsafe impl RefEncode for cssm_version {
181 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
182}
183
184#[deprecated]
186#[cfg(feature = "cssmconfig")]
187pub type CSSM_VERSION = cssm_version;
188
189#[deprecated]
191#[cfg(feature = "cssmconfig")]
192pub type CSSM_VERSION_PTR = *mut cssm_version;
193
194#[cfg(feature = "cssmconfig")]
196pub type CSSM_SERVICE_MASK = uint32;
197
198pub const CSSM_SERVICE_CSSM: c_uint = 1;
200pub const CSSM_SERVICE_CSP: c_uint = 2;
202pub const CSSM_SERVICE_DL: c_uint = 4;
204pub const CSSM_SERVICE_CL: c_uint = 8;
206pub const CSSM_SERVICE_TP: c_uint = 16;
208pub const CSSM_SERVICE_AC: c_uint = 32;
210pub const CSSM_SERVICE_KR: c_uint = 64;
212
213#[cfg(feature = "cssmconfig")]
215pub type CSSM_SERVICE_TYPE = CSSM_SERVICE_MASK;
216
217#[cfg(feature = "cssmconfig")]
219#[deprecated]
220#[repr(C)]
221#[derive(Clone, Copy, Debug, PartialEq)]
222pub struct cssm_subservice_uid {
223 pub Guid: CSSM_GUID,
224 pub Version: CSSM_VERSION,
225 pub SubserviceId: uint32,
226 pub SubserviceType: CSSM_SERVICE_TYPE,
227}
228
229#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
230unsafe impl Encode for cssm_subservice_uid {
231 const ENCODING: Encoding = Encoding::Struct(
232 "cssm_subservice_uid",
233 &[
234 <CSSM_GUID>::ENCODING,
235 <CSSM_VERSION>::ENCODING,
236 <uint32>::ENCODING,
237 <CSSM_SERVICE_TYPE>::ENCODING,
238 ],
239 );
240}
241
242#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
243unsafe impl RefEncode for cssm_subservice_uid {
244 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
245}
246
247#[deprecated]
249#[cfg(feature = "cssmconfig")]
250pub type CSSM_SUBSERVICE_UID = cssm_subservice_uid;
251
252#[deprecated]
254#[cfg(feature = "cssmconfig")]
255pub type CSSM_SUBSERVICE_UID_PTR = *mut cssm_subservice_uid;
256
257#[cfg(feature = "cssmconfig")]
259pub type CSSM_MODULE_EVENT = uint32;
260
261#[cfg(feature = "cssmconfig")]
263pub type CSSM_MODULE_EVENT_PTR = *mut uint32;
264
265pub const CSSM_NOTIFY_INSERT: c_uint = 1;
267pub const CSSM_NOTIFY_REMOVE: c_uint = 2;
269pub const CSSM_NOTIFY_FAULT: c_uint = 3;
271
272#[deprecated]
274#[cfg(feature = "cssmconfig")]
275pub type CSSM_API_ModuleEventHandler = Option<
276 unsafe extern "C-unwind" fn(
277 *const CSSM_GUID,
278 *mut c_void,
279 uint32,
280 CSSM_SERVICE_TYPE,
281 CSSM_MODULE_EVENT,
282 ) -> CSSM_RETURN,
283>;
284
285#[cfg(feature = "cssmconfig")]
287pub type CSSM_ATTACH_FLAGS = uint32;
288
289pub const CSSM_ATTACH_READ_ONLY: c_uint = 1;
291
292#[cfg(feature = "cssmconfig")]
294pub type CSSM_PRIVILEGE = uint64;
295
296#[cfg(feature = "cssmconfig")]
298pub type CSSM_USEE_TAG = CSSM_PRIVILEGE;
299
300pub const CSSM_USEE_LAST: c_uint = 255;
302pub const CSSM_USEE_NONE: c_uint = 0;
304pub const CSSM_USEE_DOMESTIC: c_uint = 1;
306pub const CSSM_USEE_FINANCIAL: c_uint = 2;
308pub const CSSM_USEE_KRLE: c_uint = 3;
310pub const CSSM_USEE_KRENT: c_uint = 4;
312pub const CSSM_USEE_SSL: c_uint = 5;
314pub const CSSM_USEE_AUTHENTICATION: c_uint = 6;
316pub const CSSM_USEE_KEYEXCH: c_uint = 7;
318pub const CSSM_USEE_MEDICAL: c_uint = 8;
320pub const CSSM_USEE_INSURANCE: c_uint = 9;
322pub const CSSM_USEE_WEAK: c_uint = 10;
324
325#[cfg(feature = "cssmconfig")]
327pub type CSSM_NET_ADDRESS_TYPE = uint32;
328
329pub const CSSM_ADDR_NONE: c_uint = 0;
331pub const CSSM_ADDR_CUSTOM: c_uint = 1;
333pub const CSSM_ADDR_URL: c_uint = 2;
335pub const CSSM_ADDR_SOCKADDR: c_uint = 3;
337pub const CSSM_ADDR_NAME: c_uint = 4;
339
340#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
342#[deprecated]
343#[repr(C)]
344#[derive(Clone, Copy, Debug, PartialEq)]
345pub struct cssm_net_address {
346 pub AddressType: CSSM_NET_ADDRESS_TYPE,
347 pub Address: SecAsn1Item,
348}
349
350#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
351unsafe impl Encode for cssm_net_address {
352 const ENCODING: Encoding = Encoding::Struct(
353 "cssm_net_address",
354 &[<CSSM_NET_ADDRESS_TYPE>::ENCODING, <SecAsn1Item>::ENCODING],
355 );
356}
357
358#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
359unsafe impl RefEncode for cssm_net_address {
360 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
361}
362
363#[deprecated]
365#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
366pub type CSSM_NET_ADDRESS = cssm_net_address;
367
368#[deprecated]
370#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
371pub type CSSM_NET_ADDRESS_PTR = *mut cssm_net_address;
372
373#[cfg(feature = "cssmconfig")]
375pub type CSSM_NET_PROTOCOL = uint32;
376
377pub const CSSM_NET_PROTO_NONE: c_uint = 0;
379pub const CSSM_NET_PROTO_CUSTOM: c_uint = 1;
381pub const CSSM_NET_PROTO_UNSPECIFIED: c_uint = 2;
383pub const CSSM_NET_PROTO_LDAP: c_uint = 3;
385pub const CSSM_NET_PROTO_LDAPS: c_uint = 4;
387pub const CSSM_NET_PROTO_LDAPNS: c_uint = 5;
389pub const CSSM_NET_PROTO_X500DAP: c_uint = 6;
391pub const CSSM_NET_PROTO_FTP: c_uint = 7;
393pub const CSSM_NET_PROTO_FTPS: c_uint = 8;
395pub const CSSM_NET_PROTO_OCSP: c_uint = 9;
397pub const CSSM_NET_PROTO_CMP: c_uint = 10;
399pub const CSSM_NET_PROTO_CMPS: c_uint = 11;
401
402#[deprecated]
404#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
405pub type CSSM_CALLBACK =
406 Option<unsafe extern "C-unwind" fn(CSSM_DATA_PTR, *mut c_void) -> CSSM_RETURN>;
407
408#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
410#[deprecated]
411#[repr(C)]
412#[allow(unpredictable_function_pointer_comparisons)]
413#[derive(Clone, Copy, Debug, PartialEq)]
414pub struct cssm_crypto_data {
415 pub Param: SecAsn1Item,
416 pub Callback: CSSM_CALLBACK,
417 pub CallerCtx: *mut c_void,
418}
419
420#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
421unsafe impl Encode for cssm_crypto_data {
422 const ENCODING: Encoding = Encoding::Struct(
423 "cssm_crypto_data",
424 &[
425 <SecAsn1Item>::ENCODING,
426 <CSSM_CALLBACK>::ENCODING,
427 <*mut c_void>::ENCODING,
428 ],
429 );
430}
431
432#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
433unsafe impl RefEncode for cssm_crypto_data {
434 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
435}
436
437#[deprecated]
439#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
440pub type CSSM_CRYPTO_DATA = cssm_crypto_data;
441
442#[deprecated]
444#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
445pub type CSSM_CRYPTO_DATA_PTR = *mut cssm_crypto_data;
446
447#[cfg(feature = "cssmconfig")]
449pub type CSSM_WORDID_TYPE = sint32;
450
451pub const CSSM_WORDID__UNK_: c_int = -1;
453pub const CSSM_WORDID__NLU_: c_int = 0;
455pub const CSSM_WORDID__STAR_: c_int = 1;
457pub const CSSM_WORDID_A: c_int = 2;
459pub const CSSM_WORDID_ACL: c_int = 3;
461pub const CSSM_WORDID_ALPHA: c_int = 4;
463pub const CSSM_WORDID_B: c_int = 5;
465pub const CSSM_WORDID_BER: c_int = 6;
467pub const CSSM_WORDID_BINARY: c_int = 7;
469pub const CSSM_WORDID_BIOMETRIC: c_int = 8;
471pub const CSSM_WORDID_C: c_int = 9;
473pub const CSSM_WORDID_CANCELED: c_int = 10;
475pub const CSSM_WORDID_CERT: c_int = 11;
477pub const CSSM_WORDID_COMMENT: c_int = 12;
479pub const CSSM_WORDID_CRL: c_int = 13;
481pub const CSSM_WORDID_CUSTOM: c_int = 14;
483pub const CSSM_WORDID_D: c_int = 15;
485pub const CSSM_WORDID_DATE: c_int = 16;
487pub const CSSM_WORDID_DB_DELETE: c_int = 17;
489pub const CSSM_WORDID_DB_EXEC_STORED_QUERY: c_int = 18;
491pub const CSSM_WORDID_DB_INSERT: c_int = 19;
493pub const CSSM_WORDID_DB_MODIFY: c_int = 20;
495pub const CSSM_WORDID_DB_READ: c_int = 21;
497pub const CSSM_WORDID_DBS_CREATE: c_int = 22;
499pub const CSSM_WORDID_DBS_DELETE: c_int = 23;
501pub const CSSM_WORDID_DECRYPT: c_int = 24;
503pub const CSSM_WORDID_DELETE: c_int = 25;
505pub const CSSM_WORDID_DELTA_CRL: c_int = 26;
507pub const CSSM_WORDID_DER: c_int = 27;
509pub const CSSM_WORDID_DERIVE: c_int = 28;
511pub const CSSM_WORDID_DISPLAY: c_int = 29;
513pub const CSSM_WORDID_DO: c_int = 30;
515pub const CSSM_WORDID_DSA: c_int = 31;
517pub const CSSM_WORDID_DSA_SHA1: c_int = 32;
519pub const CSSM_WORDID_E: c_int = 33;
521pub const CSSM_WORDID_ELGAMAL: c_int = 34;
523pub const CSSM_WORDID_ENCRYPT: c_int = 35;
525pub const CSSM_WORDID_ENTRY: c_int = 36;
527pub const CSSM_WORDID_EXPORT_CLEAR: c_int = 37;
529pub const CSSM_WORDID_EXPORT_WRAPPED: c_int = 38;
531pub const CSSM_WORDID_G: c_int = 39;
533pub const CSSM_WORDID_GE: c_int = 40;
535pub const CSSM_WORDID_GENKEY: c_int = 41;
537pub const CSSM_WORDID_HASH: c_int = 42;
539pub const CSSM_WORDID_HASHED_PASSWORD: c_int = 43;
541pub const CSSM_WORDID_HASHED_SUBJECT: c_int = 44;
543pub const CSSM_WORDID_HAVAL: c_int = 45;
545pub const CSSM_WORDID_IBCHASH: c_int = 46;
547pub const CSSM_WORDID_IMPORT_CLEAR: c_int = 47;
549pub const CSSM_WORDID_IMPORT_WRAPPED: c_int = 48;
551pub const CSSM_WORDID_INTEL: c_int = 49;
553pub const CSSM_WORDID_ISSUER: c_int = 50;
555pub const CSSM_WORDID_ISSUER_INFO: c_int = 51;
557pub const CSSM_WORDID_K_OF_N: c_int = 52;
559pub const CSSM_WORDID_KEA: c_int = 53;
561pub const CSSM_WORDID_KEYHOLDER: c_int = 54;
563pub const CSSM_WORDID_L: c_int = 55;
565pub const CSSM_WORDID_LE: c_int = 56;
567pub const CSSM_WORDID_LOGIN: c_int = 57;
569pub const CSSM_WORDID_LOGIN_NAME: c_int = 58;
571pub const CSSM_WORDID_MAC: c_int = 59;
573pub const CSSM_WORDID_MD2: c_int = 60;
575pub const CSSM_WORDID_MD2WITHRSA: c_int = 61;
577pub const CSSM_WORDID_MD4: c_int = 62;
579pub const CSSM_WORDID_MD5: c_int = 63;
581pub const CSSM_WORDID_MD5WITHRSA: c_int = 64;
583pub const CSSM_WORDID_N: c_int = 65;
585pub const CSSM_WORDID_NAME: c_int = 66;
587pub const CSSM_WORDID_NDR: c_int = 67;
589pub const CSSM_WORDID_NHASH: c_int = 68;
591pub const CSSM_WORDID_NOT_AFTER: c_int = 69;
593pub const CSSM_WORDID_NOT_BEFORE: c_int = 70;
595pub const CSSM_WORDID_NULL: c_int = 71;
597pub const CSSM_WORDID_NUMERIC: c_int = 72;
599pub const CSSM_WORDID_OBJECT_HASH: c_int = 73;
601pub const CSSM_WORDID_ONE_TIME: c_int = 74;
603pub const CSSM_WORDID_ONLINE: c_int = 75;
605pub const CSSM_WORDID_OWNER: c_int = 76;
607pub const CSSM_WORDID_P: c_int = 77;
609pub const CSSM_WORDID_PAM_NAME: c_int = 78;
611pub const CSSM_WORDID_PASSWORD: c_int = 79;
613pub const CSSM_WORDID_PGP: c_int = 80;
615pub const CSSM_WORDID_PREFIX: c_int = 81;
617pub const CSSM_WORDID_PRIVATE_KEY: c_int = 82;
619pub const CSSM_WORDID_PROMPTED_BIOMETRIC: c_int = 83;
621pub const CSSM_WORDID_PROMPTED_PASSWORD: c_int = 84;
623pub const CSSM_WORDID_PROPAGATE: c_int = 85;
625pub const CSSM_WORDID_PROTECTED_BIOMETRIC: c_int = 86;
627pub const CSSM_WORDID_PROTECTED_PASSWORD: c_int = 87;
629pub const CSSM_WORDID_PROTECTED_PIN: c_int = 88;
631pub const CSSM_WORDID_PUBLIC_KEY: c_int = 89;
633pub const CSSM_WORDID_PUBLIC_KEY_FROM_CERT: c_int = 90;
635pub const CSSM_WORDID_Q: c_int = 91;
637pub const CSSM_WORDID_RANGE: c_int = 92;
639pub const CSSM_WORDID_REVAL: c_int = 93;
641pub const CSSM_WORDID_RIPEMAC: c_int = 94;
643pub const CSSM_WORDID_RIPEMD: c_int = 95;
645pub const CSSM_WORDID_RIPEMD160: c_int = 96;
647pub const CSSM_WORDID_RSA: c_int = 97;
649pub const CSSM_WORDID_RSA_ISO9796: c_int = 98;
651pub const CSSM_WORDID_RSA_PKCS: c_int = 99;
653pub const CSSM_WORDID_RSA_PKCS_MD5: c_int = 100;
655pub const CSSM_WORDID_RSA_PKCS_SHA1: c_int = 101;
657pub const CSSM_WORDID_RSA_PKCS1: c_int = 102;
659pub const CSSM_WORDID_RSA_PKCS1_MD5: c_int = 103;
661pub const CSSM_WORDID_RSA_PKCS1_SHA1: c_int = 104;
663pub const CSSM_WORDID_RSA_PKCS1_SIG: c_int = 105;
665pub const CSSM_WORDID_RSA_RAW: c_int = 106;
667pub const CSSM_WORDID_SDSIV1: c_int = 107;
669pub const CSSM_WORDID_SEQUENCE: c_int = 108;
671pub const CSSM_WORDID_SET: c_int = 109;
673pub const CSSM_WORDID_SEXPR: c_int = 110;
675pub const CSSM_WORDID_SHA1: c_int = 111;
677pub const CSSM_WORDID_SHA1WITHDSA: c_int = 112;
679pub const CSSM_WORDID_SHA1WITHECDSA: c_int = 113;
681pub const CSSM_WORDID_SHA1WITHRSA: c_int = 114;
683pub const CSSM_WORDID_SIGN: c_int = 115;
685pub const CSSM_WORDID_SIGNATURE: c_int = 116;
687pub const CSSM_WORDID_SIGNED_NONCE: c_int = 117;
689pub const CSSM_WORDID_SIGNED_SECRET: c_int = 118;
691pub const CSSM_WORDID_SPKI: c_int = 119;
693pub const CSSM_WORDID_SUBJECT: c_int = 120;
695pub const CSSM_WORDID_SUBJECT_INFO: c_int = 121;
697pub const CSSM_WORDID_TAG: c_int = 122;
699pub const CSSM_WORDID_THRESHOLD: c_int = 123;
701pub const CSSM_WORDID_TIME: c_int = 124;
703pub const CSSM_WORDID_URI: c_int = 125;
705pub const CSSM_WORDID_VERSION: c_int = 126;
707pub const CSSM_WORDID_X509_ATTRIBUTE: c_int = 127;
709pub const CSSM_WORDID_X509V1: c_int = 128;
711pub const CSSM_WORDID_X509V2: c_int = 129;
713pub const CSSM_WORDID_X509V3: c_int = 130;
715pub const CSSM_WORDID_X9_ATTRIBUTE: c_int = 131;
717pub const CSSM_WORDID_VENDOR_START: c_int = 65536;
719pub const CSSM_WORDID_VENDOR_END: c_int = 2147418112;
721
722#[cfg(feature = "cssmconfig")]
724pub type CSSM_LIST_ELEMENT_TYPE = uint32;
725
726#[cfg(feature = "cssmconfig")]
728pub type CSSM_LIST_ELEMENT_TYPE_PTR = *mut uint32;
729
730pub const CSSM_LIST_ELEMENT_DATUM: c_uint = 0;
732pub const CSSM_LIST_ELEMENT_SUBLIST: c_uint = 1;
734pub const CSSM_LIST_ELEMENT_WORDID: c_uint = 2;
736
737#[cfg(feature = "cssmconfig")]
739pub type CSSM_LIST_TYPE = uint32;
740
741#[cfg(feature = "cssmconfig")]
743pub type CSSM_LIST_TYPE_PTR = *mut uint32;
744
745pub const CSSM_LIST_TYPE_UNKNOWN: c_uint = 0;
747pub const CSSM_LIST_TYPE_CUSTOM: c_uint = 1;
749pub const CSSM_LIST_TYPE_SEXPR: c_uint = 2;
751
752pub type CSSM_LIST_ELEMENT_PTR = *mut cssm_list_element;
754
755#[cfg(feature = "cssmconfig")]
757#[repr(C)]
758#[derive(Clone, Copy, Debug, PartialEq)]
759pub struct cssm_list {
760 pub ListType: CSSM_LIST_TYPE,
761 pub Head: CSSM_LIST_ELEMENT_PTR,
762 pub Tail: CSSM_LIST_ELEMENT_PTR,
763}
764
765#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
766unsafe impl Encode for cssm_list {
767 const ENCODING: Encoding = Encoding::Struct(
768 "cssm_list",
769 &[
770 <CSSM_LIST_TYPE>::ENCODING,
771 <CSSM_LIST_ELEMENT_PTR>::ENCODING,
772 <CSSM_LIST_ELEMENT_PTR>::ENCODING,
773 ],
774 );
775}
776
777#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
778unsafe impl RefEncode for cssm_list {
779 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
780}
781
782#[deprecated]
784#[cfg(feature = "cssmconfig")]
785pub type CSSM_LIST = cssm_list;
786
787#[deprecated]
789#[cfg(feature = "cssmconfig")]
790pub type CSSM_LIST_PTR = *mut cssm_list;
791
792#[deprecated]
794pub type CSSM_LIST_ELEMENT = cssm_list_element;
795
796#[cfg(feature = "cssmconfig")]
798#[deprecated]
799#[repr(C)]
800#[derive(Clone, Copy, Debug, PartialEq)]
801pub struct CSSM_TUPLE {
802 pub Issuer: CSSM_LIST,
803 pub Subject: CSSM_LIST,
804 pub Delegate: CSSM_BOOL,
805 pub AuthorizationTag: CSSM_LIST,
806 pub ValidityPeriod: CSSM_LIST,
807}
808
809#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
810unsafe impl Encode for CSSM_TUPLE {
811 const ENCODING: Encoding = Encoding::Struct(
812 "?",
813 &[
814 <CSSM_LIST>::ENCODING,
815 <CSSM_LIST>::ENCODING,
816 <CSSM_BOOL>::ENCODING,
817 <CSSM_LIST>::ENCODING,
818 <CSSM_LIST>::ENCODING,
819 ],
820 );
821}
822
823#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
824unsafe impl RefEncode for CSSM_TUPLE {
825 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
826}
827
828#[deprecated]
830#[cfg(feature = "cssmconfig")]
831pub type CSSM_TUPLE_PTR = *mut CSSM_TUPLE;
832
833#[cfg(feature = "cssmconfig")]
835#[deprecated]
836#[repr(C)]
837#[derive(Clone, Copy, Debug, PartialEq)]
838pub struct cssm_tuplegroup {
839 pub NumberOfTuples: uint32,
840 pub Tuples: CSSM_TUPLE_PTR,
841}
842
843#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
844unsafe impl Encode for cssm_tuplegroup {
845 const ENCODING: Encoding = Encoding::Struct(
846 "cssm_tuplegroup",
847 &[<uint32>::ENCODING, <CSSM_TUPLE_PTR>::ENCODING],
848 );
849}
850
851#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
852unsafe impl RefEncode for cssm_tuplegroup {
853 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
854}
855
856#[deprecated]
858#[cfg(feature = "cssmconfig")]
859pub type CSSM_TUPLEGROUP = cssm_tuplegroup;
860
861#[deprecated]
863#[cfg(feature = "cssmconfig")]
864pub type CSSM_TUPLEGROUP_PTR = *mut cssm_tuplegroup;
865
866#[cfg(feature = "cssmconfig")]
868pub type CSSM_SAMPLE_TYPE = CSSM_WORDID_TYPE;
869
870pub const CSSM_SAMPLE_TYPE_PASSWORD: c_uint = 79;
872pub const CSSM_SAMPLE_TYPE_HASHED_PASSWORD: c_uint = 43;
874pub const CSSM_SAMPLE_TYPE_PROTECTED_PASSWORD: c_uint = 87;
876pub const CSSM_SAMPLE_TYPE_PROMPTED_PASSWORD: c_uint = 84;
878pub const CSSM_SAMPLE_TYPE_SIGNED_NONCE: c_uint = 117;
880pub const CSSM_SAMPLE_TYPE_SIGNED_SECRET: c_uint = 118;
882pub const CSSM_SAMPLE_TYPE_BIOMETRIC: c_uint = 8;
884pub const CSSM_SAMPLE_TYPE_PROTECTED_BIOMETRIC: c_uint = 86;
886pub const CSSM_SAMPLE_TYPE_PROMPTED_BIOMETRIC: c_uint = 83;
888pub const CSSM_SAMPLE_TYPE_THRESHOLD: c_uint = 123;
890
891#[cfg(feature = "cssmconfig")]
893#[deprecated]
894#[repr(C)]
895#[derive(Clone, Copy, Debug, PartialEq)]
896pub struct cssm_sample {
897 pub TypedSample: CSSM_LIST,
898 pub Verifier: *const CSSM_SUBSERVICE_UID,
899}
900
901#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
902unsafe impl Encode for cssm_sample {
903 const ENCODING: Encoding = Encoding::Struct(
904 "cssm_sample",
905 &[
906 <CSSM_LIST>::ENCODING,
907 <*const CSSM_SUBSERVICE_UID>::ENCODING,
908 ],
909 );
910}
911
912#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
913unsafe impl RefEncode for cssm_sample {
914 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
915}
916
917#[deprecated]
919#[cfg(feature = "cssmconfig")]
920pub type CSSM_SAMPLE = cssm_sample;
921
922#[deprecated]
924#[cfg(feature = "cssmconfig")]
925pub type CSSM_SAMPLE_PTR = *mut cssm_sample;
926
927#[cfg(feature = "cssmconfig")]
929#[deprecated]
930#[repr(C)]
931#[derive(Clone, Copy, Debug, PartialEq)]
932pub struct cssm_samplegroup {
933 pub NumberOfSamples: uint32,
934 pub Samples: *const CSSM_SAMPLE,
935}
936
937#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
938unsafe impl Encode for cssm_samplegroup {
939 const ENCODING: Encoding = Encoding::Struct(
940 "cssm_samplegroup",
941 &[<uint32>::ENCODING, <*const CSSM_SAMPLE>::ENCODING],
942 );
943}
944
945#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
946unsafe impl RefEncode for cssm_samplegroup {
947 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
948}
949
950#[deprecated]
952#[cfg(feature = "cssmconfig")]
953pub type CSSM_SAMPLEGROUP = cssm_samplegroup;
954
955#[deprecated]
957#[cfg(feature = "cssmconfig")]
958pub type CSSM_SAMPLEGROUP_PTR = *mut cssm_samplegroup;
959
960#[cfg(feature = "cssmconfig")]
962pub type CSSM_MALLOC = Option<unsafe extern "C-unwind" fn(CSSM_SIZE, *mut c_void) -> *mut c_void>;
963
964pub type CSSM_FREE = Option<unsafe extern "C-unwind" fn(*mut c_void, *mut c_void)>;
966
967#[cfg(feature = "cssmconfig")]
969pub type CSSM_REALLOC =
970 Option<unsafe extern "C-unwind" fn(*mut c_void, CSSM_SIZE, *mut c_void) -> *mut c_void>;
971
972#[cfg(feature = "cssmconfig")]
974pub type CSSM_CALLOC =
975 Option<unsafe extern "C-unwind" fn(uint32, CSSM_SIZE, *mut c_void) -> *mut c_void>;
976
977#[cfg(feature = "cssmconfig")]
979#[repr(C)]
980#[allow(unpredictable_function_pointer_comparisons)]
981#[derive(Clone, Copy, Debug, PartialEq)]
982pub struct cssm_memory_funcs {
983 pub malloc_func: CSSM_MALLOC,
984 pub free_func: CSSM_FREE,
985 pub realloc_func: CSSM_REALLOC,
986 pub calloc_func: CSSM_CALLOC,
987 pub AllocRef: *mut c_void,
988}
989
990#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
991unsafe impl Encode for cssm_memory_funcs {
992 const ENCODING: Encoding = Encoding::Struct(
993 "cssm_memory_funcs",
994 &[
995 <CSSM_MALLOC>::ENCODING,
996 <CSSM_FREE>::ENCODING,
997 <CSSM_REALLOC>::ENCODING,
998 <CSSM_CALLOC>::ENCODING,
999 <*mut c_void>::ENCODING,
1000 ],
1001 );
1002}
1003
1004#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1005unsafe impl RefEncode for cssm_memory_funcs {
1006 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1007}
1008
1009#[deprecated]
1011#[cfg(feature = "cssmconfig")]
1012pub type CSSM_MEMORY_FUNCS = cssm_memory_funcs;
1013
1014#[deprecated]
1016#[cfg(feature = "cssmconfig")]
1017pub type CSSM_MEMORY_FUNCS_PTR = *mut cssm_memory_funcs;
1018
1019#[deprecated]
1021#[cfg(feature = "cssmconfig")]
1022pub type CSSM_API_MEMORY_FUNCS = CSSM_MEMORY_FUNCS;
1023
1024#[deprecated]
1026#[cfg(feature = "cssmconfig")]
1027pub type CSSM_API_MEMORY_FUNCS_PTR = *mut CSSM_API_MEMORY_FUNCS;
1028
1029#[deprecated]
1031#[cfg(feature = "cssmconfig")]
1032pub type CSSM_CHALLENGE_CALLBACK = Option<
1033 unsafe extern "C-unwind" fn(
1034 *const CSSM_LIST,
1035 CSSM_SAMPLEGROUP_PTR,
1036 *mut c_void,
1037 *const CSSM_MEMORY_FUNCS,
1038 ) -> CSSM_RETURN,
1039>;
1040
1041#[cfg(feature = "cssmconfig")]
1043pub type CSSM_CERT_TYPE = uint32;
1044
1045#[cfg(feature = "cssmconfig")]
1047pub type CSSM_CERT_TYPE_PTR = *mut uint32;
1048
1049pub const CSSM_CERT_UNKNOWN: c_uint = 0;
1051pub const CSSM_CERT_X_509v1: c_uint = 1;
1053pub const CSSM_CERT_X_509v2: c_uint = 2;
1055pub const CSSM_CERT_X_509v3: c_uint = 3;
1057pub const CSSM_CERT_PGP: c_uint = 4;
1059pub const CSSM_CERT_SPKI: c_uint = 5;
1061pub const CSSM_CERT_SDSIv1: c_uint = 6;
1063pub const CSSM_CERT_Intel: c_uint = 8;
1065pub const CSSM_CERT_X_509_ATTRIBUTE: c_uint = 9;
1067pub const CSSM_CERT_X9_ATTRIBUTE: c_uint = 10;
1069pub const CSSM_CERT_TUPLE: c_uint = 11;
1071pub const CSSM_CERT_ACL_ENTRY: c_uint = 12;
1073pub const CSSM_CERT_MULTIPLE: c_uint = 32766;
1075pub const CSSM_CERT_LAST: c_uint = 32767;
1077pub const CSSM_CL_CUSTOM_CERT_TYPE: c_uint = 32768;
1079
1080#[cfg(feature = "cssmconfig")]
1082pub type CSSM_CERT_ENCODING = uint32;
1083
1084#[cfg(feature = "cssmconfig")]
1086pub type CSSM_CERT_ENCODING_PTR = *mut uint32;
1087
1088pub const CSSM_CERT_ENCODING_UNKNOWN: c_uint = 0;
1090pub const CSSM_CERT_ENCODING_CUSTOM: c_uint = 1;
1092pub const CSSM_CERT_ENCODING_BER: c_uint = 2;
1094pub const CSSM_CERT_ENCODING_DER: c_uint = 3;
1096pub const CSSM_CERT_ENCODING_NDR: c_uint = 4;
1098pub const CSSM_CERT_ENCODING_SEXPR: c_uint = 5;
1100pub const CSSM_CERT_ENCODING_PGP: c_uint = 6;
1102pub const CSSM_CERT_ENCODING_MULTIPLE: c_uint = 32766;
1104pub const CSSM_CERT_ENCODING_LAST: c_uint = 32767;
1106pub const CSSM_CL_CUSTOM_CERT_ENCODING: c_uint = 32768;
1108
1109#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1111#[deprecated]
1112#[repr(C)]
1113#[derive(Clone, Copy, Debug, PartialEq)]
1114pub struct cssm_encoded_cert {
1115 pub CertType: CSSM_CERT_TYPE,
1116 pub CertEncoding: CSSM_CERT_ENCODING,
1117 pub CertBlob: SecAsn1Item,
1118}
1119
1120#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1121unsafe impl Encode for cssm_encoded_cert {
1122 const ENCODING: Encoding = Encoding::Struct(
1123 "cssm_encoded_cert",
1124 &[
1125 <CSSM_CERT_TYPE>::ENCODING,
1126 <CSSM_CERT_ENCODING>::ENCODING,
1127 <SecAsn1Item>::ENCODING,
1128 ],
1129 );
1130}
1131
1132#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1133unsafe impl RefEncode for cssm_encoded_cert {
1134 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1135}
1136
1137#[deprecated]
1139#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1140pub type CSSM_ENCODED_CERT = cssm_encoded_cert;
1141
1142#[deprecated]
1144#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1145pub type CSSM_ENCODED_CERT_PTR = *mut cssm_encoded_cert;
1146
1147#[cfg(feature = "cssmconfig")]
1149pub type CSSM_CERT_PARSE_FORMAT = uint32;
1150
1151#[cfg(feature = "cssmconfig")]
1153pub type CSSM_CERT_PARSE_FORMAT_PTR = *mut uint32;
1154
1155pub const CSSM_CERT_PARSE_FORMAT_NONE: c_uint = 0;
1157pub const CSSM_CERT_PARSE_FORMAT_CUSTOM: c_uint = 1;
1159pub const CSSM_CERT_PARSE_FORMAT_SEXPR: c_uint = 2;
1161pub const CSSM_CERT_PARSE_FORMAT_COMPLEX: c_uint = 3;
1163pub const CSSM_CERT_PARSE_FORMAT_OID_NAMED: c_uint = 4;
1165pub const CSSM_CERT_PARSE_FORMAT_TUPLE: c_uint = 5;
1167pub const CSSM_CERT_PARSE_FORMAT_MULTIPLE: c_uint = 32766;
1169pub const CSSM_CERT_PARSE_FORMAT_LAST: c_uint = 32767;
1171pub const CSSM_CL_CUSTOM_CERT_PARSE_FORMAT: c_uint = 32768;
1173
1174#[cfg(feature = "cssmconfig")]
1176#[repr(C)]
1177#[derive(Clone, Copy, Debug, PartialEq)]
1178pub struct cssm_parsed_cert {
1179 pub CertType: CSSM_CERT_TYPE,
1180 pub ParsedCertFormat: CSSM_CERT_PARSE_FORMAT,
1181 pub ParsedCert: *mut c_void,
1182}
1183
1184#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1185unsafe impl Encode for cssm_parsed_cert {
1186 const ENCODING: Encoding = Encoding::Struct(
1187 "cssm_parsed_cert",
1188 &[
1189 <CSSM_CERT_TYPE>::ENCODING,
1190 <CSSM_CERT_PARSE_FORMAT>::ENCODING,
1191 <*mut c_void>::ENCODING,
1192 ],
1193 );
1194}
1195
1196#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1197unsafe impl RefEncode for cssm_parsed_cert {
1198 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1199}
1200
1201#[deprecated]
1203#[cfg(feature = "cssmconfig")]
1204pub type CSSM_PARSED_CERT = cssm_parsed_cert;
1205
1206#[deprecated]
1208#[cfg(feature = "cssmconfig")]
1209pub type CSSM_PARSED_CERT_PTR = *mut cssm_parsed_cert;
1210
1211#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1213#[deprecated]
1214#[repr(C)]
1215#[derive(Clone, Copy, Debug, PartialEq)]
1216pub struct cssm_cert_pair {
1217 pub EncodedCert: CSSM_ENCODED_CERT,
1218 pub ParsedCert: CSSM_PARSED_CERT,
1219}
1220
1221#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1222unsafe impl Encode for cssm_cert_pair {
1223 const ENCODING: Encoding = Encoding::Struct(
1224 "cssm_cert_pair",
1225 &[<CSSM_ENCODED_CERT>::ENCODING, <CSSM_PARSED_CERT>::ENCODING],
1226 );
1227}
1228
1229#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1230unsafe impl RefEncode for cssm_cert_pair {
1231 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1232}
1233
1234#[deprecated]
1236#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1237pub type CSSM_CERT_PAIR = cssm_cert_pair;
1238
1239#[deprecated]
1241#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1242pub type CSSM_CERT_PAIR_PTR = *mut cssm_cert_pair;
1243
1244#[cfg(feature = "cssmconfig")]
1246pub type CSSM_CERTGROUP_TYPE = uint32;
1247
1248#[cfg(feature = "cssmconfig")]
1250pub type CSSM_CERTGROUP_TYPE_PTR = *mut uint32;
1251
1252pub const CSSM_CERTGROUP_DATA: c_uint = 0;
1254pub const CSSM_CERTGROUP_ENCODED_CERT: c_uint = 1;
1256pub const CSSM_CERTGROUP_PARSED_CERT: c_uint = 2;
1258pub const CSSM_CERTGROUP_CERT_PAIR: c_uint = 3;
1260
1261#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1263#[repr(C)]
1264#[derive(Clone, Copy)]
1265pub union cssm_certgroup_GroupList {
1266 pub CertList: CSSM_DATA_PTR,
1267 pub EncodedCertList: CSSM_ENCODED_CERT_PTR,
1268 pub ParsedCertList: CSSM_PARSED_CERT_PTR,
1269 pub PairCertList: CSSM_CERT_PAIR_PTR,
1270}
1271
1272#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1273unsafe impl Encode for cssm_certgroup_GroupList {
1274 const ENCODING: Encoding = Encoding::Union(
1275 "?",
1276 &[
1277 <CSSM_DATA_PTR>::ENCODING,
1278 <CSSM_ENCODED_CERT_PTR>::ENCODING,
1279 <CSSM_PARSED_CERT_PTR>::ENCODING,
1280 <CSSM_CERT_PAIR_PTR>::ENCODING,
1281 ],
1282 );
1283}
1284
1285#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1286unsafe impl RefEncode for cssm_certgroup_GroupList {
1287 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1288}
1289
1290#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1292#[deprecated]
1293#[repr(C)]
1294#[derive(Clone, Copy)]
1295pub struct cssm_certgroup {
1296 pub CertType: CSSM_CERT_TYPE,
1297 pub CertEncoding: CSSM_CERT_ENCODING,
1298 pub NumCerts: uint32,
1299 pub GroupList: cssm_certgroup_GroupList,
1300 pub CertGroupType: CSSM_CERTGROUP_TYPE,
1301 pub Reserved: *mut c_void,
1302}
1303
1304#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1305unsafe impl Encode for cssm_certgroup {
1306 const ENCODING: Encoding = Encoding::Struct(
1307 "cssm_certgroup",
1308 &[
1309 <CSSM_CERT_TYPE>::ENCODING,
1310 <CSSM_CERT_ENCODING>::ENCODING,
1311 <uint32>::ENCODING,
1312 <cssm_certgroup_GroupList>::ENCODING,
1313 <CSSM_CERTGROUP_TYPE>::ENCODING,
1314 <*mut c_void>::ENCODING,
1315 ],
1316 );
1317}
1318
1319#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1320unsafe impl RefEncode for cssm_certgroup {
1321 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1322}
1323
1324#[deprecated]
1326#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1327pub type CSSM_CERTGROUP = cssm_certgroup;
1328
1329#[deprecated]
1331#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1332pub type CSSM_CERTGROUP_PTR = *mut cssm_certgroup;
1333
1334#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1336#[deprecated]
1337#[repr(C)]
1338#[derive(Clone, Copy)]
1339pub struct cssm_base_certs {
1340 pub TPHandle: CSSM_TP_HANDLE,
1341 pub CLHandle: CSSM_CL_HANDLE,
1342 pub Certs: CSSM_CERTGROUP,
1343}
1344
1345#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1346unsafe impl Encode for cssm_base_certs {
1347 const ENCODING: Encoding = Encoding::Struct(
1348 "cssm_base_certs",
1349 &[
1350 <CSSM_TP_HANDLE>::ENCODING,
1351 <CSSM_CL_HANDLE>::ENCODING,
1352 <CSSM_CERTGROUP>::ENCODING,
1353 ],
1354 );
1355}
1356
1357#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1358unsafe impl RefEncode for cssm_base_certs {
1359 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1360}
1361
1362#[deprecated]
1364#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1365pub type CSSM_BASE_CERTS = cssm_base_certs;
1366
1367#[deprecated]
1369#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1370pub type CSSM_BASE_CERTS_PTR = *mut cssm_base_certs;
1371
1372#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1374#[deprecated]
1375#[repr(C)]
1376#[derive(Clone, Copy)]
1377pub struct cssm_access_credentials {
1378 pub EntryTag: CSSM_STRING,
1379 pub BaseCerts: CSSM_BASE_CERTS,
1380 pub Samples: CSSM_SAMPLEGROUP,
1381 pub Callback: CSSM_CHALLENGE_CALLBACK,
1382 pub CallerCtx: *mut c_void,
1383}
1384
1385#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1386unsafe impl Encode for cssm_access_credentials {
1387 const ENCODING: Encoding = Encoding::Struct(
1388 "cssm_access_credentials",
1389 &[
1390 <CSSM_STRING>::ENCODING,
1391 <CSSM_BASE_CERTS>::ENCODING,
1392 <CSSM_SAMPLEGROUP>::ENCODING,
1393 <CSSM_CHALLENGE_CALLBACK>::ENCODING,
1394 <*mut c_void>::ENCODING,
1395 ],
1396 );
1397}
1398
1399#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1400unsafe impl RefEncode for cssm_access_credentials {
1401 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1402}
1403
1404#[deprecated]
1406#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1407pub type CSSM_ACCESS_CREDENTIALS = cssm_access_credentials;
1408
1409#[deprecated]
1411#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1412pub type CSSM_ACCESS_CREDENTIALS_PTR = *mut cssm_access_credentials;
1413
1414#[cfg(feature = "cssmconfig")]
1416pub type CSSM_ACL_SUBJECT_TYPE = sint32;
1417
1418pub const CSSM_ACL_SUBJECT_TYPE_ANY: c_uint = 1;
1420pub const CSSM_ACL_SUBJECT_TYPE_THRESHOLD: c_uint = 123;
1422pub const CSSM_ACL_SUBJECT_TYPE_PASSWORD: c_uint = 79;
1424pub const CSSM_ACL_SUBJECT_TYPE_PROTECTED_PASSWORD: c_uint = 87;
1426pub const CSSM_ACL_SUBJECT_TYPE_PROMPTED_PASSWORD: c_uint = 84;
1428pub const CSSM_ACL_SUBJECT_TYPE_PUBLIC_KEY: c_uint = 89;
1430pub const CSSM_ACL_SUBJECT_TYPE_HASHED_SUBJECT: c_uint = 44;
1432pub const CSSM_ACL_SUBJECT_TYPE_BIOMETRIC: c_uint = 8;
1434pub const CSSM_ACL_SUBJECT_TYPE_PROTECTED_BIOMETRIC: c_uint = 86;
1436pub const CSSM_ACL_SUBJECT_TYPE_PROMPTED_BIOMETRIC: c_uint = 83;
1438pub const CSSM_ACL_SUBJECT_TYPE_LOGIN_NAME: c_uint = 58;
1440pub const CSSM_ACL_SUBJECT_TYPE_EXT_PAM_NAME: c_uint = 78;
1442
1443#[cfg(feature = "cssmconfig")]
1445pub type CSSM_ACL_AUTHORIZATION_TAG = sint32;
1446
1447pub const CSSM_ACL_AUTHORIZATION_TAG_VENDOR_DEFINED_START: c_uint = 65536;
1449pub const CSSM_ACL_AUTHORIZATION_ANY: c_uint = 1;
1451pub const CSSM_ACL_AUTHORIZATION_LOGIN: c_uint = 57;
1453pub const CSSM_ACL_AUTHORIZATION_GENKEY: c_uint = 41;
1455pub const CSSM_ACL_AUTHORIZATION_DELETE: c_uint = 25;
1457pub const CSSM_ACL_AUTHORIZATION_EXPORT_WRAPPED: c_uint = 38;
1459pub const CSSM_ACL_AUTHORIZATION_EXPORT_CLEAR: c_uint = 37;
1461pub const CSSM_ACL_AUTHORIZATION_IMPORT_WRAPPED: c_uint = 48;
1463pub const CSSM_ACL_AUTHORIZATION_IMPORT_CLEAR: c_uint = 47;
1465pub const CSSM_ACL_AUTHORIZATION_SIGN: c_uint = 115;
1467pub const CSSM_ACL_AUTHORIZATION_ENCRYPT: c_uint = 35;
1469pub const CSSM_ACL_AUTHORIZATION_DECRYPT: c_uint = 24;
1471pub const CSSM_ACL_AUTHORIZATION_MAC: c_uint = 59;
1473pub const CSSM_ACL_AUTHORIZATION_DERIVE: c_uint = 28;
1475pub const CSSM_ACL_AUTHORIZATION_DBS_CREATE: c_uint = 22;
1477pub const CSSM_ACL_AUTHORIZATION_DBS_DELETE: c_uint = 23;
1479pub const CSSM_ACL_AUTHORIZATION_DB_READ: c_uint = 21;
1481pub const CSSM_ACL_AUTHORIZATION_DB_INSERT: c_uint = 19;
1483pub const CSSM_ACL_AUTHORIZATION_DB_MODIFY: c_uint = 20;
1485pub const CSSM_ACL_AUTHORIZATION_DB_DELETE: c_uint = 17;
1487
1488#[cfg(feature = "cssmconfig")]
1490#[repr(C)]
1491#[derive(Clone, Copy, Debug, PartialEq)]
1492pub struct cssm_authorizationgroup {
1493 pub NumberOfAuthTags: uint32,
1494 pub AuthTags: *mut CSSM_ACL_AUTHORIZATION_TAG,
1495}
1496
1497#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1498unsafe impl Encode for cssm_authorizationgroup {
1499 const ENCODING: Encoding = Encoding::Struct(
1500 "cssm_authorizationgroup",
1501 &[
1502 <uint32>::ENCODING,
1503 <*mut CSSM_ACL_AUTHORIZATION_TAG>::ENCODING,
1504 ],
1505 );
1506}
1507
1508#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1509unsafe impl RefEncode for cssm_authorizationgroup {
1510 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1511}
1512
1513#[deprecated]
1515#[cfg(feature = "cssmconfig")]
1516pub type CSSM_AUTHORIZATIONGROUP = cssm_authorizationgroup;
1517
1518#[deprecated]
1520#[cfg(feature = "cssmconfig")]
1521pub type CSSM_AUTHORIZATIONGROUP_PTR = *mut cssm_authorizationgroup;
1522
1523#[cfg(feature = "SecAsn1Types")]
1525#[deprecated]
1526#[repr(C)]
1527#[derive(Clone, Copy, Debug, PartialEq)]
1528pub struct cssm_acl_validity_period {
1529 pub StartDate: SecAsn1Item,
1530 pub EndDate: SecAsn1Item,
1531}
1532
1533#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
1534unsafe impl Encode for cssm_acl_validity_period {
1535 const ENCODING: Encoding = Encoding::Struct(
1536 "cssm_acl_validity_period",
1537 &[<SecAsn1Item>::ENCODING, <SecAsn1Item>::ENCODING],
1538 );
1539}
1540
1541#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
1542unsafe impl RefEncode for cssm_acl_validity_period {
1543 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1544}
1545
1546#[deprecated]
1548#[cfg(feature = "SecAsn1Types")]
1549pub type CSSM_ACL_VALIDITY_PERIOD = cssm_acl_validity_period;
1550
1551#[deprecated]
1553#[cfg(feature = "SecAsn1Types")]
1554pub type CSSM_ACL_VALIDITY_PERIOD_PTR = *mut cssm_acl_validity_period;
1555
1556#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1558#[deprecated]
1559#[repr(C)]
1560#[derive(Clone, Copy, Debug, PartialEq)]
1561pub struct cssm_acl_entry_prototype {
1562 pub TypedSubject: CSSM_LIST,
1563 pub Delegate: CSSM_BOOL,
1564 pub Authorization: CSSM_AUTHORIZATIONGROUP,
1565 pub TimeRange: CSSM_ACL_VALIDITY_PERIOD,
1566 pub EntryTag: CSSM_STRING,
1567}
1568
1569#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1570unsafe impl Encode for cssm_acl_entry_prototype {
1571 const ENCODING: Encoding = Encoding::Struct(
1572 "cssm_acl_entry_prototype",
1573 &[
1574 <CSSM_LIST>::ENCODING,
1575 <CSSM_BOOL>::ENCODING,
1576 <CSSM_AUTHORIZATIONGROUP>::ENCODING,
1577 <CSSM_ACL_VALIDITY_PERIOD>::ENCODING,
1578 <CSSM_STRING>::ENCODING,
1579 ],
1580 );
1581}
1582
1583#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1584unsafe impl RefEncode for cssm_acl_entry_prototype {
1585 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1586}
1587
1588#[deprecated]
1590#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1591pub type CSSM_ACL_ENTRY_PROTOTYPE = cssm_acl_entry_prototype;
1592
1593#[deprecated]
1595#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1596pub type CSSM_ACL_ENTRY_PROTOTYPE_PTR = *mut cssm_acl_entry_prototype;
1597
1598#[cfg(feature = "cssmconfig")]
1600#[deprecated]
1601#[repr(C)]
1602#[derive(Clone, Copy, Debug, PartialEq)]
1603pub struct cssm_acl_owner_prototype {
1604 pub TypedSubject: CSSM_LIST,
1605 pub Delegate: CSSM_BOOL,
1606}
1607
1608#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1609unsafe impl Encode for cssm_acl_owner_prototype {
1610 const ENCODING: Encoding = Encoding::Struct(
1611 "cssm_acl_owner_prototype",
1612 &[<CSSM_LIST>::ENCODING, <CSSM_BOOL>::ENCODING],
1613 );
1614}
1615
1616#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1617unsafe impl RefEncode for cssm_acl_owner_prototype {
1618 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1619}
1620
1621#[deprecated]
1623#[cfg(feature = "cssmconfig")]
1624pub type CSSM_ACL_OWNER_PROTOTYPE = cssm_acl_owner_prototype;
1625
1626#[deprecated]
1628#[cfg(feature = "cssmconfig")]
1629pub type CSSM_ACL_OWNER_PROTOTYPE_PTR = *mut cssm_acl_owner_prototype;
1630
1631#[deprecated]
1633#[cfg(feature = "cssmconfig")]
1634pub type CSSM_ACL_SUBJECT_CALLBACK = Option<
1635 unsafe extern "C-unwind" fn(
1636 *const CSSM_LIST,
1637 CSSM_LIST_PTR,
1638 *mut c_void,
1639 *const CSSM_MEMORY_FUNCS,
1640 ) -> CSSM_RETURN,
1641>;
1642
1643#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1645#[deprecated]
1646#[repr(C)]
1647#[allow(unpredictable_function_pointer_comparisons)]
1648#[derive(Clone, Copy, Debug, PartialEq)]
1649pub struct cssm_acl_entry_input {
1650 pub Prototype: CSSM_ACL_ENTRY_PROTOTYPE,
1651 pub Callback: CSSM_ACL_SUBJECT_CALLBACK,
1652 pub CallerContext: *mut c_void,
1653}
1654
1655#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1656unsafe impl Encode for cssm_acl_entry_input {
1657 const ENCODING: Encoding = Encoding::Struct(
1658 "cssm_acl_entry_input",
1659 &[
1660 <CSSM_ACL_ENTRY_PROTOTYPE>::ENCODING,
1661 <CSSM_ACL_SUBJECT_CALLBACK>::ENCODING,
1662 <*mut c_void>::ENCODING,
1663 ],
1664 );
1665}
1666
1667#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1668unsafe impl RefEncode for cssm_acl_entry_input {
1669 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1670}
1671
1672#[deprecated]
1674#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1675pub type CSSM_ACL_ENTRY_INPUT = cssm_acl_entry_input;
1676
1677#[deprecated]
1679#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1680pub type CSSM_ACL_ENTRY_INPUT_PTR = *mut cssm_acl_entry_input;
1681
1682#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1684#[deprecated]
1685#[repr(C)]
1686#[derive(Clone, Copy, Debug, PartialEq)]
1687pub struct cssm_resource_control_context {
1688 pub AccessCred: CSSM_ACCESS_CREDENTIALS_PTR,
1689 pub InitialAclEntry: CSSM_ACL_ENTRY_INPUT,
1690}
1691
1692#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1693unsafe impl Encode for cssm_resource_control_context {
1694 const ENCODING: Encoding = Encoding::Struct(
1695 "cssm_resource_control_context",
1696 &[
1697 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
1698 <CSSM_ACL_ENTRY_INPUT>::ENCODING,
1699 ],
1700 );
1701}
1702
1703#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1704unsafe impl RefEncode for cssm_resource_control_context {
1705 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1706}
1707
1708#[deprecated]
1710#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1711pub type CSSM_RESOURCE_CONTROL_CONTEXT = cssm_resource_control_context;
1712
1713#[deprecated]
1715#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1716pub type CSSM_RESOURCE_CONTROL_CONTEXT_PTR = *mut cssm_resource_control_context;
1717
1718#[cfg(feature = "cssmconfig")]
1720pub type CSSM_ACL_HANDLE = CSSM_HANDLE;
1721
1722#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1724#[deprecated]
1725#[repr(C)]
1726#[derive(Clone, Copy, Debug, PartialEq)]
1727pub struct cssm_acl_entry_info {
1728 pub EntryPublicInfo: CSSM_ACL_ENTRY_PROTOTYPE,
1729 pub EntryHandle: CSSM_ACL_HANDLE,
1730}
1731
1732#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1733unsafe impl Encode for cssm_acl_entry_info {
1734 const ENCODING: Encoding = Encoding::Struct(
1735 "cssm_acl_entry_info",
1736 &[
1737 <CSSM_ACL_ENTRY_PROTOTYPE>::ENCODING,
1738 <CSSM_ACL_HANDLE>::ENCODING,
1739 ],
1740 );
1741}
1742
1743#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1744unsafe impl RefEncode for cssm_acl_entry_info {
1745 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1746}
1747
1748#[deprecated]
1750#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1751pub type CSSM_ACL_ENTRY_INFO = cssm_acl_entry_info;
1752
1753#[deprecated]
1755#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1756pub type CSSM_ACL_ENTRY_INFO_PTR = *mut cssm_acl_entry_info;
1757
1758#[cfg(feature = "cssmconfig")]
1760pub type CSSM_ACL_EDIT_MODE = uint32;
1761
1762pub const CSSM_ACL_EDIT_MODE_ADD: c_uint = 1;
1764pub const CSSM_ACL_EDIT_MODE_DELETE: c_uint = 2;
1766pub const CSSM_ACL_EDIT_MODE_REPLACE: c_uint = 3;
1768
1769#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1771#[deprecated]
1772#[repr(C)]
1773#[derive(Clone, Copy, Debug, PartialEq)]
1774pub struct cssm_acl_edit {
1775 pub EditMode: CSSM_ACL_EDIT_MODE,
1776 pub OldEntryHandle: CSSM_ACL_HANDLE,
1777 pub NewEntry: *const CSSM_ACL_ENTRY_INPUT,
1778}
1779
1780#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1781unsafe impl Encode for cssm_acl_edit {
1782 const ENCODING: Encoding = Encoding::Struct(
1783 "cssm_acl_edit",
1784 &[
1785 <CSSM_ACL_EDIT_MODE>::ENCODING,
1786 <CSSM_ACL_HANDLE>::ENCODING,
1787 <*const CSSM_ACL_ENTRY_INPUT>::ENCODING,
1788 ],
1789 );
1790}
1791
1792#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
1793unsafe impl RefEncode for cssm_acl_edit {
1794 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1795}
1796
1797#[deprecated]
1799#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1800pub type CSSM_ACL_EDIT = cssm_acl_edit;
1801
1802#[deprecated]
1804#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
1805pub type CSSM_ACL_EDIT_PTR = *mut cssm_acl_edit;
1806
1807pub type CSSM_PROC_ADDR = Option<unsafe extern "C-unwind" fn()>;
1809
1810pub type CSSM_PROC_ADDR_PTR = *mut CSSM_PROC_ADDR;
1812
1813#[repr(C)]
1815#[allow(unpredictable_function_pointer_comparisons)]
1816#[derive(Clone, Copy, Debug, PartialEq)]
1817pub struct cssm_func_name_addr {
1818 pub Name: CSSM_STRING,
1819 pub Address: CSSM_PROC_ADDR,
1820}
1821
1822#[cfg(feature = "objc2")]
1823unsafe impl Encode for cssm_func_name_addr {
1824 const ENCODING: Encoding = Encoding::Struct(
1825 "cssm_func_name_addr",
1826 &[<CSSM_STRING>::ENCODING, <CSSM_PROC_ADDR>::ENCODING],
1827 );
1828}
1829
1830#[cfg(feature = "objc2")]
1831unsafe impl RefEncode for cssm_func_name_addr {
1832 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1833}
1834
1835#[deprecated]
1837pub type CSSM_FUNC_NAME_ADDR = cssm_func_name_addr;
1838
1839#[deprecated]
1841pub type CSSM_FUNC_NAME_ADDR_PTR = *mut cssm_func_name_addr;
1842
1843#[cfg(feature = "cssmconfig")]
1845#[repr(C)]
1846#[derive(Clone, Copy, Debug, PartialEq)]
1847pub struct cssm_date {
1848 pub Year: [uint8; 4],
1849 pub Month: [uint8; 2],
1850 pub Day: [uint8; 2],
1851}
1852
1853#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1854unsafe impl Encode for cssm_date {
1855 const ENCODING: Encoding = Encoding::Struct(
1856 "cssm_date",
1857 &[
1858 <[uint8; 4]>::ENCODING,
1859 <[uint8; 2]>::ENCODING,
1860 <[uint8; 2]>::ENCODING,
1861 ],
1862 );
1863}
1864
1865#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1866unsafe impl RefEncode for cssm_date {
1867 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1868}
1869
1870#[deprecated]
1872#[cfg(feature = "cssmconfig")]
1873pub type CSSM_DATE = cssm_date;
1874
1875#[deprecated]
1877#[cfg(feature = "cssmconfig")]
1878pub type CSSM_DATE_PTR = *mut cssm_date;
1879
1880#[cfg(feature = "cssmconfig")]
1882#[repr(C)]
1883#[derive(Clone, Copy, Debug, PartialEq)]
1884pub struct cssm_range {
1885 pub Min: uint32,
1886 pub Max: uint32,
1887}
1888
1889#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1890unsafe impl Encode for cssm_range {
1891 const ENCODING: Encoding =
1892 Encoding::Struct("cssm_range", &[<uint32>::ENCODING, <uint32>::ENCODING]);
1893}
1894
1895#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1896unsafe impl RefEncode for cssm_range {
1897 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1898}
1899
1900#[deprecated]
1902#[cfg(feature = "cssmconfig")]
1903pub type CSSM_RANGE = cssm_range;
1904
1905#[deprecated]
1907#[cfg(feature = "cssmconfig")]
1908pub type CSSM_RANGE_PTR = *mut cssm_range;
1909
1910#[cfg(feature = "cssmconfig")]
1912#[repr(C)]
1913#[derive(Clone, Copy, Debug, PartialEq)]
1914pub struct cssm_query_size_data {
1915 pub SizeInputBlock: uint32,
1916 pub SizeOutputBlock: uint32,
1917}
1918
1919#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1920unsafe impl Encode for cssm_query_size_data {
1921 const ENCODING: Encoding = Encoding::Struct(
1922 "cssm_query_size_data",
1923 &[<uint32>::ENCODING, <uint32>::ENCODING],
1924 );
1925}
1926
1927#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1928unsafe impl RefEncode for cssm_query_size_data {
1929 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1930}
1931
1932#[deprecated]
1934#[cfg(feature = "cssmconfig")]
1935pub type CSSM_QUERY_SIZE_DATA = cssm_query_size_data;
1936
1937#[deprecated]
1939#[cfg(feature = "cssmconfig")]
1940pub type CSSM_QUERY_SIZE_DATA_PTR = *mut cssm_query_size_data;
1941
1942#[cfg(feature = "cssmconfig")]
1944pub type CSSM_HEADERVERSION = uint32;
1945
1946pub const CSSM_KEYHEADER_VERSION: c_uint = 2;
1948
1949#[cfg(feature = "cssmconfig")]
1951#[repr(C)]
1952#[derive(Clone, Copy, Debug, PartialEq)]
1953pub struct cssm_key_size {
1954 pub LogicalKeySizeInBits: uint32,
1955 pub EffectiveKeySizeInBits: uint32,
1956}
1957
1958#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1959unsafe impl Encode for cssm_key_size {
1960 const ENCODING: Encoding =
1961 Encoding::Struct("cssm_key_size", &[<uint32>::ENCODING, <uint32>::ENCODING]);
1962}
1963
1964#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
1965unsafe impl RefEncode for cssm_key_size {
1966 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1967}
1968
1969#[deprecated]
1971#[cfg(feature = "cssmconfig")]
1972pub type CSSM_KEY_SIZE = cssm_key_size;
1973
1974#[deprecated]
1976#[cfg(feature = "cssmconfig")]
1977pub type CSSM_KEY_SIZE_PTR = *mut cssm_key_size;
1978
1979#[cfg(feature = "cssmconfig")]
1981pub type CSSM_KEYBLOB_TYPE = uint32;
1982
1983pub const CSSM_KEYBLOB_RAW: c_uint = 0;
1985pub const CSSM_KEYBLOB_REFERENCE: c_uint = 2;
1987pub const CSSM_KEYBLOB_WRAPPED: c_uint = 3;
1989pub const CSSM_KEYBLOB_OTHER: c_uint = 4294967295;
1991
1992#[cfg(feature = "cssmconfig")]
1994pub type CSSM_KEYBLOB_FORMAT = uint32;
1995
1996pub const CSSM_KEYBLOB_RAW_FORMAT_NONE: c_uint = 0;
1998pub const CSSM_KEYBLOB_RAW_FORMAT_PKCS1: c_uint = 1;
2000pub const CSSM_KEYBLOB_RAW_FORMAT_PKCS3: c_uint = 2;
2002pub const CSSM_KEYBLOB_RAW_FORMAT_MSCAPI: c_uint = 3;
2004pub const CSSM_KEYBLOB_RAW_FORMAT_PGP: c_uint = 4;
2006pub const CSSM_KEYBLOB_RAW_FORMAT_FIPS186: c_uint = 5;
2008pub const CSSM_KEYBLOB_RAW_FORMAT_BSAFE: c_uint = 6;
2010pub const CSSM_KEYBLOB_RAW_FORMAT_CCA: c_uint = 9;
2012pub const CSSM_KEYBLOB_RAW_FORMAT_PKCS8: c_uint = 10;
2014pub const CSSM_KEYBLOB_RAW_FORMAT_SPKI: c_uint = 11;
2016pub const CSSM_KEYBLOB_RAW_FORMAT_OCTET_STRING: c_uint = 12;
2018pub const CSSM_KEYBLOB_RAW_FORMAT_OTHER: c_uint = 4294967295;
2020
2021pub const CSSM_KEYBLOB_WRAPPED_FORMAT_NONE: c_uint = 0;
2023pub const CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS8: c_uint = 1;
2025pub const CSSM_KEYBLOB_WRAPPED_FORMAT_PKCS7: c_uint = 2;
2027pub const CSSM_KEYBLOB_WRAPPED_FORMAT_MSCAPI: c_uint = 3;
2029pub const CSSM_KEYBLOB_WRAPPED_FORMAT_OTHER: c_uint = 4294967295;
2031
2032pub const CSSM_KEYBLOB_REF_FORMAT_INTEGER: c_uint = 0;
2034pub const CSSM_KEYBLOB_REF_FORMAT_STRING: c_uint = 1;
2036pub const CSSM_KEYBLOB_REF_FORMAT_SPKI: c_uint = 2;
2038pub const CSSM_KEYBLOB_REF_FORMAT_OTHER: c_uint = 4294967295;
2040
2041#[cfg(feature = "cssmconfig")]
2043pub type CSSM_KEYCLASS = uint32;
2044
2045pub const CSSM_KEYCLASS_PUBLIC_KEY: c_uint = 0;
2047pub const CSSM_KEYCLASS_PRIVATE_KEY: c_uint = 1;
2049pub const CSSM_KEYCLASS_SESSION_KEY: c_uint = 2;
2051pub const CSSM_KEYCLASS_SECRET_PART: c_uint = 3;
2053pub const CSSM_KEYCLASS_OTHER: c_uint = 4294967295;
2055
2056#[cfg(feature = "cssmconfig")]
2058pub type CSSM_KEYATTR_FLAGS = uint32;
2059
2060pub const CSSM_KEYATTR_RETURN_DEFAULT: c_uint = 0;
2062pub const CSSM_KEYATTR_RETURN_DATA: c_uint = 268435456;
2064pub const CSSM_KEYATTR_RETURN_REF: c_uint = 536870912;
2066pub const CSSM_KEYATTR_RETURN_NONE: c_uint = 1073741824;
2068pub const CSSM_KEYATTR_PERMANENT: c_uint = 1;
2070pub const CSSM_KEYATTR_PRIVATE: c_uint = 2;
2072pub const CSSM_KEYATTR_MODIFIABLE: c_uint = 4;
2074pub const CSSM_KEYATTR_SENSITIVE: c_uint = 8;
2076pub const CSSM_KEYATTR_EXTRACTABLE: c_uint = 32;
2078pub const CSSM_KEYATTR_ALWAYS_SENSITIVE: c_uint = 16;
2080pub const CSSM_KEYATTR_NEVER_EXTRACTABLE: c_uint = 64;
2082
2083#[cfg(feature = "cssmconfig")]
2085pub type CSSM_KEYUSE = uint32;
2086
2087pub const CSSM_KEYUSE_ANY: c_uint = 2147483648;
2089pub const CSSM_KEYUSE_ENCRYPT: c_uint = 1;
2091pub const CSSM_KEYUSE_DECRYPT: c_uint = 2;
2093pub const CSSM_KEYUSE_SIGN: c_uint = 4;
2095pub const CSSM_KEYUSE_VERIFY: c_uint = 8;
2097pub const CSSM_KEYUSE_SIGN_RECOVER: c_uint = 16;
2099pub const CSSM_KEYUSE_VERIFY_RECOVER: c_uint = 32;
2101pub const CSSM_KEYUSE_WRAP: c_uint = 64;
2103pub const CSSM_KEYUSE_UNWRAP: c_uint = 128;
2105pub const CSSM_KEYUSE_DERIVE: c_uint = 256;
2107
2108#[cfg(feature = "cssmconfig")]
2110pub type CSSM_ALGORITHMS = uint32;
2111
2112pub const CSSM_ALGID_NONE: c_uint = 0;
2114pub const CSSM_ALGID_CUSTOM: c_uint = 1;
2116pub const CSSM_ALGID_DH: c_uint = 2;
2118pub const CSSM_ALGID_PH: c_uint = 3;
2120pub const CSSM_ALGID_KEA: c_uint = 4;
2122pub const CSSM_ALGID_MD2: c_uint = 5;
2124pub const CSSM_ALGID_MD4: c_uint = 6;
2126pub const CSSM_ALGID_MD5: c_uint = 7;
2128pub const CSSM_ALGID_SHA1: c_uint = 8;
2130pub const CSSM_ALGID_NHASH: c_uint = 9;
2132pub const CSSM_ALGID_HAVAL: c_uint = 10;
2134pub const CSSM_ALGID_RIPEMD: c_uint = 11;
2136pub const CSSM_ALGID_IBCHASH: c_uint = 12;
2138pub const CSSM_ALGID_RIPEMAC: c_uint = 13;
2140pub const CSSM_ALGID_DES: c_uint = 14;
2142pub const CSSM_ALGID_DESX: c_uint = 15;
2144pub const CSSM_ALGID_RDES: c_uint = 16;
2146pub const CSSM_ALGID_3DES_3KEY_EDE: c_uint = 17;
2148pub const CSSM_ALGID_3DES_2KEY_EDE: c_uint = 18;
2150pub const CSSM_ALGID_3DES_1KEY_EEE: c_uint = 19;
2152pub const CSSM_ALGID_3DES_3KEY: c_uint = 17;
2154pub const CSSM_ALGID_3DES_3KEY_EEE: c_uint = 20;
2156pub const CSSM_ALGID_3DES_2KEY: c_uint = 18;
2158pub const CSSM_ALGID_3DES_2KEY_EEE: c_uint = 21;
2160pub const CSSM_ALGID_3DES_1KEY: c_uint = 20;
2162pub const CSSM_ALGID_IDEA: c_uint = 22;
2164pub const CSSM_ALGID_RC2: c_uint = 23;
2166pub const CSSM_ALGID_RC5: c_uint = 24;
2168pub const CSSM_ALGID_RC4: c_uint = 25;
2170pub const CSSM_ALGID_SEAL: c_uint = 26;
2172pub const CSSM_ALGID_CAST: c_uint = 27;
2174pub const CSSM_ALGID_BLOWFISH: c_uint = 28;
2176pub const CSSM_ALGID_SKIPJACK: c_uint = 29;
2178pub const CSSM_ALGID_LUCIFER: c_uint = 30;
2180pub const CSSM_ALGID_MADRYGA: c_uint = 31;
2182pub const CSSM_ALGID_FEAL: c_uint = 32;
2184pub const CSSM_ALGID_REDOC: c_uint = 33;
2186pub const CSSM_ALGID_REDOC3: c_uint = 34;
2188pub const CSSM_ALGID_LOKI: c_uint = 35;
2190pub const CSSM_ALGID_KHUFU: c_uint = 36;
2192pub const CSSM_ALGID_KHAFRE: c_uint = 37;
2194pub const CSSM_ALGID_MMB: c_uint = 38;
2196pub const CSSM_ALGID_GOST: c_uint = 39;
2198pub const CSSM_ALGID_SAFER: c_uint = 40;
2200pub const CSSM_ALGID_CRAB: c_uint = 41;
2202pub const CSSM_ALGID_RSA: c_uint = 42;
2204pub const CSSM_ALGID_DSA: c_uint = 43;
2206pub const CSSM_ALGID_MD5WithRSA: c_uint = 44;
2208pub const CSSM_ALGID_MD2WithRSA: c_uint = 45;
2210pub const CSSM_ALGID_ElGamal: c_uint = 46;
2212pub const CSSM_ALGID_MD2Random: c_uint = 47;
2214pub const CSSM_ALGID_MD5Random: c_uint = 48;
2216pub const CSSM_ALGID_SHARandom: c_uint = 49;
2218pub const CSSM_ALGID_DESRandom: c_uint = 50;
2220pub const CSSM_ALGID_SHA1WithRSA: c_uint = 51;
2222pub const CSSM_ALGID_CDMF: c_uint = 52;
2224pub const CSSM_ALGID_CAST3: c_uint = 53;
2226pub const CSSM_ALGID_CAST5: c_uint = 54;
2228pub const CSSM_ALGID_GenericSecret: c_uint = 55;
2230pub const CSSM_ALGID_ConcatBaseAndKey: c_uint = 56;
2232pub const CSSM_ALGID_ConcatKeyAndBase: c_uint = 57;
2234pub const CSSM_ALGID_ConcatBaseAndData: c_uint = 58;
2236pub const CSSM_ALGID_ConcatDataAndBase: c_uint = 59;
2238pub const CSSM_ALGID_XORBaseAndData: c_uint = 60;
2240pub const CSSM_ALGID_ExtractFromKey: c_uint = 61;
2242pub const CSSM_ALGID_SSL3PrePrimaryGen: c_uint = 62;
2244#[deprecated]
2246pub const CSSM_ALGID_SSL3PreMasterGen: c_uint = 62;
2247pub const CSSM_ALGID_SSL3PrimaryDerive: c_uint = 63;
2249#[deprecated]
2251pub const CSSM_ALGID_SSL3MasterDerive: c_uint = 63;
2252pub const CSSM_ALGID_SSL3KeyAndMacDerive: c_uint = 64;
2254pub const CSSM_ALGID_SSL3MD5_MAC: c_uint = 65;
2256pub const CSSM_ALGID_SSL3SHA1_MAC: c_uint = 66;
2258pub const CSSM_ALGID_PKCS5_PBKDF1_MD5: c_uint = 67;
2260pub const CSSM_ALGID_PKCS5_PBKDF1_MD2: c_uint = 68;
2262pub const CSSM_ALGID_PKCS5_PBKDF1_SHA1: c_uint = 69;
2264pub const CSSM_ALGID_WrapLynks: c_uint = 70;
2266pub const CSSM_ALGID_WrapSET_OAEP: c_uint = 71;
2268pub const CSSM_ALGID_BATON: c_uint = 72;
2270pub const CSSM_ALGID_ECDSA: c_uint = 73;
2272pub const CSSM_ALGID_MAYFLY: c_uint = 74;
2274pub const CSSM_ALGID_JUNIPER: c_uint = 75;
2276pub const CSSM_ALGID_FASTHASH: c_uint = 76;
2278pub const CSSM_ALGID_3DES: c_uint = 77;
2280pub const CSSM_ALGID_SSL3MD5: c_uint = 78;
2282pub const CSSM_ALGID_SSL3SHA1: c_uint = 79;
2284pub const CSSM_ALGID_FortezzaTimestamp: c_uint = 80;
2286pub const CSSM_ALGID_SHA1WithDSA: c_uint = 81;
2288pub const CSSM_ALGID_SHA1WithECDSA: c_uint = 82;
2290pub const CSSM_ALGID_DSA_BSAFE: c_uint = 83;
2292pub const CSSM_ALGID_ECDH: c_uint = 84;
2294pub const CSSM_ALGID_ECMQV: c_uint = 85;
2296pub const CSSM_ALGID_PKCS12_SHA1_PBE: c_uint = 86;
2298pub const CSSM_ALGID_ECNRA: c_uint = 87;
2300pub const CSSM_ALGID_SHA1WithECNRA: c_uint = 88;
2302pub const CSSM_ALGID_ECES: c_uint = 89;
2304pub const CSSM_ALGID_ECAES: c_uint = 90;
2306pub const CSSM_ALGID_SHA1HMAC: c_uint = 91;
2308pub const CSSM_ALGID_FIPS186Random: c_uint = 92;
2310pub const CSSM_ALGID_ECC: c_uint = 93;
2312pub const CSSM_ALGID_MQV: c_uint = 94;
2314pub const CSSM_ALGID_NRA: c_uint = 95;
2316pub const CSSM_ALGID_IntelPlatformRandom: c_uint = 96;
2318pub const CSSM_ALGID_UTC: c_uint = 97;
2320pub const CSSM_ALGID_HAVAL3: c_uint = 98;
2322pub const CSSM_ALGID_HAVAL4: c_uint = 99;
2324pub const CSSM_ALGID_HAVAL5: c_uint = 100;
2326pub const CSSM_ALGID_TIGER: c_uint = 101;
2328pub const CSSM_ALGID_MD5HMAC: c_uint = 102;
2330pub const CSSM_ALGID_PKCS5_PBKDF2: c_uint = 103;
2332pub const CSSM_ALGID_RUNNING_COUNTER: c_uint = 104;
2334pub const CSSM_ALGID_LAST: c_uint = 2147483647;
2336pub const CSSM_ALGID_VENDOR_DEFINED: c_uint = 2147483648;
2338
2339#[cfg(feature = "cssmconfig")]
2341pub type CSSM_ENCRYPT_MODE = uint32;
2342
2343pub const CSSM_ALGMODE_NONE: c_uint = 0;
2345pub const CSSM_ALGMODE_CUSTOM: c_uint = 1;
2347pub const CSSM_ALGMODE_ECB: c_uint = 2;
2349pub const CSSM_ALGMODE_ECBPad: c_uint = 3;
2351pub const CSSM_ALGMODE_CBC: c_uint = 4;
2353pub const CSSM_ALGMODE_CBC_IV8: c_uint = 5;
2355pub const CSSM_ALGMODE_CBCPadIV8: c_uint = 6;
2357pub const CSSM_ALGMODE_CFB: c_uint = 7;
2359pub const CSSM_ALGMODE_CFB_IV8: c_uint = 8;
2361pub const CSSM_ALGMODE_CFBPadIV8: c_uint = 9;
2363pub const CSSM_ALGMODE_OFB: c_uint = 10;
2365pub const CSSM_ALGMODE_OFB_IV8: c_uint = 11;
2367pub const CSSM_ALGMODE_OFBPadIV8: c_uint = 12;
2369pub const CSSM_ALGMODE_COUNTER: c_uint = 13;
2371pub const CSSM_ALGMODE_BC: c_uint = 14;
2373pub const CSSM_ALGMODE_PCBC: c_uint = 15;
2375pub const CSSM_ALGMODE_CBCC: c_uint = 16;
2377pub const CSSM_ALGMODE_OFBNLF: c_uint = 17;
2379pub const CSSM_ALGMODE_PBC: c_uint = 18;
2381pub const CSSM_ALGMODE_PFB: c_uint = 19;
2383pub const CSSM_ALGMODE_CBCPD: c_uint = 20;
2385pub const CSSM_ALGMODE_PUBLIC_KEY: c_uint = 21;
2387pub const CSSM_ALGMODE_PRIVATE_KEY: c_uint = 22;
2389pub const CSSM_ALGMODE_SHUFFLE: c_uint = 23;
2391pub const CSSM_ALGMODE_ECB64: c_uint = 24;
2393pub const CSSM_ALGMODE_CBC64: c_uint = 25;
2395pub const CSSM_ALGMODE_OFB64: c_uint = 26;
2397pub const CSSM_ALGMODE_CFB32: c_uint = 28;
2399pub const CSSM_ALGMODE_CFB16: c_uint = 29;
2401pub const CSSM_ALGMODE_CFB8: c_uint = 30;
2403pub const CSSM_ALGMODE_WRAP: c_uint = 31;
2405pub const CSSM_ALGMODE_PRIVATE_WRAP: c_uint = 32;
2407pub const CSSM_ALGMODE_RELAYX: c_uint = 33;
2409pub const CSSM_ALGMODE_ECB128: c_uint = 34;
2411pub const CSSM_ALGMODE_ECB96: c_uint = 35;
2413pub const CSSM_ALGMODE_CBC128: c_uint = 36;
2415pub const CSSM_ALGMODE_OAEP_HASH: c_uint = 37;
2417pub const CSSM_ALGMODE_PKCS1_EME_V15: c_uint = 38;
2419pub const CSSM_ALGMODE_PKCS1_EME_OAEP: c_uint = 39;
2421pub const CSSM_ALGMODE_PKCS1_EMSA_V15: c_uint = 40;
2423pub const CSSM_ALGMODE_ISO_9796: c_uint = 41;
2425pub const CSSM_ALGMODE_X9_31: c_uint = 42;
2427pub const CSSM_ALGMODE_LAST: c_uint = 2147483647;
2429pub const CSSM_ALGMODE_VENDOR_DEFINED: c_uint = 2147483648;
2431
2432#[cfg(feature = "cssmconfig")]
2434#[deprecated]
2435#[repr(C)]
2436#[derive(Clone, Copy, Debug, PartialEq)]
2437pub struct cssm_keyheader {
2438 pub HeaderVersion: CSSM_HEADERVERSION,
2439 pub CspId: CSSM_GUID,
2440 pub BlobType: CSSM_KEYBLOB_TYPE,
2441 pub Format: CSSM_KEYBLOB_FORMAT,
2442 pub AlgorithmId: CSSM_ALGORITHMS,
2443 pub KeyClass: CSSM_KEYCLASS,
2444 pub LogicalKeySizeInBits: uint32,
2445 pub KeyAttr: CSSM_KEYATTR_FLAGS,
2446 pub KeyUsage: CSSM_KEYUSE,
2447 pub StartDate: CSSM_DATE,
2448 pub EndDate: CSSM_DATE,
2449 pub WrapAlgorithmId: CSSM_ALGORITHMS,
2450 pub WrapMode: CSSM_ENCRYPT_MODE,
2451 pub Reserved: uint32,
2452}
2453
2454#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2455unsafe impl Encode for cssm_keyheader {
2456 const ENCODING: Encoding = Encoding::Struct(
2457 "cssm_keyheader",
2458 &[
2459 <CSSM_HEADERVERSION>::ENCODING,
2460 <CSSM_GUID>::ENCODING,
2461 <CSSM_KEYBLOB_TYPE>::ENCODING,
2462 <CSSM_KEYBLOB_FORMAT>::ENCODING,
2463 <CSSM_ALGORITHMS>::ENCODING,
2464 <CSSM_KEYCLASS>::ENCODING,
2465 <uint32>::ENCODING,
2466 <CSSM_KEYATTR_FLAGS>::ENCODING,
2467 <CSSM_KEYUSE>::ENCODING,
2468 <CSSM_DATE>::ENCODING,
2469 <CSSM_DATE>::ENCODING,
2470 <CSSM_ALGORITHMS>::ENCODING,
2471 <CSSM_ENCRYPT_MODE>::ENCODING,
2472 <uint32>::ENCODING,
2473 ],
2474 );
2475}
2476
2477#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2478unsafe impl RefEncode for cssm_keyheader {
2479 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2480}
2481
2482#[deprecated]
2484#[cfg(feature = "cssmconfig")]
2485pub type CSSM_KEYHEADER = cssm_keyheader;
2486
2487#[deprecated]
2489#[cfg(feature = "cssmconfig")]
2490pub type CSSM_KEYHEADER_PTR = *mut cssm_keyheader;
2491
2492#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2494#[deprecated]
2495#[repr(C)]
2496#[derive(Clone, Copy, Debug, PartialEq)]
2497pub struct cssm_key {
2498 pub KeyHeader: CSSM_KEYHEADER,
2499 pub KeyData: SecAsn1Item,
2500}
2501
2502#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
2503unsafe impl Encode for cssm_key {
2504 const ENCODING: Encoding = Encoding::Struct(
2505 "cssm_key",
2506 &[<CSSM_KEYHEADER>::ENCODING, <SecAsn1Item>::ENCODING],
2507 );
2508}
2509
2510#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
2511unsafe impl RefEncode for cssm_key {
2512 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2513}
2514
2515#[deprecated]
2517#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2518pub type CSSM_KEY = cssm_key;
2519
2520#[deprecated]
2522#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2523pub type CSSM_KEY_PTR = *mut cssm_key;
2524
2525#[deprecated]
2527#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2528pub type CSSM_WRAP_KEY = CSSM_KEY;
2529
2530#[deprecated]
2532#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
2533pub type CSSM_WRAP_KEY_PTR = *mut CSSM_KEY;
2534
2535#[cfg(feature = "cssmconfig")]
2537pub type CSSM_CSPTYPE = uint32;
2538
2539pub const CSSM_CSP_SOFTWARE: c_uint = 1;
2541pub const CSSM_CSP_HARDWARE: c_uint = 2;
2543pub const CSSM_CSP_HYBRID: c_uint = 3;
2545
2546#[cfg(feature = "cssmconfig")]
2548#[repr(C)]
2549#[derive(Clone, Copy, Debug, PartialEq)]
2550pub struct cssm_dl_db_handle {
2551 pub DLHandle: CSSM_DL_HANDLE,
2552 pub DBHandle: CSSM_DB_HANDLE,
2553}
2554
2555#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2556unsafe impl Encode for cssm_dl_db_handle {
2557 const ENCODING: Encoding = Encoding::Struct(
2558 "cssm_dl_db_handle",
2559 &[<CSSM_DL_HANDLE>::ENCODING, <CSSM_DB_HANDLE>::ENCODING],
2560 );
2561}
2562
2563#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
2564unsafe impl RefEncode for cssm_dl_db_handle {
2565 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2566}
2567
2568#[deprecated]
2570#[cfg(feature = "cssmconfig")]
2571pub type CSSM_DL_DB_HANDLE = cssm_dl_db_handle;
2572
2573#[deprecated]
2575#[cfg(feature = "cssmconfig")]
2576pub type CSSM_DL_DB_HANDLE_PTR = *mut cssm_dl_db_handle;
2577
2578#[cfg(feature = "cssmconfig")]
2580pub type CSSM_CONTEXT_TYPE = uint32;
2581
2582pub const CSSM_ALGCLASS_NONE: c_uint = 0;
2584pub const CSSM_ALGCLASS_CUSTOM: c_uint = 1;
2586pub const CSSM_ALGCLASS_SIGNATURE: c_uint = 2;
2588pub const CSSM_ALGCLASS_SYMMETRIC: c_uint = 3;
2590pub const CSSM_ALGCLASS_DIGEST: c_uint = 4;
2592pub const CSSM_ALGCLASS_RANDOMGEN: c_uint = 5;
2594pub const CSSM_ALGCLASS_UNIQUEGEN: c_uint = 6;
2596pub const CSSM_ALGCLASS_MAC: c_uint = 7;
2598pub const CSSM_ALGCLASS_ASYMMETRIC: c_uint = 8;
2600pub const CSSM_ALGCLASS_KEYGEN: c_uint = 9;
2602pub const CSSM_ALGCLASS_DERIVEKEY: c_uint = 10;
2604
2605pub const CSSM_ATTRIBUTE_DATA_NONE: c_uint = 0;
2607pub const CSSM_ATTRIBUTE_DATA_UINT32: c_uint = 268435456;
2609pub const CSSM_ATTRIBUTE_DATA_CSSM_DATA: c_uint = 536870912;
2611pub const CSSM_ATTRIBUTE_DATA_CRYPTO_DATA: c_uint = 805306368;
2613pub const CSSM_ATTRIBUTE_DATA_KEY: c_uint = 1073741824;
2615pub const CSSM_ATTRIBUTE_DATA_STRING: c_uint = 1342177280;
2617pub const CSSM_ATTRIBUTE_DATA_DATE: c_uint = 1610612736;
2619pub const CSSM_ATTRIBUTE_DATA_RANGE: c_uint = 1879048192;
2621pub const CSSM_ATTRIBUTE_DATA_ACCESS_CREDENTIALS: c_uint = 2147483648;
2623pub const CSSM_ATTRIBUTE_DATA_VERSION: c_uint = 16777216;
2625pub const CSSM_ATTRIBUTE_DATA_DL_DB_HANDLE: c_uint = 33554432;
2627pub const CSSM_ATTRIBUTE_DATA_KR_PROFILE: c_uint = 50331648;
2629pub const CSSM_ATTRIBUTE_TYPE_MASK: c_uint = 4278190080;
2631
2632#[cfg(feature = "cssmconfig")]
2634pub type CSSM_ATTRIBUTE_TYPE = uint32;
2635
2636pub const CSSM_ATTRIBUTE_NONE: c_uint = 0;
2638pub const CSSM_ATTRIBUTE_CUSTOM: c_uint = 536870913;
2640pub const CSSM_ATTRIBUTE_DESCRIPTION: c_uint = 1342177282;
2642pub const CSSM_ATTRIBUTE_KEY: c_uint = 1073741827;
2644pub const CSSM_ATTRIBUTE_INIT_VECTOR: c_uint = 536870916;
2646pub const CSSM_ATTRIBUTE_SALT: c_uint = 536870917;
2648pub const CSSM_ATTRIBUTE_PADDING: c_uint = 268435462;
2650pub const CSSM_ATTRIBUTE_RANDOM: c_uint = 536870919;
2652pub const CSSM_ATTRIBUTE_SEED: c_uint = 805306376;
2654pub const CSSM_ATTRIBUTE_PASSPHRASE: c_uint = 805306377;
2656pub const CSSM_ATTRIBUTE_KEY_LENGTH: c_uint = 268435466;
2658pub const CSSM_ATTRIBUTE_KEY_LENGTH_RANGE: c_uint = 1879048203;
2660pub const CSSM_ATTRIBUTE_BLOCK_SIZE: c_uint = 268435468;
2662pub const CSSM_ATTRIBUTE_OUTPUT_SIZE: c_uint = 268435469;
2664pub const CSSM_ATTRIBUTE_ROUNDS: c_uint = 268435470;
2666pub const CSSM_ATTRIBUTE_IV_SIZE: c_uint = 268435471;
2668pub const CSSM_ATTRIBUTE_ALG_PARAMS: c_uint = 536870928;
2670pub const CSSM_ATTRIBUTE_LABEL: c_uint = 536870929;
2672pub const CSSM_ATTRIBUTE_KEY_TYPE: c_uint = 268435474;
2674pub const CSSM_ATTRIBUTE_MODE: c_uint = 268435475;
2676pub const CSSM_ATTRIBUTE_EFFECTIVE_BITS: c_uint = 268435476;
2678pub const CSSM_ATTRIBUTE_START_DATE: c_uint = 1610612757;
2680pub const CSSM_ATTRIBUTE_END_DATE: c_uint = 1610612758;
2682pub const CSSM_ATTRIBUTE_KEYUSAGE: c_uint = 268435479;
2684pub const CSSM_ATTRIBUTE_KEYATTR: c_uint = 268435480;
2686pub const CSSM_ATTRIBUTE_VERSION: c_uint = 16777241;
2688pub const CSSM_ATTRIBUTE_PRIME: c_uint = 536870938;
2690pub const CSSM_ATTRIBUTE_BASE: c_uint = 536870939;
2692pub const CSSM_ATTRIBUTE_SUBPRIME: c_uint = 536870940;
2694pub const CSSM_ATTRIBUTE_ALG_ID: c_uint = 268435485;
2696pub const CSSM_ATTRIBUTE_ITERATION_COUNT: c_uint = 268435486;
2698pub const CSSM_ATTRIBUTE_ROUNDS_RANGE: c_uint = 1879048223;
2700pub const CSSM_ATTRIBUTE_KRPROFILE_LOCAL: c_uint = 50331680;
2702pub const CSSM_ATTRIBUTE_KRPROFILE_REMOTE: c_uint = 50331681;
2704pub const CSSM_ATTRIBUTE_CSP_HANDLE: c_uint = 268435490;
2706pub const CSSM_ATTRIBUTE_DL_DB_HANDLE: c_uint = 33554467;
2708pub const CSSM_ATTRIBUTE_ACCESS_CREDENTIALS: c_uint = 2147483684;
2710pub const CSSM_ATTRIBUTE_PUBLIC_KEY_FORMAT: c_uint = 268435493;
2712pub const CSSM_ATTRIBUTE_PRIVATE_KEY_FORMAT: c_uint = 268435494;
2714pub const CSSM_ATTRIBUTE_SYMMETRIC_KEY_FORMAT: c_uint = 268435495;
2716pub const CSSM_ATTRIBUTE_WRAPPED_KEY_FORMAT: c_uint = 268435496;
2718
2719#[cfg(feature = "cssmconfig")]
2721pub type CSSM_PADDING = uint32;
2722
2723pub const CSSM_PADDING_NONE: c_uint = 0;
2725pub const CSSM_PADDING_CUSTOM: c_uint = 1;
2727pub const CSSM_PADDING_ZERO: c_uint = 2;
2729pub const CSSM_PADDING_ONE: c_uint = 3;
2731pub const CSSM_PADDING_ALTERNATE: c_uint = 4;
2733pub const CSSM_PADDING_FF: c_uint = 5;
2735pub const CSSM_PADDING_PKCS5: c_uint = 6;
2737pub const CSSM_PADDING_PKCS7: c_uint = 7;
2739pub const CSSM_PADDING_CIPHERSTEALING: c_uint = 8;
2741pub const CSSM_PADDING_RANDOM: c_uint = 9;
2743pub const CSSM_PADDING_PKCS1: c_uint = 10;
2745pub const CSSM_PADDING_SIGRAW: c_uint = 11;
2747pub const CSSM_PADDING_VENDOR_DEFINED: c_uint = 2147483648;
2749
2750#[cfg(feature = "cssmconfig")]
2752pub type CSSM_KEY_TYPE = CSSM_ALGORITHMS;
2753
2754#[cfg(all(
2756 feature = "SecAsn1Types",
2757 feature = "cssmconfig",
2758 feature = "cssmkrapi"
2759))]
2760#[deprecated]
2761#[repr(C)]
2762#[derive(Clone, Copy)]
2763pub union cssm_context_attribute_value {
2764 pub String: *mut c_char,
2765 pub Uint32: uint32,
2766 pub AccessCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
2767 pub Key: CSSM_KEY_PTR,
2768 pub Data: CSSM_DATA_PTR,
2769 pub Padding: CSSM_PADDING,
2770 pub Date: CSSM_DATE_PTR,
2771 pub Range: CSSM_RANGE_PTR,
2772 pub CryptoData: CSSM_CRYPTO_DATA_PTR,
2773 pub Version: CSSM_VERSION_PTR,
2774 pub DLDBHandle: CSSM_DL_DB_HANDLE_PTR,
2775 pub KRProfile: *mut cssm_kr_profile,
2776}
2777
2778#[cfg(all(
2779 feature = "SecAsn1Types",
2780 feature = "cssmconfig",
2781 feature = "cssmkrapi",
2782 feature = "objc2"
2783))]
2784unsafe impl Encode for cssm_context_attribute_value {
2785 const ENCODING: Encoding = Encoding::Union(
2786 "cssm_context_attribute_value",
2787 &[
2788 <*mut c_char>::ENCODING,
2789 <uint32>::ENCODING,
2790 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
2791 <CSSM_KEY_PTR>::ENCODING,
2792 <CSSM_DATA_PTR>::ENCODING,
2793 <CSSM_PADDING>::ENCODING,
2794 <CSSM_DATE_PTR>::ENCODING,
2795 <CSSM_RANGE_PTR>::ENCODING,
2796 <CSSM_CRYPTO_DATA_PTR>::ENCODING,
2797 <CSSM_VERSION_PTR>::ENCODING,
2798 <CSSM_DL_DB_HANDLE_PTR>::ENCODING,
2799 <*mut cssm_kr_profile>::ENCODING,
2800 ],
2801 );
2802}
2803
2804#[cfg(all(
2805 feature = "SecAsn1Types",
2806 feature = "cssmconfig",
2807 feature = "cssmkrapi",
2808 feature = "objc2"
2809))]
2810unsafe impl RefEncode for cssm_context_attribute_value {
2811 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2812}
2813
2814#[cfg(all(
2816 feature = "SecAsn1Types",
2817 feature = "cssmconfig",
2818 feature = "cssmkrapi"
2819))]
2820#[deprecated]
2821#[repr(C)]
2822#[derive(Clone, Copy)]
2823pub struct cssm_context_attribute {
2824 pub AttributeType: CSSM_ATTRIBUTE_TYPE,
2825 pub AttributeLength: uint32,
2826 pub Attribute: cssm_context_attribute_value,
2827}
2828
2829#[cfg(all(
2830 feature = "SecAsn1Types",
2831 feature = "cssmconfig",
2832 feature = "cssmkrapi",
2833 feature = "objc2"
2834))]
2835unsafe impl Encode for cssm_context_attribute {
2836 const ENCODING: Encoding = Encoding::Struct(
2837 "cssm_context_attribute",
2838 &[
2839 <CSSM_ATTRIBUTE_TYPE>::ENCODING,
2840 <uint32>::ENCODING,
2841 <cssm_context_attribute_value>::ENCODING,
2842 ],
2843 );
2844}
2845
2846#[cfg(all(
2847 feature = "SecAsn1Types",
2848 feature = "cssmconfig",
2849 feature = "cssmkrapi",
2850 feature = "objc2"
2851))]
2852unsafe impl RefEncode for cssm_context_attribute {
2853 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2854}
2855
2856#[deprecated]
2858#[cfg(all(
2859 feature = "SecAsn1Types",
2860 feature = "cssmconfig",
2861 feature = "cssmkrapi"
2862))]
2863pub type CSSM_CONTEXT_ATTRIBUTE = cssm_context_attribute;
2864
2865#[deprecated]
2867#[cfg(all(
2868 feature = "SecAsn1Types",
2869 feature = "cssmconfig",
2870 feature = "cssmkrapi"
2871))]
2872pub type CSSM_CONTEXT_ATTRIBUTE_PTR = *mut cssm_context_attribute;
2873
2874#[cfg(all(
2876 feature = "SecAsn1Types",
2877 feature = "cssmconfig",
2878 feature = "cssmkrapi"
2879))]
2880#[deprecated]
2881#[repr(C)]
2882#[derive(Clone, Copy, Debug, PartialEq)]
2883pub struct cssm_context {
2884 pub ContextType: CSSM_CONTEXT_TYPE,
2885 pub AlgorithmType: CSSM_ALGORITHMS,
2886 pub NumberOfAttributes: uint32,
2887 pub ContextAttributes: CSSM_CONTEXT_ATTRIBUTE_PTR,
2888 pub CSPHandle: CSSM_CSP_HANDLE,
2889 pub Privileged: CSSM_BOOL,
2890 pub EncryptionProhibited: uint32,
2891 pub WorkFactor: uint32,
2892 pub Reserved: uint32,
2893}
2894
2895#[cfg(all(
2896 feature = "SecAsn1Types",
2897 feature = "cssmconfig",
2898 feature = "cssmkrapi",
2899 feature = "objc2"
2900))]
2901unsafe impl Encode for cssm_context {
2902 const ENCODING: Encoding = Encoding::Struct(
2903 "cssm_context",
2904 &[
2905 <CSSM_CONTEXT_TYPE>::ENCODING,
2906 <CSSM_ALGORITHMS>::ENCODING,
2907 <uint32>::ENCODING,
2908 <CSSM_CONTEXT_ATTRIBUTE_PTR>::ENCODING,
2909 <CSSM_CSP_HANDLE>::ENCODING,
2910 <CSSM_BOOL>::ENCODING,
2911 <uint32>::ENCODING,
2912 <uint32>::ENCODING,
2913 <uint32>::ENCODING,
2914 ],
2915 );
2916}
2917
2918#[cfg(all(
2919 feature = "SecAsn1Types",
2920 feature = "cssmconfig",
2921 feature = "cssmkrapi",
2922 feature = "objc2"
2923))]
2924unsafe impl RefEncode for cssm_context {
2925 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
2926}
2927
2928#[deprecated]
2930#[cfg(all(
2931 feature = "SecAsn1Types",
2932 feature = "cssmconfig",
2933 feature = "cssmkrapi"
2934))]
2935pub type CSSM_CONTEXT = cssm_context;
2936
2937#[deprecated]
2939#[cfg(all(
2940 feature = "SecAsn1Types",
2941 feature = "cssmconfig",
2942 feature = "cssmkrapi"
2943))]
2944pub type CSSM_CONTEXT_PTR = *mut cssm_context;
2945
2946#[cfg(feature = "cssmconfig")]
2948pub type CSSM_SC_FLAGS = uint32;
2949
2950pub const CSSM_CSP_TOK_RNG: c_uint = 1;
2952pub const CSSM_CSP_TOK_CLOCK_EXISTS: c_uint = 64;
2954
2955#[cfg(feature = "cssmconfig")]
2957pub type CSSM_CSP_READER_FLAGS = uint32;
2958
2959pub const CSSM_CSP_RDR_TOKENPRESENT: c_uint = 1;
2961pub const CSSM_CSP_RDR_EXISTS: c_uint = 2;
2963pub const CSSM_CSP_RDR_HW: c_uint = 4;
2965
2966#[cfg(feature = "cssmconfig")]
2968pub type CSSM_CSP_FLAGS = uint32;
2969
2970pub const CSSM_CSP_TOK_WRITE_PROTECTED: c_uint = 2;
2972pub const CSSM_CSP_TOK_LOGIN_REQUIRED: c_uint = 4;
2974pub const CSSM_CSP_TOK_USER_PIN_INITIALIZED: c_uint = 8;
2976pub const CSSM_CSP_TOK_PROT_AUTHENTICATION: c_uint = 256;
2978pub const CSSM_CSP_TOK_USER_PIN_EXPIRED: c_uint = 1048576;
2980pub const CSSM_CSP_TOK_SESSION_KEY_PASSWORD: c_uint = 2097152;
2982pub const CSSM_CSP_TOK_PRIVATE_KEY_PASSWORD: c_uint = 4194304;
2984pub const CSSM_CSP_STORES_PRIVATE_KEYS: c_uint = 16777216;
2986pub const CSSM_CSP_STORES_PUBLIC_KEYS: c_uint = 33554432;
2988pub const CSSM_CSP_STORES_SESSION_KEYS: c_uint = 67108864;
2990pub const CSSM_CSP_STORES_CERTIFICATES: c_uint = 134217728;
2992pub const CSSM_CSP_STORES_GENERIC: c_uint = 268435456;
2994
2995#[cfg(feature = "cssmconfig")]
2997pub type CSSM_PKCS_OAEP_MGF = uint32;
2998
2999pub const CSSM_PKCS_OAEP_MGF_NONE: c_uint = 0;
3001pub const CSSM_PKCS_OAEP_MGF1_SHA1: c_uint = 1;
3003pub const CSSM_PKCS_OAEP_MGF1_MD5: c_uint = 2;
3005
3006#[cfg(feature = "cssmconfig")]
3008pub type CSSM_PKCS_OAEP_PSOURCE = uint32;
3009
3010pub const CSSM_PKCS_OAEP_PSOURCE_NONE: c_uint = 0;
3012pub const CSSM_PKCS_OAEP_PSOURCE_Pspecified: c_uint = 1;
3014
3015#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3017#[deprecated]
3018#[repr(C)]
3019#[derive(Clone, Copy, Debug, PartialEq)]
3020pub struct cssm_pkcs1_oaep_params {
3021 pub HashAlgorithm: uint32,
3022 pub HashParams: SecAsn1Item,
3023 pub MGF: CSSM_PKCS_OAEP_MGF,
3024 pub MGFParams: SecAsn1Item,
3025 pub PSource: CSSM_PKCS_OAEP_PSOURCE,
3026 pub PSourceParams: SecAsn1Item,
3027}
3028
3029#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3030unsafe impl Encode for cssm_pkcs1_oaep_params {
3031 const ENCODING: Encoding = Encoding::Struct(
3032 "cssm_pkcs1_oaep_params",
3033 &[
3034 <uint32>::ENCODING,
3035 <SecAsn1Item>::ENCODING,
3036 <CSSM_PKCS_OAEP_MGF>::ENCODING,
3037 <SecAsn1Item>::ENCODING,
3038 <CSSM_PKCS_OAEP_PSOURCE>::ENCODING,
3039 <SecAsn1Item>::ENCODING,
3040 ],
3041 );
3042}
3043
3044#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3045unsafe impl RefEncode for cssm_pkcs1_oaep_params {
3046 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3047}
3048
3049#[deprecated]
3051#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3052pub type CSSM_PKCS1_OAEP_PARAMS = cssm_pkcs1_oaep_params;
3053
3054#[deprecated]
3056#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3057pub type CSSM_PKCS1_OAEP_PARAMS_PTR = *mut cssm_pkcs1_oaep_params;
3058
3059#[cfg(feature = "cssmconfig")]
3061#[repr(C)]
3062#[derive(Clone, Copy, Debug, PartialEq)]
3063pub struct cssm_csp_operational_statistics {
3064 pub UserAuthenticated: CSSM_BOOL,
3065 pub DeviceFlags: CSSM_CSP_FLAGS,
3066 pub TokenMaxSessionCount: uint32,
3067 pub TokenOpenedSessionCount: uint32,
3068 pub TokenMaxRWSessionCount: uint32,
3069 pub TokenOpenedRWSessionCount: uint32,
3070 pub TokenTotalPublicMem: uint32,
3071 pub TokenFreePublicMem: uint32,
3072 pub TokenTotalPrivateMem: uint32,
3073 pub TokenFreePrivateMem: uint32,
3074}
3075
3076#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3077unsafe impl Encode for cssm_csp_operational_statistics {
3078 const ENCODING: Encoding = Encoding::Struct(
3079 "cssm_csp_operational_statistics",
3080 &[
3081 <CSSM_BOOL>::ENCODING,
3082 <CSSM_CSP_FLAGS>::ENCODING,
3083 <uint32>::ENCODING,
3084 <uint32>::ENCODING,
3085 <uint32>::ENCODING,
3086 <uint32>::ENCODING,
3087 <uint32>::ENCODING,
3088 <uint32>::ENCODING,
3089 <uint32>::ENCODING,
3090 <uint32>::ENCODING,
3091 ],
3092 );
3093}
3094
3095#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3096unsafe impl RefEncode for cssm_csp_operational_statistics {
3097 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3098}
3099
3100#[deprecated]
3102#[cfg(feature = "cssmconfig")]
3103pub type CSSM_CSP_OPERATIONAL_STATISTICS = cssm_csp_operational_statistics;
3104
3105#[deprecated]
3107#[cfg(feature = "cssmconfig")]
3108pub type CSSM_CSP_OPERATIONAL_STATISTICS_PTR = *mut cssm_csp_operational_statistics;
3109
3110pub const CSSM_VALUE_NOT_AVAILABLE: c_int = -1;
3112
3113#[cfg(feature = "SecAsn1Types")]
3115#[deprecated]
3116#[repr(C)]
3117#[derive(Clone, Copy, Debug, PartialEq)]
3118pub struct cssm_pkcs5_pbkdf1_params {
3119 pub Passphrase: SecAsn1Item,
3120 pub InitVector: SecAsn1Item,
3121}
3122
3123#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3124unsafe impl Encode for cssm_pkcs5_pbkdf1_params {
3125 const ENCODING: Encoding = Encoding::Struct(
3126 "cssm_pkcs5_pbkdf1_params",
3127 &[<SecAsn1Item>::ENCODING, <SecAsn1Item>::ENCODING],
3128 );
3129}
3130
3131#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3132unsafe impl RefEncode for cssm_pkcs5_pbkdf1_params {
3133 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3134}
3135
3136#[deprecated]
3138#[cfg(feature = "SecAsn1Types")]
3139pub type CSSM_PKCS5_PBKDF1_PARAMS = cssm_pkcs5_pbkdf1_params;
3140
3141#[deprecated]
3143#[cfg(feature = "SecAsn1Types")]
3144pub type CSSM_PKCS5_PBKDF1_PARAMS_PTR = *mut cssm_pkcs5_pbkdf1_params;
3145
3146#[cfg(feature = "cssmconfig")]
3148pub type CSSM_PKCS5_PBKDF2_PRF = uint32;
3149
3150pub const CSSM_PKCS5_PBKDF2_PRF_HMAC_SHA1: c_uint = 0;
3152
3153#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3155#[deprecated]
3156#[repr(C)]
3157#[derive(Clone, Copy, Debug, PartialEq)]
3158pub struct cssm_pkcs5_pbkdf2_params {
3159 pub Passphrase: SecAsn1Item,
3160 pub PseudoRandomFunction: CSSM_PKCS5_PBKDF2_PRF,
3161}
3162
3163#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3164unsafe impl Encode for cssm_pkcs5_pbkdf2_params {
3165 const ENCODING: Encoding = Encoding::Struct(
3166 "cssm_pkcs5_pbkdf2_params",
3167 &[<SecAsn1Item>::ENCODING, <CSSM_PKCS5_PBKDF2_PRF>::ENCODING],
3168 );
3169}
3170
3171#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3172unsafe impl RefEncode for cssm_pkcs5_pbkdf2_params {
3173 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3174}
3175
3176#[deprecated]
3178#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3179pub type CSSM_PKCS5_PBKDF2_PARAMS = cssm_pkcs5_pbkdf2_params;
3180
3181#[deprecated]
3183#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3184pub type CSSM_PKCS5_PBKDF2_PARAMS_PTR = *mut cssm_pkcs5_pbkdf2_params;
3185
3186#[cfg(feature = "SecAsn1Types")]
3188#[deprecated]
3189#[repr(C)]
3190#[derive(Clone, Copy, Debug, PartialEq)]
3191pub struct cssm_kea_derive_params {
3192 pub Rb: SecAsn1Item,
3193 pub Yb: SecAsn1Item,
3194}
3195
3196#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3197unsafe impl Encode for cssm_kea_derive_params {
3198 const ENCODING: Encoding = Encoding::Struct(
3199 "cssm_kea_derive_params",
3200 &[<SecAsn1Item>::ENCODING, <SecAsn1Item>::ENCODING],
3201 );
3202}
3203
3204#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3205unsafe impl RefEncode for cssm_kea_derive_params {
3206 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3207}
3208
3209#[deprecated]
3211#[cfg(feature = "SecAsn1Types")]
3212pub type CSSM_KEA_DERIVE_PARAMS = cssm_kea_derive_params;
3213
3214#[deprecated]
3216#[cfg(feature = "SecAsn1Types")]
3217pub type CSSM_KEA_DERIVE_PARAMS_PTR = *mut cssm_kea_derive_params;
3218
3219#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3221#[deprecated]
3222#[repr(C)]
3223#[derive(Clone, Copy, Debug, PartialEq)]
3224pub struct cssm_tp_authority_id {
3225 pub AuthorityCert: *mut SecAsn1Item,
3226 pub AuthorityLocation: CSSM_NET_ADDRESS_PTR,
3227}
3228
3229#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3230unsafe impl Encode for cssm_tp_authority_id {
3231 const ENCODING: Encoding = Encoding::Struct(
3232 "cssm_tp_authority_id",
3233 &[
3234 <*mut SecAsn1Item>::ENCODING,
3235 <CSSM_NET_ADDRESS_PTR>::ENCODING,
3236 ],
3237 );
3238}
3239
3240#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3241unsafe impl RefEncode for cssm_tp_authority_id {
3242 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3243}
3244
3245#[deprecated]
3247#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3248pub type CSSM_TP_AUTHORITY_ID = cssm_tp_authority_id;
3249
3250#[deprecated]
3252#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3253pub type CSSM_TP_AUTHORITY_ID_PTR = *mut cssm_tp_authority_id;
3254
3255#[cfg(feature = "cssmconfig")]
3257pub type CSSM_TP_AUTHORITY_REQUEST_TYPE = uint32;
3258
3259#[cfg(feature = "cssmconfig")]
3261pub type CSSM_TP_AUTHORITY_REQUEST_TYPE_PTR = *mut uint32;
3262
3263pub const CSSM_TP_AUTHORITY_REQUEST_CERTISSUE: c_uint = 1;
3265pub const CSSM_TP_AUTHORITY_REQUEST_CERTREVOKE: c_uint = 2;
3267pub const CSSM_TP_AUTHORITY_REQUEST_CERTSUSPEND: c_uint = 3;
3269pub const CSSM_TP_AUTHORITY_REQUEST_CERTRESUME: c_uint = 4;
3271pub const CSSM_TP_AUTHORITY_REQUEST_CERTVERIFY: c_uint = 5;
3273pub const CSSM_TP_AUTHORITY_REQUEST_CERTNOTARIZE: c_uint = 6;
3275pub const CSSM_TP_AUTHORITY_REQUEST_CERTUSERECOVER: c_uint = 7;
3277pub const CSSM_TP_AUTHORITY_REQUEST_CRLISSUE: c_uint = 256;
3279
3280#[deprecated]
3282#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3283pub type CSSM_TP_VERIFICATION_RESULTS_CALLBACK = Option<
3284 unsafe extern "C-unwind" fn(CSSM_MODULE_HANDLE, *mut c_void, CSSM_DATA_PTR) -> CSSM_RETURN,
3285>;
3286
3287#[deprecated]
3289#[cfg(feature = "SecAsn1Types")]
3290pub type CSSM_OID_PTR = *mut SecAsn1Oid;
3291
3292#[cfg(feature = "SecAsn1Types")]
3294#[deprecated]
3295#[repr(C)]
3296#[derive(Clone, Copy, Debug, PartialEq)]
3297pub struct cssm_field {
3298 pub FieldOid: SecAsn1Oid,
3299 pub FieldValue: SecAsn1Item,
3300}
3301
3302#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3303unsafe impl Encode for cssm_field {
3304 const ENCODING: Encoding = Encoding::Struct(
3305 "cssm_field",
3306 &[<SecAsn1Oid>::ENCODING, <SecAsn1Item>::ENCODING],
3307 );
3308}
3309
3310#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3311unsafe impl RefEncode for cssm_field {
3312 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3313}
3314
3315#[deprecated]
3317#[cfg(feature = "SecAsn1Types")]
3318pub type CSSM_FIELD = cssm_field;
3319
3320#[deprecated]
3322#[cfg(feature = "SecAsn1Types")]
3323pub type CSSM_FIELD_PTR = *mut cssm_field;
3324
3325#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3327#[deprecated]
3328#[repr(C)]
3329#[derive(Clone, Copy, Debug, PartialEq)]
3330pub struct cssm_tp_policyinfo {
3331 pub NumberOfPolicyIds: uint32,
3332 pub PolicyIds: CSSM_FIELD_PTR,
3333 pub PolicyControl: *mut c_void,
3334}
3335
3336#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3337unsafe impl Encode for cssm_tp_policyinfo {
3338 const ENCODING: Encoding = Encoding::Struct(
3339 "cssm_tp_policyinfo",
3340 &[
3341 <uint32>::ENCODING,
3342 <CSSM_FIELD_PTR>::ENCODING,
3343 <*mut c_void>::ENCODING,
3344 ],
3345 );
3346}
3347
3348#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3349unsafe impl RefEncode for cssm_tp_policyinfo {
3350 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3351}
3352
3353#[deprecated]
3355#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3356pub type CSSM_TP_POLICYINFO = cssm_tp_policyinfo;
3357
3358#[deprecated]
3360#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3361pub type CSSM_TP_POLICYINFO_PTR = *mut cssm_tp_policyinfo;
3362
3363#[cfg(feature = "cssmconfig")]
3365pub type CSSM_TP_SERVICES = uint32;
3366
3367pub const CSSM_TP_KEY_ARCHIVE: c_uint = 1;
3369pub const CSSM_TP_CERT_PUBLISH: c_uint = 2;
3371pub const CSSM_TP_CERT_NOTIFY_RENEW: c_uint = 4;
3373pub const CSSM_TP_CERT_DIR_UPDATE: c_uint = 8;
3375pub const CSSM_TP_CRL_DISTRIBUTE: c_uint = 16;
3377
3378#[cfg(feature = "cssmconfig")]
3380pub type CSSM_TP_ACTION = uint32;
3381
3382pub const CSSM_TP_ACTION_DEFAULT: c_uint = 0;
3384
3385#[cfg(feature = "cssmconfig")]
3387pub type CSSM_TP_STOP_ON = uint32;
3388
3389pub const CSSM_TP_STOP_ON_POLICY: c_uint = 0;
3391pub const CSSM_TP_STOP_ON_NONE: c_uint = 1;
3393pub const CSSM_TP_STOP_ON_FIRST_PASS: c_uint = 2;
3395pub const CSSM_TP_STOP_ON_FIRST_FAIL: c_uint = 3;
3397
3398pub type CSSM_TIMESTRING = *mut c_char;
3400
3401#[cfg(feature = "cssmconfig")]
3403#[deprecated]
3404#[repr(C)]
3405#[derive(Clone, Copy, Debug, PartialEq)]
3406pub struct cssm_dl_db_list {
3407 pub NumHandles: uint32,
3408 pub DLDBHandle: CSSM_DL_DB_HANDLE_PTR,
3409}
3410
3411#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3412unsafe impl Encode for cssm_dl_db_list {
3413 const ENCODING: Encoding = Encoding::Struct(
3414 "cssm_dl_db_list",
3415 &[<uint32>::ENCODING, <CSSM_DL_DB_HANDLE_PTR>::ENCODING],
3416 );
3417}
3418
3419#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3420unsafe impl RefEncode for cssm_dl_db_list {
3421 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3422}
3423
3424#[deprecated]
3426#[cfg(feature = "cssmconfig")]
3427pub type CSSM_DL_DB_LIST = cssm_dl_db_list;
3428
3429#[deprecated]
3431#[cfg(feature = "cssmconfig")]
3432pub type CSSM_DL_DB_LIST_PTR = *mut cssm_dl_db_list;
3433
3434#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3436#[deprecated]
3437#[repr(C)]
3438#[allow(unpredictable_function_pointer_comparisons)]
3439#[derive(Clone, Copy, Debug, PartialEq)]
3440pub struct cssm_tp_callerauth_context {
3441 pub Policy: CSSM_TP_POLICYINFO,
3442 pub VerifyTime: CSSM_TIMESTRING,
3443 pub VerificationAbortOn: CSSM_TP_STOP_ON,
3444 pub CallbackWithVerifiedCert: CSSM_TP_VERIFICATION_RESULTS_CALLBACK,
3445 pub NumberOfAnchorCerts: uint32,
3446 pub AnchorCerts: CSSM_DATA_PTR,
3447 pub DBList: CSSM_DL_DB_LIST_PTR,
3448 pub CallerCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
3449}
3450
3451#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3452unsafe impl Encode for cssm_tp_callerauth_context {
3453 const ENCODING: Encoding = Encoding::Struct(
3454 "cssm_tp_callerauth_context",
3455 &[
3456 <CSSM_TP_POLICYINFO>::ENCODING,
3457 <CSSM_TIMESTRING>::ENCODING,
3458 <CSSM_TP_STOP_ON>::ENCODING,
3459 <CSSM_TP_VERIFICATION_RESULTS_CALLBACK>::ENCODING,
3460 <uint32>::ENCODING,
3461 <CSSM_DATA_PTR>::ENCODING,
3462 <CSSM_DL_DB_LIST_PTR>::ENCODING,
3463 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
3464 ],
3465 );
3466}
3467
3468#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3469unsafe impl RefEncode for cssm_tp_callerauth_context {
3470 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3471}
3472
3473#[deprecated]
3475#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3476pub type CSSM_TP_CALLERAUTH_CONTEXT = cssm_tp_callerauth_context;
3477
3478#[deprecated]
3480#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3481pub type CSSM_TP_CALLERAUTH_CONTEXT_PTR = *mut cssm_tp_callerauth_context;
3482
3483#[cfg(feature = "cssmconfig")]
3485pub type CSSM_CRL_PARSE_FORMAT = uint32;
3486
3487#[cfg(feature = "cssmconfig")]
3489pub type CSSM_CRL_PARSE_FORMAT_PTR = *mut uint32;
3490
3491pub const CSSM_CRL_PARSE_FORMAT_NONE: c_uint = 0;
3493pub const CSSM_CRL_PARSE_FORMAT_CUSTOM: c_uint = 1;
3495pub const CSSM_CRL_PARSE_FORMAT_SEXPR: c_uint = 2;
3497pub const CSSM_CRL_PARSE_FORMAT_COMPLEX: c_uint = 3;
3499pub const CSSM_CRL_PARSE_FORMAT_OID_NAMED: c_uint = 4;
3501pub const CSSM_CRL_PARSE_FORMAT_TUPLE: c_uint = 5;
3503pub const CSSM_CRL_PARSE_FORMAT_MULTIPLE: c_uint = 32766;
3505pub const CSSM_CRL_PARSE_FORMAT_LAST: c_uint = 32767;
3507pub const CSSM_CL_CUSTOM_CRL_PARSE_FORMAT: c_uint = 32768;
3509
3510#[cfg(feature = "cssmconfig")]
3512pub type CSSM_CRL_TYPE = uint32;
3513
3514#[cfg(feature = "cssmconfig")]
3516pub type CSSM_CRL_TYPE_PTR = *mut uint32;
3517
3518pub const CSSM_CRL_TYPE_UNKNOWN: c_uint = 0;
3520pub const CSSM_CRL_TYPE_X_509v1: c_uint = 1;
3522pub const CSSM_CRL_TYPE_X_509v2: c_uint = 2;
3524pub const CSSM_CRL_TYPE_SPKI: c_uint = 3;
3526pub const CSSM_CRL_TYPE_MULTIPLE: c_uint = 32766;
3528
3529#[cfg(feature = "cssmconfig")]
3531pub type CSSM_CRL_ENCODING = uint32;
3532
3533#[cfg(feature = "cssmconfig")]
3535pub type CSSM_CRL_ENCODING_PTR = *mut uint32;
3536
3537pub const CSSM_CRL_ENCODING_UNKNOWN: c_uint = 0;
3539pub const CSSM_CRL_ENCODING_CUSTOM: c_uint = 1;
3541pub const CSSM_CRL_ENCODING_BER: c_uint = 2;
3543pub const CSSM_CRL_ENCODING_DER: c_uint = 3;
3545pub const CSSM_CRL_ENCODING_BLOOM: c_uint = 4;
3547pub const CSSM_CRL_ENCODING_SEXPR: c_uint = 5;
3549pub const CSSM_CRL_ENCODING_MULTIPLE: c_uint = 32766;
3551
3552#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3554#[deprecated]
3555#[repr(C)]
3556#[derive(Clone, Copy, Debug, PartialEq)]
3557pub struct cssm_encoded_crl {
3558 pub CrlType: CSSM_CRL_TYPE,
3559 pub CrlEncoding: CSSM_CRL_ENCODING,
3560 pub CrlBlob: SecAsn1Item,
3561}
3562
3563#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3564unsafe impl Encode for cssm_encoded_crl {
3565 const ENCODING: Encoding = Encoding::Struct(
3566 "cssm_encoded_crl",
3567 &[
3568 <CSSM_CRL_TYPE>::ENCODING,
3569 <CSSM_CRL_ENCODING>::ENCODING,
3570 <SecAsn1Item>::ENCODING,
3571 ],
3572 );
3573}
3574
3575#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3576unsafe impl RefEncode for cssm_encoded_crl {
3577 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3578}
3579
3580#[deprecated]
3582#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3583pub type CSSM_ENCODED_CRL = cssm_encoded_crl;
3584
3585#[deprecated]
3587#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3588pub type CSSM_ENCODED_CRL_PTR = *mut cssm_encoded_crl;
3589
3590#[cfg(feature = "cssmconfig")]
3592#[repr(C)]
3593#[derive(Clone, Copy, Debug, PartialEq)]
3594pub struct cssm_parsed_crl {
3595 pub CrlType: CSSM_CRL_TYPE,
3596 pub ParsedCrlFormat: CSSM_CRL_PARSE_FORMAT,
3597 pub ParsedCrl: *mut c_void,
3598}
3599
3600#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3601unsafe impl Encode for cssm_parsed_crl {
3602 const ENCODING: Encoding = Encoding::Struct(
3603 "cssm_parsed_crl",
3604 &[
3605 <CSSM_CRL_TYPE>::ENCODING,
3606 <CSSM_CRL_PARSE_FORMAT>::ENCODING,
3607 <*mut c_void>::ENCODING,
3608 ],
3609 );
3610}
3611
3612#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3613unsafe impl RefEncode for cssm_parsed_crl {
3614 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3615}
3616
3617#[deprecated]
3619#[cfg(feature = "cssmconfig")]
3620pub type CSSM_PARSED_CRL = cssm_parsed_crl;
3621
3622#[deprecated]
3624#[cfg(feature = "cssmconfig")]
3625pub type CSSM_PARSED_CRL_PTR = *mut cssm_parsed_crl;
3626
3627#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3629#[deprecated]
3630#[repr(C)]
3631#[derive(Clone, Copy, Debug, PartialEq)]
3632pub struct cssm_crl_pair {
3633 pub EncodedCrl: CSSM_ENCODED_CRL,
3634 pub ParsedCrl: CSSM_PARSED_CRL,
3635}
3636
3637#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3638unsafe impl Encode for cssm_crl_pair {
3639 const ENCODING: Encoding = Encoding::Struct(
3640 "cssm_crl_pair",
3641 &[<CSSM_ENCODED_CRL>::ENCODING, <CSSM_PARSED_CRL>::ENCODING],
3642 );
3643}
3644
3645#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3646unsafe impl RefEncode for cssm_crl_pair {
3647 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3648}
3649
3650#[deprecated]
3652#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3653pub type CSSM_CRL_PAIR = cssm_crl_pair;
3654
3655#[deprecated]
3657#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3658pub type CSSM_CRL_PAIR_PTR = *mut cssm_crl_pair;
3659
3660#[cfg(feature = "cssmconfig")]
3662pub type CSSM_CRLGROUP_TYPE = uint32;
3663
3664#[cfg(feature = "cssmconfig")]
3666pub type CSSM_CRLGROUP_TYPE_PTR = *mut uint32;
3667
3668pub const CSSM_CRLGROUP_DATA: c_uint = 0;
3670pub const CSSM_CRLGROUP_ENCODED_CRL: c_uint = 1;
3672pub const CSSM_CRLGROUP_PARSED_CRL: c_uint = 2;
3674pub const CSSM_CRLGROUP_CRL_PAIR: c_uint = 3;
3676
3677#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3679#[repr(C)]
3680#[derive(Clone, Copy)]
3681pub union cssm_crlgroup_GroupCrlList {
3682 pub CrlList: CSSM_DATA_PTR,
3683 pub EncodedCrlList: CSSM_ENCODED_CRL_PTR,
3684 pub ParsedCrlList: CSSM_PARSED_CRL_PTR,
3685 pub PairCrlList: CSSM_CRL_PAIR_PTR,
3686}
3687
3688#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3689unsafe impl Encode for cssm_crlgroup_GroupCrlList {
3690 const ENCODING: Encoding = Encoding::Union(
3691 "?",
3692 &[
3693 <CSSM_DATA_PTR>::ENCODING,
3694 <CSSM_ENCODED_CRL_PTR>::ENCODING,
3695 <CSSM_PARSED_CRL_PTR>::ENCODING,
3696 <CSSM_CRL_PAIR_PTR>::ENCODING,
3697 ],
3698 );
3699}
3700
3701#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3702unsafe impl RefEncode for cssm_crlgroup_GroupCrlList {
3703 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3704}
3705
3706#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3708#[deprecated]
3709#[repr(C)]
3710#[derive(Clone, Copy)]
3711pub struct cssm_crlgroup {
3712 pub CrlType: CSSM_CRL_TYPE,
3713 pub CrlEncoding: CSSM_CRL_ENCODING,
3714 pub NumberOfCrls: uint32,
3715 pub GroupCrlList: cssm_crlgroup_GroupCrlList,
3716 pub CrlGroupType: CSSM_CRLGROUP_TYPE,
3717}
3718
3719#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3720unsafe impl Encode for cssm_crlgroup {
3721 const ENCODING: Encoding = Encoding::Struct(
3722 "cssm_crlgroup",
3723 &[
3724 <CSSM_CRL_TYPE>::ENCODING,
3725 <CSSM_CRL_ENCODING>::ENCODING,
3726 <uint32>::ENCODING,
3727 <cssm_crlgroup_GroupCrlList>::ENCODING,
3728 <CSSM_CRLGROUP_TYPE>::ENCODING,
3729 ],
3730 );
3731}
3732
3733#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3734unsafe impl RefEncode for cssm_crlgroup {
3735 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3736}
3737
3738#[deprecated]
3740#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3741pub type CSSM_CRLGROUP = cssm_crlgroup;
3742
3743#[deprecated]
3745#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3746pub type CSSM_CRLGROUP_PTR = *mut cssm_crlgroup;
3747
3748#[cfg(feature = "SecAsn1Types")]
3750#[deprecated]
3751#[repr(C)]
3752#[derive(Clone, Copy, Debug, PartialEq)]
3753pub struct cssm_fieldgroup {
3754 pub NumberOfFields: c_int,
3755 pub Fields: CSSM_FIELD_PTR,
3756}
3757
3758#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3759unsafe impl Encode for cssm_fieldgroup {
3760 const ENCODING: Encoding = Encoding::Struct(
3761 "cssm_fieldgroup",
3762 &[<c_int>::ENCODING, <CSSM_FIELD_PTR>::ENCODING],
3763 );
3764}
3765
3766#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
3767unsafe impl RefEncode for cssm_fieldgroup {
3768 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3769}
3770
3771#[deprecated]
3773#[cfg(feature = "SecAsn1Types")]
3774pub type CSSM_FIELDGROUP = cssm_fieldgroup;
3775
3776#[deprecated]
3778#[cfg(feature = "SecAsn1Types")]
3779pub type CSSM_FIELDGROUP_PTR = *mut cssm_fieldgroup;
3780
3781#[cfg(feature = "cssmconfig")]
3783pub type CSSM_EVIDENCE_FORM = uint32;
3784
3785pub const CSSM_EVIDENCE_FORM_UNSPECIFIC: c_uint = 0;
3787pub const CSSM_EVIDENCE_FORM_CERT: c_uint = 1;
3789pub const CSSM_EVIDENCE_FORM_CRL: c_uint = 2;
3791pub const CSSM_EVIDENCE_FORM_CERT_ID: c_uint = 3;
3793pub const CSSM_EVIDENCE_FORM_CRL_ID: c_uint = 4;
3795pub const CSSM_EVIDENCE_FORM_VERIFIER_TIME: c_uint = 5;
3797pub const CSSM_EVIDENCE_FORM_CRL_THISTIME: c_uint = 6;
3799pub const CSSM_EVIDENCE_FORM_CRL_NEXTTIME: c_uint = 7;
3801pub const CSSM_EVIDENCE_FORM_POLICYINFO: c_uint = 8;
3803pub const CSSM_EVIDENCE_FORM_TUPLEGROUP: c_uint = 9;
3805
3806#[cfg(feature = "cssmconfig")]
3808#[deprecated]
3809#[repr(C)]
3810#[derive(Clone, Copy, Debug, PartialEq)]
3811pub struct cssm_evidence {
3812 pub EvidenceForm: CSSM_EVIDENCE_FORM,
3813 pub Evidence: *mut c_void,
3814}
3815
3816#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3817unsafe impl Encode for cssm_evidence {
3818 const ENCODING: Encoding = Encoding::Struct(
3819 "cssm_evidence",
3820 &[<CSSM_EVIDENCE_FORM>::ENCODING, <*mut c_void>::ENCODING],
3821 );
3822}
3823
3824#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3825unsafe impl RefEncode for cssm_evidence {
3826 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3827}
3828
3829#[deprecated]
3831#[cfg(feature = "cssmconfig")]
3832pub type CSSM_EVIDENCE = cssm_evidence;
3833
3834#[deprecated]
3836#[cfg(feature = "cssmconfig")]
3837pub type CSSM_EVIDENCE_PTR = *mut cssm_evidence;
3838
3839#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3841#[deprecated]
3842#[repr(C)]
3843#[derive(Clone, Copy)]
3844pub struct cssm_tp_verify_context {
3845 pub Action: CSSM_TP_ACTION,
3846 pub ActionData: SecAsn1Item,
3847 pub Crls: CSSM_CRLGROUP,
3848 pub Cred: CSSM_TP_CALLERAUTH_CONTEXT_PTR,
3849}
3850
3851#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3852unsafe impl Encode for cssm_tp_verify_context {
3853 const ENCODING: Encoding = Encoding::Struct(
3854 "cssm_tp_verify_context",
3855 &[
3856 <CSSM_TP_ACTION>::ENCODING,
3857 <SecAsn1Item>::ENCODING,
3858 <CSSM_CRLGROUP>::ENCODING,
3859 <CSSM_TP_CALLERAUTH_CONTEXT_PTR>::ENCODING,
3860 ],
3861 );
3862}
3863
3864#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
3865unsafe impl RefEncode for cssm_tp_verify_context {
3866 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3867}
3868
3869#[deprecated]
3871#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3872pub type CSSM_TP_VERIFY_CONTEXT = cssm_tp_verify_context;
3873
3874#[deprecated]
3876#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
3877pub type CSSM_TP_VERIFY_CONTEXT_PTR = *mut cssm_tp_verify_context;
3878
3879#[cfg(feature = "cssmconfig")]
3881#[deprecated]
3882#[repr(C)]
3883#[derive(Clone, Copy, Debug, PartialEq)]
3884pub struct cssm_tp_verify_context_result {
3885 pub NumberOfEvidences: uint32,
3886 pub Evidence: CSSM_EVIDENCE_PTR,
3887}
3888
3889#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3890unsafe impl Encode for cssm_tp_verify_context_result {
3891 const ENCODING: Encoding = Encoding::Struct(
3892 "cssm_tp_verify_context_result",
3893 &[<uint32>::ENCODING, <CSSM_EVIDENCE_PTR>::ENCODING],
3894 );
3895}
3896
3897#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3898unsafe impl RefEncode for cssm_tp_verify_context_result {
3899 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3900}
3901
3902#[deprecated]
3904#[cfg(feature = "cssmconfig")]
3905pub type CSSM_TP_VERIFY_CONTEXT_RESULT = cssm_tp_verify_context_result;
3906
3907#[deprecated]
3909#[cfg(feature = "cssmconfig")]
3910pub type CSSM_TP_VERIFY_CONTEXT_RESULT_PTR = *mut cssm_tp_verify_context_result;
3911
3912#[cfg(feature = "cssmconfig")]
3914#[deprecated]
3915#[repr(C)]
3916#[derive(Clone, Copy, Debug, PartialEq)]
3917pub struct cssm_tp_request_set {
3918 pub NumberOfRequests: uint32,
3919 pub Requests: *mut c_void,
3920}
3921
3922#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3923unsafe impl Encode for cssm_tp_request_set {
3924 const ENCODING: Encoding = Encoding::Struct(
3925 "cssm_tp_request_set",
3926 &[<uint32>::ENCODING, <*mut c_void>::ENCODING],
3927 );
3928}
3929
3930#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3931unsafe impl RefEncode for cssm_tp_request_set {
3932 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3933}
3934
3935#[deprecated]
3937#[cfg(feature = "cssmconfig")]
3938pub type CSSM_TP_REQUEST_SET = cssm_tp_request_set;
3939
3940#[deprecated]
3942#[cfg(feature = "cssmconfig")]
3943pub type CSSM_TP_REQUEST_SET_PTR = *mut cssm_tp_request_set;
3944
3945#[cfg(feature = "cssmconfig")]
3947#[repr(C)]
3948#[derive(Clone, Copy, Debug, PartialEq)]
3949pub struct cssm_tp_result_set {
3950 pub NumberOfResults: uint32,
3951 pub Results: *mut c_void,
3952}
3953
3954#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3955unsafe impl Encode for cssm_tp_result_set {
3956 const ENCODING: Encoding = Encoding::Struct(
3957 "cssm_tp_result_set",
3958 &[<uint32>::ENCODING, <*mut c_void>::ENCODING],
3959 );
3960}
3961
3962#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
3963unsafe impl RefEncode for cssm_tp_result_set {
3964 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
3965}
3966
3967#[deprecated]
3969#[cfg(feature = "cssmconfig")]
3970pub type CSSM_TP_RESULT_SET = cssm_tp_result_set;
3971
3972#[deprecated]
3974#[cfg(feature = "cssmconfig")]
3975pub type CSSM_TP_RESULT_SET_PTR = *mut cssm_tp_result_set;
3976
3977#[cfg(feature = "cssmconfig")]
3979pub type CSSM_TP_CONFIRM_STATUS = uint32;
3980
3981#[cfg(feature = "cssmconfig")]
3983pub type CSSM_TP_CONFIRM_STATUS_PTR = *mut uint32;
3984
3985pub const CSSM_TP_CONFIRM_STATUS_UNKNOWN: c_uint = 0;
3987pub const CSSM_TP_CONFIRM_ACCEPT: c_uint = 1;
3989pub const CSSM_TP_CONFIRM_REJECT: c_uint = 2;
3991
3992#[cfg(feature = "cssmconfig")]
3994#[deprecated]
3995#[repr(C)]
3996#[derive(Clone, Copy, Debug, PartialEq)]
3997pub struct cssm_tp_confirm_response {
3998 pub NumberOfResponses: uint32,
3999 pub Responses: CSSM_TP_CONFIRM_STATUS_PTR,
4000}
4001
4002#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4003unsafe impl Encode for cssm_tp_confirm_response {
4004 const ENCODING: Encoding = Encoding::Struct(
4005 "cssm_tp_confirm_response",
4006 &[<uint32>::ENCODING, <CSSM_TP_CONFIRM_STATUS_PTR>::ENCODING],
4007 );
4008}
4009
4010#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4011unsafe impl RefEncode for cssm_tp_confirm_response {
4012 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4013}
4014
4015#[deprecated]
4017#[cfg(feature = "cssmconfig")]
4018pub type CSSM_TP_CONFIRM_RESPONSE = cssm_tp_confirm_response;
4019
4020#[deprecated]
4022#[cfg(feature = "cssmconfig")]
4023pub type CSSM_TP_CONFIRM_RESPONSE_PTR = *mut cssm_tp_confirm_response;
4024
4025pub const CSSM_ESTIMATED_TIME_UNKNOWN: c_int = -1;
4027
4028pub const CSSM_ELAPSED_TIME_UNKNOWN: c_int = -1;
4030pub const CSSM_ELAPSED_TIME_COMPLETE: c_int = -2;
4032
4033#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4035#[deprecated]
4036#[repr(C)]
4037#[derive(Clone, Copy, Debug, PartialEq)]
4038pub struct cssm_tp_certissue_input {
4039 pub CSPSubserviceUid: CSSM_SUBSERVICE_UID,
4040 pub CLHandle: CSSM_CL_HANDLE,
4041 pub NumberOfTemplateFields: uint32,
4042 pub SubjectCertFields: CSSM_FIELD_PTR,
4043 pub MoreServiceRequests: CSSM_TP_SERVICES,
4044 pub NumberOfServiceControls: uint32,
4045 pub ServiceControls: CSSM_FIELD_PTR,
4046 pub UserCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4047}
4048
4049#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4050unsafe impl Encode for cssm_tp_certissue_input {
4051 const ENCODING: Encoding = Encoding::Struct(
4052 "cssm_tp_certissue_input",
4053 &[
4054 <CSSM_SUBSERVICE_UID>::ENCODING,
4055 <CSSM_CL_HANDLE>::ENCODING,
4056 <uint32>::ENCODING,
4057 <CSSM_FIELD_PTR>::ENCODING,
4058 <CSSM_TP_SERVICES>::ENCODING,
4059 <uint32>::ENCODING,
4060 <CSSM_FIELD_PTR>::ENCODING,
4061 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4062 ],
4063 );
4064}
4065
4066#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4067unsafe impl RefEncode for cssm_tp_certissue_input {
4068 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4069}
4070
4071#[deprecated]
4073#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4074pub type CSSM_TP_CERTISSUE_INPUT = cssm_tp_certissue_input;
4075
4076#[deprecated]
4078#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4079pub type CSSM_TP_CERTISSUE_INPUT_PTR = *mut cssm_tp_certissue_input;
4080
4081#[cfg(feature = "cssmconfig")]
4083pub type CSSM_TP_CERTISSUE_STATUS = uint32;
4084
4085pub const CSSM_TP_CERTISSUE_STATUS_UNKNOWN: c_uint = 0;
4087pub const CSSM_TP_CERTISSUE_OK: c_uint = 1;
4089pub const CSSM_TP_CERTISSUE_OKWITHCERTMODS: c_uint = 2;
4091pub const CSSM_TP_CERTISSUE_OKWITHSERVICEMODS: c_uint = 3;
4093pub const CSSM_TP_CERTISSUE_REJECTED: c_uint = 4;
4095pub const CSSM_TP_CERTISSUE_NOT_AUTHORIZED: c_uint = 5;
4097pub const CSSM_TP_CERTISSUE_WILL_BE_REVOKED: c_uint = 6;
4099
4100#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4102#[deprecated]
4103#[repr(C)]
4104#[derive(Clone, Copy, Debug, PartialEq)]
4105pub struct cssm_tp_certissue_output {
4106 pub IssueStatus: CSSM_TP_CERTISSUE_STATUS,
4107 pub CertGroup: CSSM_CERTGROUP_PTR,
4108 pub PerformedServiceRequests: CSSM_TP_SERVICES,
4109}
4110
4111#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4112unsafe impl Encode for cssm_tp_certissue_output {
4113 const ENCODING: Encoding = Encoding::Struct(
4114 "cssm_tp_certissue_output",
4115 &[
4116 <CSSM_TP_CERTISSUE_STATUS>::ENCODING,
4117 <CSSM_CERTGROUP_PTR>::ENCODING,
4118 <CSSM_TP_SERVICES>::ENCODING,
4119 ],
4120 );
4121}
4122
4123#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4124unsafe impl RefEncode for cssm_tp_certissue_output {
4125 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4126}
4127
4128#[deprecated]
4130#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4131pub type CSSM_TP_CERTISSUE_OUTPUT = cssm_tp_certissue_output;
4132
4133#[deprecated]
4135#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4136pub type CSSM_TP_CERTISSUE_OUTPUT_PTR = *mut cssm_tp_certissue_output;
4137
4138#[cfg(feature = "cssmconfig")]
4140pub type CSSM_TP_CERTCHANGE_ACTION = uint32;
4141
4142pub const CSSM_TP_CERTCHANGE_NONE: c_uint = 0;
4144pub const CSSM_TP_CERTCHANGE_REVOKE: c_uint = 1;
4146pub const CSSM_TP_CERTCHANGE_HOLD: c_uint = 2;
4148pub const CSSM_TP_CERTCHANGE_RELEASE: c_uint = 3;
4150
4151#[cfg(feature = "cssmconfig")]
4153pub type CSSM_TP_CERTCHANGE_REASON = uint32;
4154
4155pub const CSSM_TP_CERTCHANGE_REASON_UNKNOWN: c_uint = 0;
4157pub const CSSM_TP_CERTCHANGE_REASON_KEYCOMPROMISE: c_uint = 1;
4159pub const CSSM_TP_CERTCHANGE_REASON_CACOMPROMISE: c_uint = 2;
4161pub const CSSM_TP_CERTCHANGE_REASON_CEASEOPERATION: c_uint = 3;
4163pub const CSSM_TP_CERTCHANGE_REASON_AFFILIATIONCHANGE: c_uint = 4;
4165pub const CSSM_TP_CERTCHANGE_REASON_SUPERCEDED: c_uint = 5;
4167pub const CSSM_TP_CERTCHANGE_REASON_SUSPECTEDCOMPROMISE: c_uint = 6;
4169pub const CSSM_TP_CERTCHANGE_REASON_HOLDRELEASE: c_uint = 7;
4171
4172#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4174#[deprecated]
4175#[repr(C)]
4176#[derive(Clone, Copy, Debug, PartialEq)]
4177pub struct cssm_tp_certchange_input {
4178 pub Action: CSSM_TP_CERTCHANGE_ACTION,
4179 pub Reason: CSSM_TP_CERTCHANGE_REASON,
4180 pub CLHandle: CSSM_CL_HANDLE,
4181 pub Cert: CSSM_DATA_PTR,
4182 pub ChangeInfo: CSSM_FIELD_PTR,
4183 pub StartTime: CSSM_TIMESTRING,
4184 pub CallerCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4185}
4186
4187#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4188unsafe impl Encode for cssm_tp_certchange_input {
4189 const ENCODING: Encoding = Encoding::Struct(
4190 "cssm_tp_certchange_input",
4191 &[
4192 <CSSM_TP_CERTCHANGE_ACTION>::ENCODING,
4193 <CSSM_TP_CERTCHANGE_REASON>::ENCODING,
4194 <CSSM_CL_HANDLE>::ENCODING,
4195 <CSSM_DATA_PTR>::ENCODING,
4196 <CSSM_FIELD_PTR>::ENCODING,
4197 <CSSM_TIMESTRING>::ENCODING,
4198 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4199 ],
4200 );
4201}
4202
4203#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4204unsafe impl RefEncode for cssm_tp_certchange_input {
4205 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4206}
4207
4208#[deprecated]
4210#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4211pub type CSSM_TP_CERTCHANGE_INPUT = cssm_tp_certchange_input;
4212
4213#[deprecated]
4215#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4216pub type CSSM_TP_CERTCHANGE_INPUT_PTR = *mut cssm_tp_certchange_input;
4217
4218#[cfg(feature = "cssmconfig")]
4220pub type CSSM_TP_CERTCHANGE_STATUS = uint32;
4221
4222pub const CSSM_TP_CERTCHANGE_STATUS_UNKNOWN: c_uint = 0;
4224pub const CSSM_TP_CERTCHANGE_OK: c_uint = 1;
4226pub const CSSM_TP_CERTCHANGE_OKWITHNEWTIME: c_uint = 2;
4228pub const CSSM_TP_CERTCHANGE_WRONGCA: c_uint = 3;
4230pub const CSSM_TP_CERTCHANGE_REJECTED: c_uint = 4;
4232pub const CSSM_TP_CERTCHANGE_NOT_AUTHORIZED: c_uint = 5;
4234
4235#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4237#[deprecated]
4238#[repr(C)]
4239#[derive(Clone, Copy, Debug, PartialEq)]
4240pub struct cssm_tp_certchange_output {
4241 pub ActionStatus: CSSM_TP_CERTCHANGE_STATUS,
4242 pub RevokeInfo: CSSM_FIELD,
4243}
4244
4245#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4246unsafe impl Encode for cssm_tp_certchange_output {
4247 const ENCODING: Encoding = Encoding::Struct(
4248 "cssm_tp_certchange_output",
4249 &[
4250 <CSSM_TP_CERTCHANGE_STATUS>::ENCODING,
4251 <CSSM_FIELD>::ENCODING,
4252 ],
4253 );
4254}
4255
4256#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4257unsafe impl RefEncode for cssm_tp_certchange_output {
4258 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4259}
4260
4261#[deprecated]
4263#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4264pub type CSSM_TP_CERTCHANGE_OUTPUT = cssm_tp_certchange_output;
4265
4266#[deprecated]
4268#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4269pub type CSSM_TP_CERTCHANGE_OUTPUT_PTR = *mut cssm_tp_certchange_output;
4270
4271#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4273#[deprecated]
4274#[repr(C)]
4275#[derive(Clone, Copy, Debug, PartialEq)]
4276pub struct cssm_tp_certverify_input {
4277 pub CLHandle: CSSM_CL_HANDLE,
4278 pub Cert: CSSM_DATA_PTR,
4279 pub VerifyContext: CSSM_TP_VERIFY_CONTEXT_PTR,
4280}
4281
4282#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4283unsafe impl Encode for cssm_tp_certverify_input {
4284 const ENCODING: Encoding = Encoding::Struct(
4285 "cssm_tp_certverify_input",
4286 &[
4287 <CSSM_CL_HANDLE>::ENCODING,
4288 <CSSM_DATA_PTR>::ENCODING,
4289 <CSSM_TP_VERIFY_CONTEXT_PTR>::ENCODING,
4290 ],
4291 );
4292}
4293
4294#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4295unsafe impl RefEncode for cssm_tp_certverify_input {
4296 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4297}
4298
4299#[deprecated]
4301#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4302pub type CSSM_TP_CERTVERIFY_INPUT = cssm_tp_certverify_input;
4303
4304#[deprecated]
4306#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4307pub type CSSM_TP_CERTVERIFY_INPUT_PTR = *mut cssm_tp_certverify_input;
4308
4309#[cfg(feature = "cssmconfig")]
4311pub type CSSM_TP_CERTVERIFY_STATUS = uint32;
4312
4313pub const CSSM_TP_CERTVERIFY_UNKNOWN: c_uint = 0;
4315pub const CSSM_TP_CERTVERIFY_VALID: c_uint = 1;
4317pub const CSSM_TP_CERTVERIFY_INVALID: c_uint = 2;
4319pub const CSSM_TP_CERTVERIFY_REVOKED: c_uint = 3;
4321pub const CSSM_TP_CERTVERIFY_SUSPENDED: c_uint = 4;
4323pub const CSSM_TP_CERTVERIFY_EXPIRED: c_uint = 5;
4325pub const CSSM_TP_CERTVERIFY_NOT_VALID_YET: c_uint = 6;
4327pub const CSSM_TP_CERTVERIFY_INVALID_AUTHORITY: c_uint = 7;
4329pub const CSSM_TP_CERTVERIFY_INVALID_SIGNATURE: c_uint = 8;
4331pub const CSSM_TP_CERTVERIFY_INVALID_CERT_VALUE: c_uint = 9;
4333pub const CSSM_TP_CERTVERIFY_INVALID_CERTGROUP: c_uint = 10;
4335pub const CSSM_TP_CERTVERIFY_INVALID_POLICY: c_uint = 11;
4337pub const CSSM_TP_CERTVERIFY_INVALID_POLICY_IDS: c_uint = 12;
4339pub const CSSM_TP_CERTVERIFY_INVALID_BASIC_CONSTRAINTS: c_uint = 13;
4341pub const CSSM_TP_CERTVERIFY_INVALID_CRL_DIST_PT: c_uint = 14;
4343pub const CSSM_TP_CERTVERIFY_INVALID_NAME_TREE: c_uint = 15;
4345pub const CSSM_TP_CERTVERIFY_UNKNOWN_CRITICAL_EXT: c_uint = 16;
4347
4348#[cfg(feature = "cssmconfig")]
4350#[deprecated]
4351#[repr(C)]
4352#[derive(Clone, Copy, Debug, PartialEq)]
4353pub struct cssm_tp_certverify_output {
4354 pub VerifyStatus: CSSM_TP_CERTVERIFY_STATUS,
4355 pub NumberOfEvidence: uint32,
4356 pub Evidence: CSSM_EVIDENCE_PTR,
4357}
4358
4359#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4360unsafe impl Encode for cssm_tp_certverify_output {
4361 const ENCODING: Encoding = Encoding::Struct(
4362 "cssm_tp_certverify_output",
4363 &[
4364 <CSSM_TP_CERTVERIFY_STATUS>::ENCODING,
4365 <uint32>::ENCODING,
4366 <CSSM_EVIDENCE_PTR>::ENCODING,
4367 ],
4368 );
4369}
4370
4371#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4372unsafe impl RefEncode for cssm_tp_certverify_output {
4373 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4374}
4375
4376#[deprecated]
4378#[cfg(feature = "cssmconfig")]
4379pub type CSSM_TP_CERTVERIFY_OUTPUT = cssm_tp_certverify_output;
4380
4381#[deprecated]
4383#[cfg(feature = "cssmconfig")]
4384pub type CSSM_TP_CERTVERIFY_OUTPUT_PTR = *mut cssm_tp_certverify_output;
4385
4386#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4388#[deprecated]
4389#[repr(C)]
4390#[derive(Clone, Copy, Debug, PartialEq)]
4391pub struct cssm_tp_certnotarize_input {
4392 pub CLHandle: CSSM_CL_HANDLE,
4393 pub NumberOfFields: uint32,
4394 pub MoreFields: CSSM_FIELD_PTR,
4395 pub SignScope: CSSM_FIELD_PTR,
4396 pub ScopeSize: uint32,
4397 pub MoreServiceRequests: CSSM_TP_SERVICES,
4398 pub NumberOfServiceControls: uint32,
4399 pub ServiceControls: CSSM_FIELD_PTR,
4400 pub UserCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4401}
4402
4403#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4404unsafe impl Encode for cssm_tp_certnotarize_input {
4405 const ENCODING: Encoding = Encoding::Struct(
4406 "cssm_tp_certnotarize_input",
4407 &[
4408 <CSSM_CL_HANDLE>::ENCODING,
4409 <uint32>::ENCODING,
4410 <CSSM_FIELD_PTR>::ENCODING,
4411 <CSSM_FIELD_PTR>::ENCODING,
4412 <uint32>::ENCODING,
4413 <CSSM_TP_SERVICES>::ENCODING,
4414 <uint32>::ENCODING,
4415 <CSSM_FIELD_PTR>::ENCODING,
4416 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4417 ],
4418 );
4419}
4420
4421#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4422unsafe impl RefEncode for cssm_tp_certnotarize_input {
4423 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4424}
4425
4426#[deprecated]
4428#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4429pub type CSSM_TP_CERTNOTARIZE_INPUT = cssm_tp_certnotarize_input;
4430
4431#[deprecated]
4433#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4434pub type CSSM_TP_CERTNOTARIZE_INPUT_PTR = *mut cssm_tp_certnotarize_input;
4435
4436#[cfg(feature = "cssmconfig")]
4438pub type CSSM_TP_CERTNOTARIZE_STATUS = uint32;
4439
4440pub const CSSM_TP_CERTNOTARIZE_STATUS_UNKNOWN: c_uint = 0;
4442pub const CSSM_TP_CERTNOTARIZE_OK: c_uint = 1;
4444pub const CSSM_TP_CERTNOTARIZE_OKWITHOUTFIELDS: c_uint = 2;
4446pub const CSSM_TP_CERTNOTARIZE_OKWITHSERVICEMODS: c_uint = 3;
4448pub const CSSM_TP_CERTNOTARIZE_REJECTED: c_uint = 4;
4450pub const CSSM_TP_CERTNOTARIZE_NOT_AUTHORIZED: c_uint = 5;
4452
4453#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4455#[deprecated]
4456#[repr(C)]
4457#[derive(Clone, Copy, Debug, PartialEq)]
4458pub struct cssm_tp_certnotarize_output {
4459 pub NotarizeStatus: CSSM_TP_CERTNOTARIZE_STATUS,
4460 pub NotarizedCertGroup: CSSM_CERTGROUP_PTR,
4461 pub PerformedServiceRequests: CSSM_TP_SERVICES,
4462}
4463
4464#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4465unsafe impl Encode for cssm_tp_certnotarize_output {
4466 const ENCODING: Encoding = Encoding::Struct(
4467 "cssm_tp_certnotarize_output",
4468 &[
4469 <CSSM_TP_CERTNOTARIZE_STATUS>::ENCODING,
4470 <CSSM_CERTGROUP_PTR>::ENCODING,
4471 <CSSM_TP_SERVICES>::ENCODING,
4472 ],
4473 );
4474}
4475
4476#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4477unsafe impl RefEncode for cssm_tp_certnotarize_output {
4478 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4479}
4480
4481#[deprecated]
4483#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4484pub type CSSM_TP_CERTNOTARIZE_OUTPUT = cssm_tp_certnotarize_output;
4485
4486#[deprecated]
4488#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4489pub type CSSM_TP_CERTNOTARIZE_OUTPUT_PTR = *mut cssm_tp_certnotarize_output;
4490
4491#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4493#[deprecated]
4494#[repr(C)]
4495#[derive(Clone, Copy, Debug, PartialEq)]
4496pub struct cssm_tp_certreclaim_input {
4497 pub CLHandle: CSSM_CL_HANDLE,
4498 pub NumberOfSelectionFields: uint32,
4499 pub SelectionFields: CSSM_FIELD_PTR,
4500 pub UserCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4501}
4502
4503#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4504unsafe impl Encode for cssm_tp_certreclaim_input {
4505 const ENCODING: Encoding = Encoding::Struct(
4506 "cssm_tp_certreclaim_input",
4507 &[
4508 <CSSM_CL_HANDLE>::ENCODING,
4509 <uint32>::ENCODING,
4510 <CSSM_FIELD_PTR>::ENCODING,
4511 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4512 ],
4513 );
4514}
4515
4516#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4517unsafe impl RefEncode for cssm_tp_certreclaim_input {
4518 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4519}
4520
4521#[deprecated]
4523#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4524pub type CSSM_TP_CERTRECLAIM_INPUT = cssm_tp_certreclaim_input;
4525
4526#[deprecated]
4528#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4529pub type CSSM_TP_CERTRECLAIM_INPUT_PTR = *mut cssm_tp_certreclaim_input;
4530
4531#[cfg(feature = "cssmconfig")]
4533pub type CSSM_TP_CERTRECLAIM_STATUS = uint32;
4534
4535pub const CSSM_TP_CERTRECLAIM_STATUS_UNKNOWN: c_uint = 0;
4537pub const CSSM_TP_CERTRECLAIM_OK: c_uint = 1;
4539pub const CSSM_TP_CERTRECLAIM_NOMATCH: c_uint = 2;
4541pub const CSSM_TP_CERTRECLAIM_REJECTED: c_uint = 3;
4543pub const CSSM_TP_CERTRECLAIM_NOT_AUTHORIZED: c_uint = 4;
4545
4546#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4548#[deprecated]
4549#[repr(C)]
4550#[derive(Clone, Copy, Debug, PartialEq)]
4551pub struct cssm_tp_certreclaim_output {
4552 pub ReclaimStatus: CSSM_TP_CERTRECLAIM_STATUS,
4553 pub ReclaimedCertGroup: CSSM_CERTGROUP_PTR,
4554 pub KeyCacheHandle: CSSM_LONG_HANDLE,
4555}
4556
4557#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4558unsafe impl Encode for cssm_tp_certreclaim_output {
4559 const ENCODING: Encoding = Encoding::Struct(
4560 "cssm_tp_certreclaim_output",
4561 &[
4562 <CSSM_TP_CERTRECLAIM_STATUS>::ENCODING,
4563 <CSSM_CERTGROUP_PTR>::ENCODING,
4564 <CSSM_LONG_HANDLE>::ENCODING,
4565 ],
4566 );
4567}
4568
4569#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4570unsafe impl RefEncode for cssm_tp_certreclaim_output {
4571 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4572}
4573
4574#[deprecated]
4576#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4577pub type CSSM_TP_CERTRECLAIM_OUTPUT = cssm_tp_certreclaim_output;
4578
4579#[deprecated]
4581#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4582pub type CSSM_TP_CERTRECLAIM_OUTPUT_PTR = *mut cssm_tp_certreclaim_output;
4583
4584#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4586#[deprecated]
4587#[repr(C)]
4588#[derive(Clone, Copy, Debug, PartialEq)]
4589pub struct cssm_tp_crlissue_input {
4590 pub CLHandle: CSSM_CL_HANDLE,
4591 pub CrlIdentifier: uint32,
4592 pub CrlThisTime: CSSM_TIMESTRING,
4593 pub PolicyIdentifier: CSSM_FIELD_PTR,
4594 pub CallerCredentials: CSSM_ACCESS_CREDENTIALS_PTR,
4595}
4596
4597#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4598unsafe impl Encode for cssm_tp_crlissue_input {
4599 const ENCODING: Encoding = Encoding::Struct(
4600 "cssm_tp_crlissue_input",
4601 &[
4602 <CSSM_CL_HANDLE>::ENCODING,
4603 <uint32>::ENCODING,
4604 <CSSM_TIMESTRING>::ENCODING,
4605 <CSSM_FIELD_PTR>::ENCODING,
4606 <CSSM_ACCESS_CREDENTIALS_PTR>::ENCODING,
4607 ],
4608 );
4609}
4610
4611#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4612unsafe impl RefEncode for cssm_tp_crlissue_input {
4613 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4614}
4615
4616#[deprecated]
4618#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4619pub type CSSM_TP_CRLISSUE_INPUT = cssm_tp_crlissue_input;
4620
4621#[deprecated]
4623#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4624pub type CSSM_TP_CRLISSUE_INPUT_PTR = *mut cssm_tp_crlissue_input;
4625
4626#[cfg(feature = "cssmconfig")]
4628pub type CSSM_TP_CRLISSUE_STATUS = uint32;
4629
4630pub const CSSM_TP_CRLISSUE_STATUS_UNKNOWN: c_uint = 0;
4632pub const CSSM_TP_CRLISSUE_OK: c_uint = 1;
4634pub const CSSM_TP_CRLISSUE_NOT_CURRENT: c_uint = 2;
4636pub const CSSM_TP_CRLISSUE_INVALID_DOMAIN: c_uint = 3;
4638pub const CSSM_TP_CRLISSUE_UNKNOWN_IDENTIFIER: c_uint = 4;
4640pub const CSSM_TP_CRLISSUE_REJECTED: c_uint = 5;
4642pub const CSSM_TP_CRLISSUE_NOT_AUTHORIZED: c_uint = 6;
4644
4645#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4647#[deprecated]
4648#[repr(C)]
4649#[derive(Clone, Copy, Debug, PartialEq)]
4650pub struct cssm_tp_crlissue_output {
4651 pub IssueStatus: CSSM_TP_CRLISSUE_STATUS,
4652 pub Crl: CSSM_ENCODED_CRL_PTR,
4653 pub CrlNextTime: CSSM_TIMESTRING,
4654}
4655
4656#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4657unsafe impl Encode for cssm_tp_crlissue_output {
4658 const ENCODING: Encoding = Encoding::Struct(
4659 "cssm_tp_crlissue_output",
4660 &[
4661 <CSSM_TP_CRLISSUE_STATUS>::ENCODING,
4662 <CSSM_ENCODED_CRL_PTR>::ENCODING,
4663 <CSSM_TIMESTRING>::ENCODING,
4664 ],
4665 );
4666}
4667
4668#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4669unsafe impl RefEncode for cssm_tp_crlissue_output {
4670 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4671}
4672
4673#[deprecated]
4675#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4676pub type CSSM_TP_CRLISSUE_OUTPUT = cssm_tp_crlissue_output;
4677
4678#[deprecated]
4680#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4681pub type CSSM_TP_CRLISSUE_OUTPUT_PTR = *mut cssm_tp_crlissue_output;
4682
4683#[cfg(feature = "cssmconfig")]
4685pub type CSSM_TP_FORM_TYPE = uint32;
4686
4687pub const CSSM_TP_FORM_TYPE_GENERIC: c_uint = 0;
4689pub const CSSM_TP_FORM_TYPE_REGISTRATION: c_uint = 1;
4691
4692#[cfg(feature = "cssmconfig")]
4694pub type CSSM_CL_TEMPLATE_TYPE = uint32;
4695
4696pub const CSSM_CL_TEMPLATE_INTERMEDIATE_CERT: c_uint = 1;
4698pub const CSSM_CL_TEMPLATE_PKIX_CERTTEMPLATE: c_uint = 2;
4700
4701#[cfg(feature = "cssmconfig")]
4703pub type CSSM_CERT_BUNDLE_TYPE = uint32;
4704
4705pub const CSSM_CERT_BUNDLE_UNKNOWN: c_uint = 0;
4707pub const CSSM_CERT_BUNDLE_CUSTOM: c_uint = 1;
4709pub const CSSM_CERT_BUNDLE_PKCS7_SIGNED_DATA: c_uint = 2;
4711pub const CSSM_CERT_BUNDLE_PKCS7_SIGNED_ENVELOPED_DATA: c_uint = 3;
4713pub const CSSM_CERT_BUNDLE_PKCS12: c_uint = 4;
4715pub const CSSM_CERT_BUNDLE_PFX: c_uint = 5;
4717pub const CSSM_CERT_BUNDLE_SPKI_SEQUENCE: c_uint = 6;
4719pub const CSSM_CERT_BUNDLE_PGP_KEYRING: c_uint = 7;
4721pub const CSSM_CERT_BUNDLE_LAST: c_uint = 32767;
4723pub const CSSM_CL_CUSTOM_CERT_BUNDLE_TYPE: c_uint = 32768;
4725
4726#[cfg(feature = "cssmconfig")]
4728pub type CSSM_CERT_BUNDLE_ENCODING = uint32;
4729
4730pub const CSSM_CERT_BUNDLE_ENCODING_UNKNOWN: c_uint = 0;
4732pub const CSSM_CERT_BUNDLE_ENCODING_CUSTOM: c_uint = 1;
4734pub const CSSM_CERT_BUNDLE_ENCODING_BER: c_uint = 2;
4736pub const CSSM_CERT_BUNDLE_ENCODING_DER: c_uint = 3;
4738pub const CSSM_CERT_BUNDLE_ENCODING_SEXPR: c_uint = 4;
4740pub const CSSM_CERT_BUNDLE_ENCODING_PGP: c_uint = 5;
4742
4743#[cfg(feature = "cssmconfig")]
4745#[deprecated]
4746#[repr(C)]
4747#[derive(Clone, Copy, Debug, PartialEq)]
4748pub struct cssm_cert_bundle_header {
4749 pub BundleType: CSSM_CERT_BUNDLE_TYPE,
4750 pub BundleEncoding: CSSM_CERT_BUNDLE_ENCODING,
4751}
4752
4753#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4754unsafe impl Encode for cssm_cert_bundle_header {
4755 const ENCODING: Encoding = Encoding::Struct(
4756 "cssm_cert_bundle_header",
4757 &[
4758 <CSSM_CERT_BUNDLE_TYPE>::ENCODING,
4759 <CSSM_CERT_BUNDLE_ENCODING>::ENCODING,
4760 ],
4761 );
4762}
4763
4764#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
4765unsafe impl RefEncode for cssm_cert_bundle_header {
4766 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4767}
4768
4769#[deprecated]
4771#[cfg(feature = "cssmconfig")]
4772pub type CSSM_CERT_BUNDLE_HEADER = cssm_cert_bundle_header;
4773
4774#[deprecated]
4776#[cfg(feature = "cssmconfig")]
4777pub type CSSM_CERT_BUNDLE_HEADER_PTR = *mut cssm_cert_bundle_header;
4778
4779#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4781#[deprecated]
4782#[repr(C)]
4783#[derive(Clone, Copy, Debug, PartialEq)]
4784pub struct cssm_cert_bundle {
4785 pub BundleHeader: CSSM_CERT_BUNDLE_HEADER,
4786 pub Bundle: SecAsn1Item,
4787}
4788
4789#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4790unsafe impl Encode for cssm_cert_bundle {
4791 const ENCODING: Encoding = Encoding::Struct(
4792 "cssm_cert_bundle",
4793 &[<CSSM_CERT_BUNDLE_HEADER>::ENCODING, <SecAsn1Item>::ENCODING],
4794 );
4795}
4796
4797#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4798unsafe impl RefEncode for cssm_cert_bundle {
4799 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4800}
4801
4802#[deprecated]
4804#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4805pub type CSSM_CERT_BUNDLE = cssm_cert_bundle;
4806
4807#[deprecated]
4809#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4810pub type CSSM_CERT_BUNDLE_PTR = *mut cssm_cert_bundle;
4811
4812pub const CSSM_FIELDVALUE_COMPLEX_DATA_TYPE: c_uint = 4294967295;
4814
4815#[cfg(feature = "cssmconfig")]
4817pub type CSSM_DB_ATTRIBUTE_NAME_FORMAT = uint32;
4818
4819#[cfg(feature = "cssmconfig")]
4821pub type CSSM_DB_ATTRIBUTE_NAME_FORMAT_PTR = *mut uint32;
4822
4823pub const CSSM_DB_ATTRIBUTE_NAME_AS_STRING: c_uint = 0;
4825pub const CSSM_DB_ATTRIBUTE_NAME_AS_OID: c_uint = 1;
4827pub const CSSM_DB_ATTRIBUTE_NAME_AS_INTEGER: c_uint = 2;
4829
4830#[cfg(feature = "cssmconfig")]
4832pub type CSSM_DB_ATTRIBUTE_FORMAT = uint32;
4833
4834#[cfg(feature = "cssmconfig")]
4836pub type CSSM_DB_ATTRIBUTE_FORMAT_PTR = *mut uint32;
4837
4838pub const CSSM_DB_ATTRIBUTE_FORMAT_STRING: c_uint = 0;
4840pub const CSSM_DB_ATTRIBUTE_FORMAT_SINT32: c_uint = 1;
4842pub const CSSM_DB_ATTRIBUTE_FORMAT_UINT32: c_uint = 2;
4844pub const CSSM_DB_ATTRIBUTE_FORMAT_BIG_NUM: c_uint = 3;
4846pub const CSSM_DB_ATTRIBUTE_FORMAT_REAL: c_uint = 4;
4848pub const CSSM_DB_ATTRIBUTE_FORMAT_TIME_DATE: c_uint = 5;
4850pub const CSSM_DB_ATTRIBUTE_FORMAT_BLOB: c_uint = 6;
4852pub const CSSM_DB_ATTRIBUTE_FORMAT_MULTI_UINT32: c_uint = 7;
4854pub const CSSM_DB_ATTRIBUTE_FORMAT_COMPLEX: c_uint = 8;
4856
4857#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4859#[deprecated]
4860#[repr(C)]
4861#[derive(Clone, Copy)]
4862pub union cssm_db_attribute_label {
4863 pub AttributeName: *mut c_char,
4864 pub AttributeOID: SecAsn1Oid,
4865 pub AttributeID: uint32,
4866}
4867
4868#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4869unsafe impl Encode for cssm_db_attribute_label {
4870 const ENCODING: Encoding = Encoding::Union(
4871 "cssm_db_attribute_label",
4872 &[
4873 <*mut c_char>::ENCODING,
4874 <SecAsn1Oid>::ENCODING,
4875 <uint32>::ENCODING,
4876 ],
4877 );
4878}
4879
4880#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4881unsafe impl RefEncode for cssm_db_attribute_label {
4882 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4883}
4884
4885#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4887#[deprecated]
4888#[repr(C)]
4889#[derive(Clone, Copy)]
4890pub struct cssm_db_attribute_info {
4891 pub AttributeNameFormat: CSSM_DB_ATTRIBUTE_NAME_FORMAT,
4892 pub Label: cssm_db_attribute_label,
4893 pub AttributeFormat: CSSM_DB_ATTRIBUTE_FORMAT,
4894}
4895
4896#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4897unsafe impl Encode for cssm_db_attribute_info {
4898 const ENCODING: Encoding = Encoding::Struct(
4899 "cssm_db_attribute_info",
4900 &[
4901 <CSSM_DB_ATTRIBUTE_NAME_FORMAT>::ENCODING,
4902 <cssm_db_attribute_label>::ENCODING,
4903 <CSSM_DB_ATTRIBUTE_FORMAT>::ENCODING,
4904 ],
4905 );
4906}
4907
4908#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4909unsafe impl RefEncode for cssm_db_attribute_info {
4910 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4911}
4912
4913#[deprecated]
4915#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4916pub type CSSM_DB_ATTRIBUTE_INFO = cssm_db_attribute_info;
4917
4918#[deprecated]
4920#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4921pub type CSSM_DB_ATTRIBUTE_INFO_PTR = *mut cssm_db_attribute_info;
4922
4923#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4925#[deprecated]
4926#[repr(C)]
4927#[derive(Clone, Copy)]
4928pub struct cssm_db_attribute_data {
4929 pub Info: CSSM_DB_ATTRIBUTE_INFO,
4930 pub NumberOfValues: uint32,
4931 pub Value: CSSM_DATA_PTR,
4932}
4933
4934#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4935unsafe impl Encode for cssm_db_attribute_data {
4936 const ENCODING: Encoding = Encoding::Struct(
4937 "cssm_db_attribute_data",
4938 &[
4939 <CSSM_DB_ATTRIBUTE_INFO>::ENCODING,
4940 <uint32>::ENCODING,
4941 <CSSM_DATA_PTR>::ENCODING,
4942 ],
4943 );
4944}
4945
4946#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
4947unsafe impl RefEncode for cssm_db_attribute_data {
4948 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
4949}
4950
4951#[deprecated]
4953#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4954pub type CSSM_DB_ATTRIBUTE_DATA = cssm_db_attribute_data;
4955
4956#[deprecated]
4958#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
4959pub type CSSM_DB_ATTRIBUTE_DATA_PTR = *mut cssm_db_attribute_data;
4960
4961#[cfg(feature = "cssmconfig")]
4963pub type CSSM_DB_RECORDTYPE = uint32;
4964
4965pub const CSSM_DB_RECORDTYPE_SCHEMA_START: c_uint = 0;
4967pub const CSSM_DB_RECORDTYPE_SCHEMA_END: c_uint = 4;
4969pub const CSSM_DB_RECORDTYPE_OPEN_GROUP_START: c_uint = 10;
4971pub const CSSM_DB_RECORDTYPE_OPEN_GROUP_END: c_uint = 18;
4973pub const CSSM_DB_RECORDTYPE_APP_DEFINED_START: c_uint = 2147483648;
4975pub const CSSM_DB_RECORDTYPE_APP_DEFINED_END: c_uint = 4294967295;
4977pub const CSSM_DL_DB_SCHEMA_INFO: c_uint = 0;
4979pub const CSSM_DL_DB_SCHEMA_INDEXES: c_uint = 1;
4981pub const CSSM_DL_DB_SCHEMA_ATTRIBUTES: c_uint = 2;
4983pub const CSSM_DL_DB_SCHEMA_PARSING_MODULE: c_uint = 3;
4985pub const CSSM_DL_DB_RECORD_ANY: c_uint = 10;
4987pub const CSSM_DL_DB_RECORD_CERT: c_uint = 11;
4989pub const CSSM_DL_DB_RECORD_CRL: c_uint = 12;
4991pub const CSSM_DL_DB_RECORD_POLICY: c_uint = 13;
4993pub const CSSM_DL_DB_RECORD_GENERIC: c_uint = 14;
4995pub const CSSM_DL_DB_RECORD_PUBLIC_KEY: c_uint = 15;
4997pub const CSSM_DL_DB_RECORD_PRIVATE_KEY: c_uint = 16;
4999pub const CSSM_DL_DB_RECORD_SYMMETRIC_KEY: c_uint = 17;
5001pub const CSSM_DL_DB_RECORD_ALL_KEYS: c_uint = 18;
5003
5004pub const CSSM_DB_CERT_USE_TRUSTED: c_uint = 1;
5006pub const CSSM_DB_CERT_USE_SYSTEM: c_uint = 2;
5008pub const CSSM_DB_CERT_USE_OWNER: c_uint = 4;
5010pub const CSSM_DB_CERT_USE_REVOKED: c_uint = 8;
5012pub const CSSM_DB_CERT_USE_SIGNING: c_uint = 16;
5014pub const CSSM_DB_CERT_USE_PRIVACY: c_uint = 32;
5016
5017#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5019#[deprecated]
5020#[repr(C)]
5021#[derive(Clone, Copy, Debug, PartialEq)]
5022pub struct cssm_db_record_attribute_info {
5023 pub DataRecordType: CSSM_DB_RECORDTYPE,
5024 pub NumberOfAttributes: uint32,
5025 pub AttributeInfo: CSSM_DB_ATTRIBUTE_INFO_PTR,
5026}
5027
5028#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5029unsafe impl Encode for cssm_db_record_attribute_info {
5030 const ENCODING: Encoding = Encoding::Struct(
5031 "cssm_db_record_attribute_info",
5032 &[
5033 <CSSM_DB_RECORDTYPE>::ENCODING,
5034 <uint32>::ENCODING,
5035 <CSSM_DB_ATTRIBUTE_INFO_PTR>::ENCODING,
5036 ],
5037 );
5038}
5039
5040#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5041unsafe impl RefEncode for cssm_db_record_attribute_info {
5042 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5043}
5044
5045#[deprecated]
5047#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5048pub type CSSM_DB_RECORD_ATTRIBUTE_INFO = cssm_db_record_attribute_info;
5049
5050#[deprecated]
5052#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5053pub type CSSM_DB_RECORD_ATTRIBUTE_INFO_PTR = *mut cssm_db_record_attribute_info;
5054
5055#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5057#[deprecated]
5058#[repr(C)]
5059#[derive(Clone, Copy, Debug, PartialEq)]
5060pub struct cssm_db_record_attribute_data {
5061 pub DataRecordType: CSSM_DB_RECORDTYPE,
5062 pub SemanticInformation: uint32,
5063 pub NumberOfAttributes: uint32,
5064 pub AttributeData: CSSM_DB_ATTRIBUTE_DATA_PTR,
5065}
5066
5067#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5068unsafe impl Encode for cssm_db_record_attribute_data {
5069 const ENCODING: Encoding = Encoding::Struct(
5070 "cssm_db_record_attribute_data",
5071 &[
5072 <CSSM_DB_RECORDTYPE>::ENCODING,
5073 <uint32>::ENCODING,
5074 <uint32>::ENCODING,
5075 <CSSM_DB_ATTRIBUTE_DATA_PTR>::ENCODING,
5076 ],
5077 );
5078}
5079
5080#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5081unsafe impl RefEncode for cssm_db_record_attribute_data {
5082 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5083}
5084
5085#[deprecated]
5087#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5088pub type CSSM_DB_RECORD_ATTRIBUTE_DATA = cssm_db_record_attribute_data;
5089
5090#[deprecated]
5092#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5093pub type CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR = *mut cssm_db_record_attribute_data;
5094
5095#[cfg(feature = "cssmconfig")]
5097#[deprecated]
5098#[repr(C)]
5099#[derive(Clone, Copy, Debug, PartialEq)]
5100pub struct cssm_db_parsing_module_info {
5101 pub RecordType: CSSM_DB_RECORDTYPE,
5102 pub ModuleSubserviceUid: CSSM_SUBSERVICE_UID,
5103}
5104
5105#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5106unsafe impl Encode for cssm_db_parsing_module_info {
5107 const ENCODING: Encoding = Encoding::Struct(
5108 "cssm_db_parsing_module_info",
5109 &[
5110 <CSSM_DB_RECORDTYPE>::ENCODING,
5111 <CSSM_SUBSERVICE_UID>::ENCODING,
5112 ],
5113 );
5114}
5115
5116#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5117unsafe impl RefEncode for cssm_db_parsing_module_info {
5118 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5119}
5120
5121#[deprecated]
5123#[cfg(feature = "cssmconfig")]
5124pub type CSSM_DB_PARSING_MODULE_INFO = cssm_db_parsing_module_info;
5125
5126#[deprecated]
5128#[cfg(feature = "cssmconfig")]
5129pub type CSSM_DB_PARSING_MODULE_INFO_PTR = *mut cssm_db_parsing_module_info;
5130
5131#[cfg(feature = "cssmconfig")]
5133pub type CSSM_DB_INDEX_TYPE = uint32;
5134
5135pub const CSSM_DB_INDEX_UNIQUE: c_uint = 0;
5137pub const CSSM_DB_INDEX_NONUNIQUE: c_uint = 1;
5139
5140#[cfg(feature = "cssmconfig")]
5142pub type CSSM_DB_INDEXED_DATA_LOCATION = uint32;
5143
5144pub const CSSM_DB_INDEX_ON_UNKNOWN: c_uint = 0;
5146pub const CSSM_DB_INDEX_ON_ATTRIBUTE: c_uint = 1;
5148pub const CSSM_DB_INDEX_ON_RECORD: c_uint = 2;
5150
5151#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5153#[deprecated]
5154#[repr(C)]
5155#[derive(Clone, Copy)]
5156pub struct cssm_db_index_info {
5157 pub IndexType: CSSM_DB_INDEX_TYPE,
5158 pub IndexedDataLocation: CSSM_DB_INDEXED_DATA_LOCATION,
5159 pub Info: CSSM_DB_ATTRIBUTE_INFO,
5160}
5161
5162#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5163unsafe impl Encode for cssm_db_index_info {
5164 const ENCODING: Encoding = Encoding::Struct(
5165 "cssm_db_index_info",
5166 &[
5167 <CSSM_DB_INDEX_TYPE>::ENCODING,
5168 <CSSM_DB_INDEXED_DATA_LOCATION>::ENCODING,
5169 <CSSM_DB_ATTRIBUTE_INFO>::ENCODING,
5170 ],
5171 );
5172}
5173
5174#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5175unsafe impl RefEncode for cssm_db_index_info {
5176 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5177}
5178
5179#[deprecated]
5181#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5182pub type CSSM_DB_INDEX_INFO = cssm_db_index_info;
5183
5184#[deprecated]
5186#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5187pub type CSSM_DB_INDEX_INFO_PTR = *mut cssm_db_index_info;
5188
5189#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5191#[deprecated]
5192#[repr(C)]
5193#[derive(Clone, Copy)]
5194pub struct cssm_db_unique_record {
5195 pub RecordLocator: CSSM_DB_INDEX_INFO,
5196 pub RecordIdentifier: SecAsn1Item,
5197}
5198
5199#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5200unsafe impl Encode for cssm_db_unique_record {
5201 const ENCODING: Encoding = Encoding::Struct(
5202 "cssm_db_unique_record",
5203 &[<CSSM_DB_INDEX_INFO>::ENCODING, <SecAsn1Item>::ENCODING],
5204 );
5205}
5206
5207#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5208unsafe impl RefEncode for cssm_db_unique_record {
5209 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5210}
5211
5212#[deprecated]
5214#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5215pub type CSSM_DB_UNIQUE_RECORD = cssm_db_unique_record;
5216
5217#[deprecated]
5219#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5220pub type CSSM_DB_UNIQUE_RECORD_PTR = *mut cssm_db_unique_record;
5221
5222#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5224#[deprecated]
5225#[repr(C)]
5226#[derive(Clone, Copy, Debug, PartialEq)]
5227pub struct cssm_db_record_index_info {
5228 pub DataRecordType: CSSM_DB_RECORDTYPE,
5229 pub NumberOfIndexes: uint32,
5230 pub IndexInfo: CSSM_DB_INDEX_INFO_PTR,
5231}
5232
5233#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5234unsafe impl Encode for cssm_db_record_index_info {
5235 const ENCODING: Encoding = Encoding::Struct(
5236 "cssm_db_record_index_info",
5237 &[
5238 <CSSM_DB_RECORDTYPE>::ENCODING,
5239 <uint32>::ENCODING,
5240 <CSSM_DB_INDEX_INFO_PTR>::ENCODING,
5241 ],
5242 );
5243}
5244
5245#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5246unsafe impl RefEncode for cssm_db_record_index_info {
5247 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5248}
5249
5250#[deprecated]
5252#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5253pub type CSSM_DB_RECORD_INDEX_INFO = cssm_db_record_index_info;
5254
5255#[deprecated]
5257#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5258pub type CSSM_DB_RECORD_INDEX_INFO_PTR = *mut cssm_db_record_index_info;
5259
5260#[cfg(feature = "cssmconfig")]
5262pub type CSSM_DB_ACCESS_TYPE = uint32;
5263
5264#[cfg(feature = "cssmconfig")]
5266pub type CSSM_DB_ACCESS_TYPE_PTR = *mut uint32;
5267
5268pub const CSSM_DB_ACCESS_READ: c_uint = 1;
5270pub const CSSM_DB_ACCESS_WRITE: c_uint = 2;
5272pub const CSSM_DB_ACCESS_PRIVILEGED: c_uint = 4;
5274
5275#[cfg(feature = "cssmconfig")]
5277pub type CSSM_DB_MODIFY_MODE = uint32;
5278
5279pub const CSSM_DB_MODIFY_ATTRIBUTE_NONE: c_uint = 0;
5281pub const CSSM_DB_MODIFY_ATTRIBUTE_ADD: c_uint = 1;
5283pub const CSSM_DB_MODIFY_ATTRIBUTE_DELETE: c_uint = 2;
5285pub const CSSM_DB_MODIFY_ATTRIBUTE_REPLACE: c_uint = 3;
5287
5288#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5290#[deprecated]
5291#[repr(C)]
5292#[derive(Clone, Copy, Debug, PartialEq)]
5293pub struct cssm_dbinfo {
5294 pub NumberOfRecordTypes: uint32,
5295 pub DefaultParsingModules: CSSM_DB_PARSING_MODULE_INFO_PTR,
5296 pub RecordAttributeNames: CSSM_DB_RECORD_ATTRIBUTE_INFO_PTR,
5297 pub RecordIndexes: CSSM_DB_RECORD_INDEX_INFO_PTR,
5298 pub IsLocal: CSSM_BOOL,
5299 pub AccessPath: *mut c_char,
5300 pub Reserved: *mut c_void,
5301}
5302
5303#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5304unsafe impl Encode for cssm_dbinfo {
5305 const ENCODING: Encoding = Encoding::Struct(
5306 "cssm_dbinfo",
5307 &[
5308 <uint32>::ENCODING,
5309 <CSSM_DB_PARSING_MODULE_INFO_PTR>::ENCODING,
5310 <CSSM_DB_RECORD_ATTRIBUTE_INFO_PTR>::ENCODING,
5311 <CSSM_DB_RECORD_INDEX_INFO_PTR>::ENCODING,
5312 <CSSM_BOOL>::ENCODING,
5313 <*mut c_char>::ENCODING,
5314 <*mut c_void>::ENCODING,
5315 ],
5316 );
5317}
5318
5319#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5320unsafe impl RefEncode for cssm_dbinfo {
5321 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5322}
5323
5324#[deprecated]
5326#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5327pub type CSSM_DBINFO = cssm_dbinfo;
5328
5329#[deprecated]
5331#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5332pub type CSSM_DBINFO_PTR = *mut cssm_dbinfo;
5333
5334#[cfg(feature = "cssmconfig")]
5336pub type CSSM_DB_OPERATOR = uint32;
5337
5338#[cfg(feature = "cssmconfig")]
5340pub type CSSM_DB_OPERATOR_PTR = *mut uint32;
5341
5342pub const CSSM_DB_EQUAL: c_uint = 0;
5344pub const CSSM_DB_NOT_EQUAL: c_uint = 1;
5346pub const CSSM_DB_LESS_THAN: c_uint = 2;
5348pub const CSSM_DB_GREATER_THAN: c_uint = 3;
5350pub const CSSM_DB_CONTAINS: c_uint = 4;
5352pub const CSSM_DB_CONTAINS_INITIAL_SUBSTRING: c_uint = 5;
5354pub const CSSM_DB_CONTAINS_FINAL_SUBSTRING: c_uint = 6;
5356
5357#[cfg(feature = "cssmconfig")]
5359pub type CSSM_DB_CONJUNCTIVE = uint32;
5360
5361#[cfg(feature = "cssmconfig")]
5363pub type CSSM_DB_CONJUNCTIVE_PTR = *mut uint32;
5364
5365pub const CSSM_DB_NONE: c_uint = 0;
5367pub const CSSM_DB_AND: c_uint = 1;
5369pub const CSSM_DB_OR: c_uint = 2;
5371
5372#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5374#[deprecated]
5375#[repr(C)]
5376#[derive(Clone, Copy)]
5377pub struct cssm_selection_predicate {
5378 pub DbOperator: CSSM_DB_OPERATOR,
5379 pub Attribute: CSSM_DB_ATTRIBUTE_DATA,
5380}
5381
5382#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5383unsafe impl Encode for cssm_selection_predicate {
5384 const ENCODING: Encoding = Encoding::Struct(
5385 "cssm_selection_predicate",
5386 &[
5387 <CSSM_DB_OPERATOR>::ENCODING,
5388 <CSSM_DB_ATTRIBUTE_DATA>::ENCODING,
5389 ],
5390 );
5391}
5392
5393#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5394unsafe impl RefEncode for cssm_selection_predicate {
5395 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5396}
5397
5398#[deprecated]
5400#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5401pub type CSSM_SELECTION_PREDICATE = cssm_selection_predicate;
5402
5403#[deprecated]
5405#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5406pub type CSSM_SELECTION_PREDICATE_PTR = *mut cssm_selection_predicate;
5407
5408pub const CSSM_QUERY_TIMELIMIT_NONE: c_uint = 0;
5410
5411pub const CSSM_QUERY_SIZELIMIT_NONE: c_uint = 0;
5413
5414#[cfg(feature = "cssmconfig")]
5416#[deprecated]
5417#[repr(C)]
5418#[derive(Clone, Copy, Debug, PartialEq)]
5419pub struct cssm_query_limits {
5420 pub TimeLimit: uint32,
5421 pub SizeLimit: uint32,
5422}
5423
5424#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5425unsafe impl Encode for cssm_query_limits {
5426 const ENCODING: Encoding = Encoding::Struct(
5427 "cssm_query_limits",
5428 &[<uint32>::ENCODING, <uint32>::ENCODING],
5429 );
5430}
5431
5432#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5433unsafe impl RefEncode for cssm_query_limits {
5434 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5435}
5436
5437#[deprecated]
5439#[cfg(feature = "cssmconfig")]
5440pub type CSSM_QUERY_LIMITS = cssm_query_limits;
5441
5442#[deprecated]
5444#[cfg(feature = "cssmconfig")]
5445pub type CSSM_QUERY_LIMITS_PTR = *mut cssm_query_limits;
5446
5447#[cfg(feature = "cssmconfig")]
5449pub type CSSM_QUERY_FLAGS = uint32;
5450
5451pub const CSSM_QUERY_RETURN_DATA: c_uint = 1;
5453
5454#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5456#[deprecated]
5457#[repr(C)]
5458#[derive(Clone, Copy, Debug, PartialEq)]
5459pub struct cssm_query {
5460 pub RecordType: CSSM_DB_RECORDTYPE,
5461 pub Conjunctive: CSSM_DB_CONJUNCTIVE,
5462 pub NumSelectionPredicates: uint32,
5463 pub SelectionPredicate: CSSM_SELECTION_PREDICATE_PTR,
5464 pub QueryLimits: CSSM_QUERY_LIMITS,
5465 pub QueryFlags: CSSM_QUERY_FLAGS,
5466}
5467
5468#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5469unsafe impl Encode for cssm_query {
5470 const ENCODING: Encoding = Encoding::Struct(
5471 "cssm_query",
5472 &[
5473 <CSSM_DB_RECORDTYPE>::ENCODING,
5474 <CSSM_DB_CONJUNCTIVE>::ENCODING,
5475 <uint32>::ENCODING,
5476 <CSSM_SELECTION_PREDICATE_PTR>::ENCODING,
5477 <CSSM_QUERY_LIMITS>::ENCODING,
5478 <CSSM_QUERY_FLAGS>::ENCODING,
5479 ],
5480 );
5481}
5482
5483#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5484unsafe impl RefEncode for cssm_query {
5485 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5486}
5487
5488#[deprecated]
5490#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5491pub type CSSM_QUERY = cssm_query;
5492
5493#[deprecated]
5495#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5496pub type CSSM_QUERY_PTR = *mut cssm_query;
5497
5498#[cfg(feature = "cssmconfig")]
5500pub type CSSM_DLTYPE = uint32;
5501
5502#[cfg(feature = "cssmconfig")]
5504pub type CSSM_DLTYPE_PTR = *mut uint32;
5505
5506pub const CSSM_DL_UNKNOWN: c_uint = 0;
5508pub const CSSM_DL_CUSTOM: c_uint = 1;
5510pub const CSSM_DL_LDAP: c_uint = 2;
5512pub const CSSM_DL_ODBC: c_uint = 3;
5514pub const CSSM_DL_PKCS11: c_uint = 4;
5516pub const CSSM_DL_FFS: c_uint = 5;
5518pub const CSSM_DL_MEMORY: c_uint = 6;
5520pub const CSSM_DL_REMOTEDIR: c_uint = 7;
5522
5523pub type CSSM_DL_CUSTOM_ATTRIBUTES = *mut c_void;
5525
5526pub type CSSM_DL_LDAP_ATTRIBUTES = *mut c_void;
5528
5529pub type CSSM_DL_ODBC_ATTRIBUTES = *mut c_void;
5531
5532pub type CSSM_DL_FFS_ATTRIBUTES = *mut c_void;
5534
5535#[cfg(feature = "cssmconfig")]
5537#[repr(C)]
5538#[derive(Clone, Copy, Debug, PartialEq)]
5539pub struct cssm_dl_pkcs11_attributes {
5540 pub DeviceAccessFlags: uint32,
5541}
5542
5543#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5544unsafe impl Encode for cssm_dl_pkcs11_attributes {
5545 const ENCODING: Encoding = Encoding::Struct("cssm_dl_pkcs11_attributes", &[<uint32>::ENCODING]);
5546}
5547
5548#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5549unsafe impl RefEncode for cssm_dl_pkcs11_attributes {
5550 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5551}
5552
5553#[cfg(feature = "cssmconfig")]
5555pub type CSSM_DL_PKCS11_ATTRIBUTE = *mut cssm_dl_pkcs11_attributes;
5556
5557#[cfg(feature = "cssmconfig")]
5559pub type CSSM_DL_PKCS11_ATTRIBUTE_PTR = *mut cssm_dl_pkcs11_attributes;
5560
5561pub const CSSM_DB_DATASTORES_UNKNOWN: c_uint = 4294967295;
5563
5564#[cfg(feature = "cssmconfig")]
5566#[repr(C)]
5567#[derive(Clone, Copy, Debug, PartialEq)]
5568pub struct cssm_name_list {
5569 pub NumStrings: uint32,
5570 pub String: *mut *mut c_char,
5571}
5572
5573#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5574unsafe impl Encode for cssm_name_list {
5575 const ENCODING: Encoding = Encoding::Struct(
5576 "cssm_name_list",
5577 &[<uint32>::ENCODING, <*mut *mut c_char>::ENCODING],
5578 );
5579}
5580
5581#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5582unsafe impl RefEncode for cssm_name_list {
5583 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5584}
5585
5586#[deprecated]
5588#[cfg(feature = "cssmconfig")]
5589pub type CSSM_NAME_LIST = cssm_name_list;
5590
5591#[deprecated]
5593#[cfg(feature = "cssmconfig")]
5594pub type CSSM_NAME_LIST_PTR = *mut cssm_name_list;
5595
5596#[cfg(feature = "cssmconfig")]
5598pub type CSSM_DB_RETRIEVAL_MODES = uint32;
5599
5600pub const CSSM_DB_TRANSACTIONAL_MODE: c_uint = 0;
5602pub const CSSM_DB_FILESYSTEMSCAN_MODE: c_uint = 1;
5604
5605#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5607#[deprecated]
5608#[repr(C)]
5609#[derive(Clone, Copy, Debug, PartialEq)]
5610pub struct cssm_db_schema_attribute_info {
5611 pub AttributeId: uint32,
5612 pub AttributeName: *mut c_char,
5613 pub AttributeNameID: SecAsn1Oid,
5614 pub DataType: CSSM_DB_ATTRIBUTE_FORMAT,
5615}
5616
5617#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5618unsafe impl Encode for cssm_db_schema_attribute_info {
5619 const ENCODING: Encoding = Encoding::Struct(
5620 "cssm_db_schema_attribute_info",
5621 &[
5622 <uint32>::ENCODING,
5623 <*mut c_char>::ENCODING,
5624 <SecAsn1Oid>::ENCODING,
5625 <CSSM_DB_ATTRIBUTE_FORMAT>::ENCODING,
5626 ],
5627 );
5628}
5629
5630#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
5631unsafe impl RefEncode for cssm_db_schema_attribute_info {
5632 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5633}
5634
5635#[deprecated]
5637#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5638pub type CSSM_DB_SCHEMA_ATTRIBUTE_INFO = cssm_db_schema_attribute_info;
5639
5640#[deprecated]
5642#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
5643pub type CSSM_DB_SCHEMA_ATTRIBUTE_INFO_PTR = *mut cssm_db_schema_attribute_info;
5644
5645#[cfg(feature = "cssmconfig")]
5647#[repr(C)]
5648#[derive(Clone, Copy, Debug, PartialEq)]
5649pub struct cssm_db_schema_index_info {
5650 pub AttributeId: uint32,
5651 pub IndexId: uint32,
5652 pub IndexType: CSSM_DB_INDEX_TYPE,
5653 pub IndexedDataLocation: CSSM_DB_INDEXED_DATA_LOCATION,
5654}
5655
5656#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5657unsafe impl Encode for cssm_db_schema_index_info {
5658 const ENCODING: Encoding = Encoding::Struct(
5659 "cssm_db_schema_index_info",
5660 &[
5661 <uint32>::ENCODING,
5662 <uint32>::ENCODING,
5663 <CSSM_DB_INDEX_TYPE>::ENCODING,
5664 <CSSM_DB_INDEXED_DATA_LOCATION>::ENCODING,
5665 ],
5666 );
5667}
5668
5669#[cfg(all(feature = "cssmconfig", feature = "objc2"))]
5670unsafe impl RefEncode for cssm_db_schema_index_info {
5671 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
5672}
5673
5674#[deprecated]
5676#[cfg(feature = "cssmconfig")]
5677pub type CSSM_DB_SCHEMA_INDEX_INFO = cssm_db_schema_index_info;
5678
5679#[deprecated]
5681#[cfg(feature = "cssmconfig")]
5682pub type CSSM_DB_SCHEMA_INDEX_INFO_PTR = *mut cssm_db_schema_index_info;