1use core::ffi::*;
4#[cfg(feature = "objc2")]
5use objc2::__framework_prelude::*;
6
7use crate::*;
8
9#[repr(transparent)]
11#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
12pub struct CE_GeneralNameType(pub c_uint);
13impl CE_GeneralNameType {
14 pub const GNT_OtherName: Self = Self(0);
15 pub const GNT_RFC822Name: Self = Self(1);
16 pub const GNT_DNSName: Self = Self(2);
17 pub const GNT_X400Address: Self = Self(3);
18 pub const GNT_DirectoryName: Self = Self(4);
19 pub const GNT_EdiPartyName: Self = Self(5);
20 pub const GNT_URI: Self = Self(6);
21 pub const GNT_IPAddress: Self = Self(7);
22 pub const GNT_RegisteredID: Self = Self(8);
23}
24
25#[cfg(feature = "objc2")]
26unsafe impl Encode for CE_GeneralNameType {
27 const ENCODING: Encoding = c_uint::ENCODING;
28}
29
30#[cfg(feature = "objc2")]
31unsafe impl RefEncode for CE_GeneralNameType {
32 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
33}
34
35#[cfg(feature = "SecAsn1Types")]
37#[repr(C)]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub struct CE_OtherName {
40 pub typeId: SecAsn1Oid,
41 pub value: SecAsn1Item,
42}
43
44#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
45unsafe impl Encode for CE_OtherName {
46 const ENCODING: Encoding = Encoding::Struct(
47 "__CE_OtherName",
48 &[<SecAsn1Oid>::ENCODING, <SecAsn1Item>::ENCODING],
49 );
50}
51
52#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
53unsafe impl RefEncode for CE_OtherName {
54 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
55}
56
57#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
59#[repr(C)]
60#[derive(Clone, Copy, Debug, PartialEq)]
61pub struct CE_GeneralName {
62 pub nameType: CE_GeneralNameType,
63 pub berEncoded: CSSM_BOOL,
64 pub name: SecAsn1Item,
65}
66
67#[cfg(all(
68 feature = "SecAsn1Types",
69 feature = "cssmconfig",
70 feature = "cssmtype",
71 feature = "objc2"
72))]
73unsafe impl Encode for CE_GeneralName {
74 const ENCODING: Encoding = Encoding::Struct(
75 "__CE_GeneralName",
76 &[
77 <CE_GeneralNameType>::ENCODING,
78 <CSSM_BOOL>::ENCODING,
79 <SecAsn1Item>::ENCODING,
80 ],
81 );
82}
83
84#[cfg(all(
85 feature = "SecAsn1Types",
86 feature = "cssmconfig",
87 feature = "cssmtype",
88 feature = "objc2"
89))]
90unsafe impl RefEncode for CE_GeneralName {
91 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
92}
93
94#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
96#[repr(C)]
97#[derive(Clone, Copy, Debug, PartialEq)]
98pub struct CE_GeneralNames {
99 pub numNames: uint32,
100 pub generalName: *mut CE_GeneralName,
101}
102
103#[cfg(all(
104 feature = "SecAsn1Types",
105 feature = "cssmconfig",
106 feature = "cssmtype",
107 feature = "objc2"
108))]
109unsafe impl Encode for CE_GeneralNames {
110 const ENCODING: Encoding = Encoding::Struct(
111 "__CE_GeneralNames",
112 &[<uint32>::ENCODING, <*mut CE_GeneralName>::ENCODING],
113 );
114}
115
116#[cfg(all(
117 feature = "SecAsn1Types",
118 feature = "cssmconfig",
119 feature = "cssmtype",
120 feature = "objc2"
121))]
122unsafe impl RefEncode for CE_GeneralNames {
123 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
124}
125
126#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
128#[repr(C)]
129#[derive(Clone, Copy, Debug, PartialEq)]
130pub struct CE_AuthorityKeyID {
131 pub keyIdentifierPresent: CSSM_BOOL,
132 pub keyIdentifier: SecAsn1Item,
133 pub generalNamesPresent: CSSM_BOOL,
134 pub generalNames: *mut CE_GeneralNames,
135 pub serialNumberPresent: CSSM_BOOL,
136 pub serialNumber: SecAsn1Item,
137}
138
139#[cfg(all(
140 feature = "SecAsn1Types",
141 feature = "cssmconfig",
142 feature = "cssmtype",
143 feature = "objc2"
144))]
145unsafe impl Encode for CE_AuthorityKeyID {
146 const ENCODING: Encoding = Encoding::Struct(
147 "__CE_AuthorityKeyID",
148 &[
149 <CSSM_BOOL>::ENCODING,
150 <SecAsn1Item>::ENCODING,
151 <CSSM_BOOL>::ENCODING,
152 <*mut CE_GeneralNames>::ENCODING,
153 <CSSM_BOOL>::ENCODING,
154 <SecAsn1Item>::ENCODING,
155 ],
156 );
157}
158
159#[cfg(all(
160 feature = "SecAsn1Types",
161 feature = "cssmconfig",
162 feature = "cssmtype",
163 feature = "objc2"
164))]
165unsafe impl RefEncode for CE_AuthorityKeyID {
166 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
167}
168
169#[deprecated]
171#[cfg(feature = "SecAsn1Types")]
172pub type CE_SubjectKeyID = SecAsn1Item;
173
174#[deprecated]
176#[cfg(feature = "cssmconfig")]
177pub type CE_KeyUsage = uint16;
178
179#[deprecated]
181#[cfg(feature = "cssmconfig")]
182pub type CE_CrlReason = uint32;
183
184#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
186#[repr(C)]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub struct CE_ExtendedKeyUsage {
189 pub numPurposes: uint32,
190 pub purposes: CSSM_OID_PTR,
191}
192
193#[cfg(all(
194 feature = "SecAsn1Types",
195 feature = "cssmconfig",
196 feature = "cssmtype",
197 feature = "objc2"
198))]
199unsafe impl Encode for CE_ExtendedKeyUsage {
200 const ENCODING: Encoding = Encoding::Struct(
201 "__CE_ExtendedKeyUsage",
202 &[<uint32>::ENCODING, <CSSM_OID_PTR>::ENCODING],
203 );
204}
205
206#[cfg(all(
207 feature = "SecAsn1Types",
208 feature = "cssmconfig",
209 feature = "cssmtype",
210 feature = "objc2"
211))]
212unsafe impl RefEncode for CE_ExtendedKeyUsage {
213 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
214}
215
216#[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
218#[repr(C)]
219#[derive(Clone, Copy, Debug, PartialEq)]
220pub struct CE_BasicConstraints {
221 pub cA: CSSM_BOOL,
222 pub pathLenConstraintPresent: CSSM_BOOL,
223 pub pathLenConstraint: uint32,
224}
225
226#[cfg(all(feature = "cssmconfig", feature = "cssmtype", feature = "objc2"))]
227unsafe impl Encode for CE_BasicConstraints {
228 const ENCODING: Encoding = Encoding::Struct(
229 "__CE_BasicConstraints",
230 &[
231 <CSSM_BOOL>::ENCODING,
232 <CSSM_BOOL>::ENCODING,
233 <uint32>::ENCODING,
234 ],
235 );
236}
237
238#[cfg(all(feature = "cssmconfig", feature = "cssmtype", feature = "objc2"))]
239unsafe impl RefEncode for CE_BasicConstraints {
240 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
241}
242
243#[cfg(feature = "SecAsn1Types")]
245#[repr(C)]
246#[derive(Clone, Copy, Debug, PartialEq)]
247pub struct CE_PolicyQualifierInfo {
248 pub policyQualifierId: SecAsn1Oid,
249 pub qualifier: SecAsn1Item,
250}
251
252#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
253unsafe impl Encode for CE_PolicyQualifierInfo {
254 const ENCODING: Encoding = Encoding::Struct(
255 "__CE_PolicyQualifierInfo",
256 &[<SecAsn1Oid>::ENCODING, <SecAsn1Item>::ENCODING],
257 );
258}
259
260#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
261unsafe impl RefEncode for CE_PolicyQualifierInfo {
262 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
263}
264
265#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
267#[repr(C)]
268#[derive(Clone, Copy, Debug, PartialEq)]
269pub struct CE_PolicyInformation {
270 pub certPolicyId: SecAsn1Oid,
271 pub numPolicyQualifiers: uint32,
272 pub policyQualifiers: *mut CE_PolicyQualifierInfo,
273}
274
275#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
276unsafe impl Encode for CE_PolicyInformation {
277 const ENCODING: Encoding = Encoding::Struct(
278 "__CE_PolicyInformation",
279 &[
280 <SecAsn1Oid>::ENCODING,
281 <uint32>::ENCODING,
282 <*mut CE_PolicyQualifierInfo>::ENCODING,
283 ],
284 );
285}
286
287#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
288unsafe impl RefEncode for CE_PolicyInformation {
289 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
290}
291
292#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
294#[repr(C)]
295#[derive(Clone, Copy, Debug, PartialEq)]
296pub struct CE_CertPolicies {
297 pub numPolicies: uint32,
298 pub policies: *mut CE_PolicyInformation,
299}
300
301#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
302unsafe impl Encode for CE_CertPolicies {
303 const ENCODING: Encoding = Encoding::Struct(
304 "__CE_CertPolicies",
305 &[<uint32>::ENCODING, <*mut CE_PolicyInformation>::ENCODING],
306 );
307}
308
309#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
310unsafe impl RefEncode for CE_CertPolicies {
311 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
312}
313
314#[deprecated]
316#[cfg(feature = "cssmconfig")]
317pub type CE_NetscapeCertType = uint16;
318
319#[deprecated]
321#[cfg(feature = "cssmconfig")]
322pub type CE_CrlDistReasonFlags = uint8;
323
324#[repr(transparent)]
326#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
327pub struct CE_CrlDistributionPointNameType(pub c_uint);
328impl CE_CrlDistributionPointNameType {
329 #[doc(alias = "CE_CDNT_FullName")]
330 pub const CDNT_FullName: Self = Self(0);
331 #[doc(alias = "CE_CDNT_NameRelativeToCrlIssuer")]
332 pub const CDNT_NameRelativeToCrlIssuer: Self = Self(1);
333}
334
335#[cfg(feature = "objc2")]
336unsafe impl Encode for CE_CrlDistributionPointNameType {
337 const ENCODING: Encoding = c_uint::ENCODING;
338}
339
340#[cfg(feature = "objc2")]
341unsafe impl RefEncode for CE_CrlDistributionPointNameType {
342 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
343}
344
345#[cfg(all(
347 feature = "SecAsn1Types",
348 feature = "cssmconfig",
349 feature = "cssmtype",
350 feature = "x509defs"
351))]
352#[repr(C)]
353#[derive(Clone, Copy)]
354pub union __CE_DistributionPointName_dpn {
355 pub fullName: *mut CE_GeneralNames,
356 pub rdn: CSSM_X509_RDN_PTR,
357}
358
359#[cfg(all(
360 feature = "SecAsn1Types",
361 feature = "cssmconfig",
362 feature = "cssmtype",
363 feature = "objc2",
364 feature = "x509defs"
365))]
366unsafe impl Encode for __CE_DistributionPointName_dpn {
367 const ENCODING: Encoding = Encoding::Union(
368 "?",
369 &[
370 <*mut CE_GeneralNames>::ENCODING,
371 <CSSM_X509_RDN_PTR>::ENCODING,
372 ],
373 );
374}
375
376#[cfg(all(
377 feature = "SecAsn1Types",
378 feature = "cssmconfig",
379 feature = "cssmtype",
380 feature = "objc2",
381 feature = "x509defs"
382))]
383unsafe impl RefEncode for __CE_DistributionPointName_dpn {
384 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
385}
386
387#[cfg(all(
389 feature = "SecAsn1Types",
390 feature = "cssmconfig",
391 feature = "cssmtype",
392 feature = "x509defs"
393))]
394#[repr(C)]
395#[derive(Clone, Copy)]
396pub struct CE_DistributionPointName {
397 pub nameType: CE_CrlDistributionPointNameType,
398 pub dpn: __CE_DistributionPointName_dpn,
399}
400
401#[cfg(all(
402 feature = "SecAsn1Types",
403 feature = "cssmconfig",
404 feature = "cssmtype",
405 feature = "objc2",
406 feature = "x509defs"
407))]
408unsafe impl Encode for CE_DistributionPointName {
409 const ENCODING: Encoding = Encoding::Struct(
410 "__CE_DistributionPointName",
411 &[
412 <CE_CrlDistributionPointNameType>::ENCODING,
413 <__CE_DistributionPointName_dpn>::ENCODING,
414 ],
415 );
416}
417
418#[cfg(all(
419 feature = "SecAsn1Types",
420 feature = "cssmconfig",
421 feature = "cssmtype",
422 feature = "objc2",
423 feature = "x509defs"
424))]
425unsafe impl RefEncode for CE_DistributionPointName {
426 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
427}
428
429#[cfg(all(
431 feature = "SecAsn1Types",
432 feature = "cssmconfig",
433 feature = "cssmtype",
434 feature = "x509defs"
435))]
436#[repr(C)]
437#[derive(Clone, Copy, Debug, PartialEq)]
438pub struct CE_CRLDistributionPoint {
439 pub distPointName: *mut CE_DistributionPointName,
440 pub reasonsPresent: CSSM_BOOL,
441 pub reasons: CE_CrlDistReasonFlags,
442 pub crlIssuer: *mut CE_GeneralNames,
443}
444
445#[cfg(all(
446 feature = "SecAsn1Types",
447 feature = "cssmconfig",
448 feature = "cssmtype",
449 feature = "objc2",
450 feature = "x509defs"
451))]
452unsafe impl Encode for CE_CRLDistributionPoint {
453 const ENCODING: Encoding = Encoding::Struct(
454 "__CE_CRLDistributionPoint",
455 &[
456 <*mut CE_DistributionPointName>::ENCODING,
457 <CSSM_BOOL>::ENCODING,
458 <CE_CrlDistReasonFlags>::ENCODING,
459 <*mut CE_GeneralNames>::ENCODING,
460 ],
461 );
462}
463
464#[cfg(all(
465 feature = "SecAsn1Types",
466 feature = "cssmconfig",
467 feature = "cssmtype",
468 feature = "objc2",
469 feature = "x509defs"
470))]
471unsafe impl RefEncode for CE_CRLDistributionPoint {
472 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
473}
474
475#[cfg(all(
477 feature = "SecAsn1Types",
478 feature = "cssmconfig",
479 feature = "cssmtype",
480 feature = "x509defs"
481))]
482#[repr(C)]
483#[derive(Clone, Copy, Debug, PartialEq)]
484pub struct CE_CRLDistPointsSyntax {
485 pub numDistPoints: uint32,
486 pub distPoints: *mut CE_CRLDistributionPoint,
487}
488
489#[cfg(all(
490 feature = "SecAsn1Types",
491 feature = "cssmconfig",
492 feature = "cssmtype",
493 feature = "objc2",
494 feature = "x509defs"
495))]
496unsafe impl Encode for CE_CRLDistPointsSyntax {
497 const ENCODING: Encoding = Encoding::Struct(
498 "__CE_CRLDistPointsSyntax",
499 &[<uint32>::ENCODING, <*mut CE_CRLDistributionPoint>::ENCODING],
500 );
501}
502
503#[cfg(all(
504 feature = "SecAsn1Types",
505 feature = "cssmconfig",
506 feature = "cssmtype",
507 feature = "objc2",
508 feature = "x509defs"
509))]
510unsafe impl RefEncode for CE_CRLDistPointsSyntax {
511 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
512}
513
514#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
516#[repr(C)]
517#[derive(Clone, Copy, Debug, PartialEq)]
518pub struct CE_AccessDescription {
519 pub accessMethod: SecAsn1Oid,
520 pub accessLocation: CE_GeneralName,
521}
522
523#[cfg(all(
524 feature = "SecAsn1Types",
525 feature = "cssmconfig",
526 feature = "cssmtype",
527 feature = "objc2"
528))]
529unsafe impl Encode for CE_AccessDescription {
530 const ENCODING: Encoding = Encoding::Struct(
531 "__CE_AccessDescription",
532 &[<SecAsn1Oid>::ENCODING, <CE_GeneralName>::ENCODING],
533 );
534}
535
536#[cfg(all(
537 feature = "SecAsn1Types",
538 feature = "cssmconfig",
539 feature = "cssmtype",
540 feature = "objc2"
541))]
542unsafe impl RefEncode for CE_AccessDescription {
543 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
544}
545
546#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
548#[repr(C)]
549#[derive(Clone, Copy, Debug, PartialEq)]
550pub struct CE_AuthorityInfoAccess {
551 pub numAccessDescriptions: uint32,
552 pub accessDescriptions: *mut CE_AccessDescription,
553}
554
555#[cfg(all(
556 feature = "SecAsn1Types",
557 feature = "cssmconfig",
558 feature = "cssmtype",
559 feature = "objc2"
560))]
561unsafe impl Encode for CE_AuthorityInfoAccess {
562 const ENCODING: Encoding = Encoding::Struct(
563 "__CE_AuthorityInfoAccess",
564 &[<uint32>::ENCODING, <*mut CE_AccessDescription>::ENCODING],
565 );
566}
567
568#[cfg(all(
569 feature = "SecAsn1Types",
570 feature = "cssmconfig",
571 feature = "cssmtype",
572 feature = "objc2"
573))]
574unsafe impl RefEncode for CE_AuthorityInfoAccess {
575 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
576}
577
578#[deprecated]
580#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
581pub type CE_NameRegistrationAuthorities = CE_GeneralNames;
582
583#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
585#[repr(C)]
586#[derive(Clone, Copy, Debug, PartialEq)]
587pub struct CE_SemanticsInformation {
588 pub semanticsIdentifier: *mut SecAsn1Oid,
589 pub nameRegistrationAuthorities: *mut CE_NameRegistrationAuthorities,
590}
591
592#[cfg(all(
593 feature = "SecAsn1Types",
594 feature = "cssmconfig",
595 feature = "cssmtype",
596 feature = "objc2"
597))]
598unsafe impl Encode for CE_SemanticsInformation {
599 const ENCODING: Encoding = Encoding::Struct(
600 "__CE_SemanticsInformation",
601 &[
602 <*mut SecAsn1Oid>::ENCODING,
603 <*mut CE_NameRegistrationAuthorities>::ENCODING,
604 ],
605 );
606}
607
608#[cfg(all(
609 feature = "SecAsn1Types",
610 feature = "cssmconfig",
611 feature = "cssmtype",
612 feature = "objc2"
613))]
614unsafe impl RefEncode for CE_SemanticsInformation {
615 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
616}
617
618#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
620#[repr(C)]
621#[derive(Clone, Copy, Debug, PartialEq)]
622pub struct CE_QC_Statement {
623 pub statementId: SecAsn1Oid,
624 pub semanticsInfo: *mut CE_SemanticsInformation,
625 pub otherInfo: *mut SecAsn1Item,
626}
627
628#[cfg(all(
629 feature = "SecAsn1Types",
630 feature = "cssmconfig",
631 feature = "cssmtype",
632 feature = "objc2"
633))]
634unsafe impl Encode for CE_QC_Statement {
635 const ENCODING: Encoding = Encoding::Struct(
636 "__CE_QC_Statement",
637 &[
638 <SecAsn1Oid>::ENCODING,
639 <*mut CE_SemanticsInformation>::ENCODING,
640 <*mut SecAsn1Item>::ENCODING,
641 ],
642 );
643}
644
645#[cfg(all(
646 feature = "SecAsn1Types",
647 feature = "cssmconfig",
648 feature = "cssmtype",
649 feature = "objc2"
650))]
651unsafe impl RefEncode for CE_QC_Statement {
652 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
653}
654
655#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
657#[repr(C)]
658#[derive(Clone, Copy, Debug, PartialEq)]
659pub struct CE_QC_Statements {
660 pub numQCStatements: uint32,
661 pub qcStatements: *mut CE_QC_Statement,
662}
663
664#[cfg(all(
665 feature = "SecAsn1Types",
666 feature = "cssmconfig",
667 feature = "cssmtype",
668 feature = "objc2"
669))]
670unsafe impl Encode for CE_QC_Statements {
671 const ENCODING: Encoding = Encoding::Struct(
672 "__CE_QC_Statements",
673 &[<uint32>::ENCODING, <*mut CE_QC_Statement>::ENCODING],
674 );
675}
676
677#[cfg(all(
678 feature = "SecAsn1Types",
679 feature = "cssmconfig",
680 feature = "cssmtype",
681 feature = "objc2"
682))]
683unsafe impl RefEncode for CE_QC_Statements {
684 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
685}
686
687#[cfg(feature = "cssmconfig")]
691pub type CE_CrlNumber = uint32;
692
693#[cfg(feature = "cssmconfig")]
695pub type CE_DeltaCrl = uint32;
696
697#[cfg(all(
699 feature = "SecAsn1Types",
700 feature = "cssmconfig",
701 feature = "cssmtype",
702 feature = "x509defs"
703))]
704#[repr(C)]
705#[derive(Clone, Copy, Debug, PartialEq)]
706pub struct CE_IssuingDistributionPoint {
707 pub distPointName: *mut CE_DistributionPointName,
708 pub onlyUserCertsPresent: CSSM_BOOL,
709 pub onlyUserCerts: CSSM_BOOL,
710 pub onlyCACertsPresent: CSSM_BOOL,
711 pub onlyCACerts: CSSM_BOOL,
712 pub onlySomeReasonsPresent: CSSM_BOOL,
713 pub onlySomeReasons: CE_CrlDistReasonFlags,
714 pub indirectCrlPresent: CSSM_BOOL,
715 pub indirectCrl: CSSM_BOOL,
716}
717
718#[cfg(all(
719 feature = "SecAsn1Types",
720 feature = "cssmconfig",
721 feature = "cssmtype",
722 feature = "objc2",
723 feature = "x509defs"
724))]
725unsafe impl Encode for CE_IssuingDistributionPoint {
726 const ENCODING: Encoding = Encoding::Struct(
727 "__CE_IssuingDistributionPoint",
728 &[
729 <*mut CE_DistributionPointName>::ENCODING,
730 <CSSM_BOOL>::ENCODING,
731 <CSSM_BOOL>::ENCODING,
732 <CSSM_BOOL>::ENCODING,
733 <CSSM_BOOL>::ENCODING,
734 <CSSM_BOOL>::ENCODING,
735 <CE_CrlDistReasonFlags>::ENCODING,
736 <CSSM_BOOL>::ENCODING,
737 <CSSM_BOOL>::ENCODING,
738 ],
739 );
740}
741
742#[cfg(all(
743 feature = "SecAsn1Types",
744 feature = "cssmconfig",
745 feature = "cssmtype",
746 feature = "objc2",
747 feature = "x509defs"
748))]
749unsafe impl RefEncode for CE_IssuingDistributionPoint {
750 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
751}
752
753#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
755#[repr(C)]
756#[derive(Clone, Copy, Debug, PartialEq)]
757pub struct CE_GeneralSubtree {
758 pub base: *mut CE_GeneralNames,
759 pub minimum: uint32,
760 pub maximumPresent: CSSM_BOOL,
761 pub maximum: uint32,
762}
763
764#[cfg(all(
765 feature = "SecAsn1Types",
766 feature = "cssmconfig",
767 feature = "cssmtype",
768 feature = "objc2"
769))]
770unsafe impl Encode for CE_GeneralSubtree {
771 const ENCODING: Encoding = Encoding::Struct(
772 "__CE_GeneralSubtree",
773 &[
774 <*mut CE_GeneralNames>::ENCODING,
775 <uint32>::ENCODING,
776 <CSSM_BOOL>::ENCODING,
777 <uint32>::ENCODING,
778 ],
779 );
780}
781
782#[cfg(all(
783 feature = "SecAsn1Types",
784 feature = "cssmconfig",
785 feature = "cssmtype",
786 feature = "objc2"
787))]
788unsafe impl RefEncode for CE_GeneralSubtree {
789 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
790}
791
792#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
794#[repr(C)]
795#[derive(Clone, Copy, Debug, PartialEq)]
796pub struct CE_GeneralSubtrees {
797 pub numSubtrees: uint32,
798 pub subtrees: *mut CE_GeneralSubtree,
799}
800
801#[cfg(all(
802 feature = "SecAsn1Types",
803 feature = "cssmconfig",
804 feature = "cssmtype",
805 feature = "objc2"
806))]
807unsafe impl Encode for CE_GeneralSubtrees {
808 const ENCODING: Encoding = Encoding::Struct(
809 "__CE_GeneralSubtrees",
810 &[<uint32>::ENCODING, <*mut CE_GeneralSubtree>::ENCODING],
811 );
812}
813
814#[cfg(all(
815 feature = "SecAsn1Types",
816 feature = "cssmconfig",
817 feature = "cssmtype",
818 feature = "objc2"
819))]
820unsafe impl RefEncode for CE_GeneralSubtrees {
821 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
822}
823
824#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
826#[repr(C)]
827#[derive(Clone, Copy, Debug, PartialEq)]
828pub struct CE_NameConstraints {
829 pub permitted: *mut CE_GeneralSubtrees,
830 pub excluded: *mut CE_GeneralSubtrees,
831}
832
833#[cfg(all(
834 feature = "SecAsn1Types",
835 feature = "cssmconfig",
836 feature = "cssmtype",
837 feature = "objc2"
838))]
839unsafe impl Encode for CE_NameConstraints {
840 const ENCODING: Encoding = Encoding::Struct(
841 "__CE_NameConstraints",
842 &[
843 <*mut CE_GeneralSubtrees>::ENCODING,
844 <*mut CE_GeneralSubtrees>::ENCODING,
845 ],
846 );
847}
848
849#[cfg(all(
850 feature = "SecAsn1Types",
851 feature = "cssmconfig",
852 feature = "cssmtype",
853 feature = "objc2"
854))]
855unsafe impl RefEncode for CE_NameConstraints {
856 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
857}
858
859#[cfg(feature = "SecAsn1Types")]
861#[repr(C)]
862#[derive(Clone, Copy, Debug, PartialEq)]
863pub struct CE_PolicyMapping {
864 pub issuerDomainPolicy: SecAsn1Oid,
865 pub subjectDomainPolicy: SecAsn1Oid,
866}
867
868#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
869unsafe impl Encode for CE_PolicyMapping {
870 const ENCODING: Encoding = Encoding::Struct(
871 "__CE_PolicyMapping",
872 &[<SecAsn1Oid>::ENCODING, <SecAsn1Oid>::ENCODING],
873 );
874}
875
876#[cfg(all(feature = "SecAsn1Types", feature = "objc2"))]
877unsafe impl RefEncode for CE_PolicyMapping {
878 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
879}
880
881#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig"))]
883#[repr(C)]
884#[derive(Clone, Copy, Debug, PartialEq)]
885pub struct CE_PolicyMappings {
886 pub numPolicyMappings: uint32,
887 pub policyMappings: *mut CE_PolicyMapping,
888}
889
890#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
891unsafe impl Encode for CE_PolicyMappings {
892 const ENCODING: Encoding = Encoding::Struct(
893 "__CE_PolicyMappings",
894 &[<uint32>::ENCODING, <*mut CE_PolicyMapping>::ENCODING],
895 );
896}
897
898#[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "objc2"))]
899unsafe impl RefEncode for CE_PolicyMappings {
900 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
901}
902
903#[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
905#[repr(C)]
906#[derive(Clone, Copy, Debug, PartialEq)]
907pub struct CE_PolicyConstraints {
908 pub requireExplicitPolicyPresent: CSSM_BOOL,
909 pub requireExplicitPolicy: uint32,
910 pub inhibitPolicyMappingPresent: CSSM_BOOL,
911 pub inhibitPolicyMapping: uint32,
912}
913
914#[cfg(all(feature = "cssmconfig", feature = "cssmtype", feature = "objc2"))]
915unsafe impl Encode for CE_PolicyConstraints {
916 const ENCODING: Encoding = Encoding::Struct(
917 "__CE_PolicyConstraints",
918 &[
919 <CSSM_BOOL>::ENCODING,
920 <uint32>::ENCODING,
921 <CSSM_BOOL>::ENCODING,
922 <uint32>::ENCODING,
923 ],
924 );
925}
926
927#[cfg(all(feature = "cssmconfig", feature = "cssmtype", feature = "objc2"))]
928unsafe impl RefEncode for CE_PolicyConstraints {
929 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
930}
931
932#[deprecated]
934#[cfg(feature = "cssmconfig")]
935pub type CE_InhibitAnyPolicy = uint32;
936
937#[repr(transparent)]
939#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
940pub struct CE_DataType(pub c_uint);
941impl CE_DataType {
942 pub const DT_AuthorityKeyID: Self = Self(0);
943 pub const DT_SubjectKeyID: Self = Self(1);
944 pub const DT_KeyUsage: Self = Self(2);
945 pub const DT_SubjectAltName: Self = Self(3);
946 pub const DT_IssuerAltName: Self = Self(4);
947 pub const DT_ExtendedKeyUsage: Self = Self(5);
948 pub const DT_BasicConstraints: Self = Self(6);
949 pub const DT_CertPolicies: Self = Self(7);
950 pub const DT_NetscapeCertType: Self = Self(8);
951 pub const DT_CrlNumber: Self = Self(9);
952 pub const DT_DeltaCrl: Self = Self(10);
953 pub const DT_CrlReason: Self = Self(11);
954 pub const DT_CrlDistributionPoints: Self = Self(12);
955 pub const DT_IssuingDistributionPoint: Self = Self(13);
956 pub const DT_AuthorityInfoAccess: Self = Self(14);
957 pub const DT_Other: Self = Self(15);
958 pub const DT_QC_Statements: Self = Self(16);
959 pub const DT_NameConstraints: Self = Self(17);
960 pub const DT_PolicyMappings: Self = Self(18);
961 pub const DT_PolicyConstraints: Self = Self(19);
962 pub const DT_InhibitAnyPolicy: Self = Self(20);
963}
964
965#[cfg(feature = "objc2")]
966unsafe impl Encode for CE_DataType {
967 const ENCODING: Encoding = c_uint::ENCODING;
968}
969
970#[cfg(feature = "objc2")]
971unsafe impl RefEncode for CE_DataType {
972 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
973}
974
975#[cfg(all(
977 feature = "SecAsn1Types",
978 feature = "cssmconfig",
979 feature = "cssmtype",
980 feature = "x509defs"
981))]
982#[repr(C)]
983#[derive(Clone, Copy)]
984pub union CE_Data {
985 pub authorityKeyID: CE_AuthorityKeyID,
986 pub subjectKeyID: CE_SubjectKeyID,
987 pub keyUsage: CE_KeyUsage,
988 pub subjectAltName: CE_GeneralNames,
989 pub issuerAltName: CE_GeneralNames,
990 pub extendedKeyUsage: CE_ExtendedKeyUsage,
991 pub basicConstraints: CE_BasicConstraints,
992 pub certPolicies: CE_CertPolicies,
993 pub netscapeCertType: CE_NetscapeCertType,
994 pub crlNumber: CE_CrlNumber,
995 pub deltaCrl: CE_DeltaCrl,
996 pub crlReason: CE_CrlReason,
997 pub crlDistPoints: CE_CRLDistPointsSyntax,
998 pub issuingDistPoint: CE_IssuingDistributionPoint,
999 pub authorityInfoAccess: CE_AuthorityInfoAccess,
1000 pub qualifiedCertStatements: CE_QC_Statements,
1001 pub nameConstraints: CE_NameConstraints,
1002 pub policyMappings: CE_PolicyMappings,
1003 pub policyConstraints: CE_PolicyConstraints,
1004 pub inhibitAnyPolicy: CE_InhibitAnyPolicy,
1005 pub rawData: SecAsn1Item,
1006}
1007
1008#[cfg(all(
1009 feature = "SecAsn1Types",
1010 feature = "cssmconfig",
1011 feature = "cssmtype",
1012 feature = "objc2",
1013 feature = "x509defs"
1014))]
1015unsafe impl Encode for CE_Data {
1016 const ENCODING: Encoding = Encoding::Union(
1017 "?",
1018 &[
1019 <CE_AuthorityKeyID>::ENCODING,
1020 <CE_SubjectKeyID>::ENCODING,
1021 <CE_KeyUsage>::ENCODING,
1022 <CE_GeneralNames>::ENCODING,
1023 <CE_GeneralNames>::ENCODING,
1024 <CE_ExtendedKeyUsage>::ENCODING,
1025 <CE_BasicConstraints>::ENCODING,
1026 <CE_CertPolicies>::ENCODING,
1027 <CE_NetscapeCertType>::ENCODING,
1028 <CE_CrlNumber>::ENCODING,
1029 <CE_DeltaCrl>::ENCODING,
1030 <CE_CrlReason>::ENCODING,
1031 <CE_CRLDistPointsSyntax>::ENCODING,
1032 <CE_IssuingDistributionPoint>::ENCODING,
1033 <CE_AuthorityInfoAccess>::ENCODING,
1034 <CE_QC_Statements>::ENCODING,
1035 <CE_NameConstraints>::ENCODING,
1036 <CE_PolicyMappings>::ENCODING,
1037 <CE_PolicyConstraints>::ENCODING,
1038 <CE_InhibitAnyPolicy>::ENCODING,
1039 <SecAsn1Item>::ENCODING,
1040 ],
1041 );
1042}
1043
1044#[cfg(all(
1045 feature = "SecAsn1Types",
1046 feature = "cssmconfig",
1047 feature = "cssmtype",
1048 feature = "objc2",
1049 feature = "x509defs"
1050))]
1051unsafe impl RefEncode for CE_Data {
1052 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1053}
1054
1055#[cfg(all(
1057 feature = "SecAsn1Types",
1058 feature = "cssmconfig",
1059 feature = "cssmtype",
1060 feature = "x509defs"
1061))]
1062#[repr(C)]
1063#[derive(Clone, Copy)]
1064pub struct CE_DataAndType {
1065 pub r#type: CE_DataType,
1066 pub extension: CE_Data,
1067 pub critical: CSSM_BOOL,
1068}
1069
1070#[cfg(all(
1071 feature = "SecAsn1Types",
1072 feature = "cssmconfig",
1073 feature = "cssmtype",
1074 feature = "objc2",
1075 feature = "x509defs"
1076))]
1077unsafe impl Encode for CE_DataAndType {
1078 const ENCODING: Encoding = Encoding::Struct(
1079 "__CE_DataAndType",
1080 &[
1081 <CE_DataType>::ENCODING,
1082 <CE_Data>::ENCODING,
1083 <CSSM_BOOL>::ENCODING,
1084 ],
1085 );
1086}
1087
1088#[cfg(all(
1089 feature = "SecAsn1Types",
1090 feature = "cssmconfig",
1091 feature = "cssmtype",
1092 feature = "objc2",
1093 feature = "x509defs"
1094))]
1095unsafe impl RefEncode for CE_DataAndType {
1096 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
1097}