1use core::ffi::*;
4
5use crate::*;
6
7extern "C-unwind" {
8 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
9 #[deprecated]
10 pub fn CSSM_Init(
11 version: *const CSSM_VERSION,
12 scope: CSSM_PRIVILEGE_SCOPE,
13 caller_guid: *const CSSM_GUID,
14 key_hierarchy: CSSM_KEY_HIERARCHY,
15 pvc_policy: *mut CSSM_PVC_MODE,
16 reserved: *const c_void,
17 ) -> CSSM_RETURN;
18}
19
20extern "C-unwind" {
21 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
22 #[deprecated]
23 pub fn CSSM_Terminate() -> CSSM_RETURN;
24}
25
26extern "C-unwind" {
27 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
28 #[deprecated]
29 pub fn CSSM_ModuleLoad(
30 module_guid: *const CSSM_GUID,
31 key_hierarchy: CSSM_KEY_HIERARCHY,
32 app_notify_callback: CSSM_API_ModuleEventHandler,
33 app_notify_callback_ctx: *mut c_void,
34 ) -> CSSM_RETURN;
35}
36
37extern "C-unwind" {
38 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
39 #[deprecated]
40 pub fn CSSM_ModuleUnload(
41 module_guid: *const CSSM_GUID,
42 app_notify_callback: CSSM_API_ModuleEventHandler,
43 app_notify_callback_ctx: *mut c_void,
44 ) -> CSSM_RETURN;
45}
46
47extern "C-unwind" {
48 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
49 #[deprecated]
50 pub fn CSSM_Introduce(
51 module_id: *const CSSM_GUID,
52 key_hierarchy: CSSM_KEY_HIERARCHY,
53 ) -> CSSM_RETURN;
54}
55
56extern "C-unwind" {
57 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
58 #[deprecated]
59 pub fn CSSM_Unintroduce(module_id: *const CSSM_GUID) -> CSSM_RETURN;
60}
61
62extern "C-unwind" {
63 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
64 #[deprecated]
65 pub fn CSSM_ModuleAttach(
66 module_guid: *const CSSM_GUID,
67 version: *const CSSM_VERSION,
68 memory_funcs: *const CSSM_API_MEMORY_FUNCS,
69 subservice_id: uint32,
70 sub_service_type: CSSM_SERVICE_TYPE,
71 attach_flags: CSSM_ATTACH_FLAGS,
72 key_hierarchy: CSSM_KEY_HIERARCHY,
73 function_table: *mut CSSM_FUNC_NAME_ADDR,
74 num_function_table: uint32,
75 reserved: *const c_void,
76 new_module_handle: CSSM_MODULE_HANDLE_PTR,
77 ) -> CSSM_RETURN;
78}
79
80extern "C-unwind" {
81 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
82 #[deprecated]
83 pub fn CSSM_ModuleDetach(module_handle: CSSM_MODULE_HANDLE) -> CSSM_RETURN;
84}
85
86extern "C-unwind" {
87 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
88 #[deprecated]
89 pub fn CSSM_SetPrivilege(privilege: CSSM_PRIVILEGE) -> CSSM_RETURN;
90}
91
92extern "C-unwind" {
93 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
94 #[deprecated]
95 pub fn CSSM_GetPrivilege(privilege: *mut CSSM_PRIVILEGE) -> CSSM_RETURN;
96}
97
98extern "C-unwind" {
99 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
100 #[deprecated]
101 pub fn CSSM_GetModuleGUIDFromHandle(
102 module_handle: CSSM_MODULE_HANDLE,
103 module_guid: CSSM_GUID_PTR,
104 ) -> CSSM_RETURN;
105}
106
107extern "C-unwind" {
108 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
109 #[deprecated]
110 pub fn CSSM_GetSubserviceUIDFromHandle(
111 module_handle: CSSM_MODULE_HANDLE,
112 subservice_uid: CSSM_SUBSERVICE_UID_PTR,
113 ) -> CSSM_RETURN;
114}
115
116extern "C-unwind" {
117 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
118 #[deprecated]
119 pub fn CSSM_ListAttachedModuleManagers(
120 number_of_module_managers: *mut uint32,
121 module_manager_guids: CSSM_GUID_PTR,
122 ) -> CSSM_RETURN;
123}
124
125extern "C-unwind" {
126 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
127 #[deprecated]
128 pub fn CSSM_GetAPIMemoryFunctions(
129 add_in_handle: CSSM_MODULE_HANDLE,
130 app_memory_funcs: CSSM_API_MEMORY_FUNCS_PTR,
131 ) -> CSSM_RETURN;
132}
133
134extern "C-unwind" {
135 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
136 #[deprecated]
137 pub fn CSSM_CSP_CreateSignatureContext(
138 csp_handle: CSSM_CSP_HANDLE,
139 algorithm_id: CSSM_ALGORITHMS,
140 access_cred: *const CSSM_ACCESS_CREDENTIALS,
141 key: *const CSSM_KEY,
142 new_context_handle: *mut CSSM_CC_HANDLE,
143 ) -> CSSM_RETURN;
144}
145
146extern "C-unwind" {
147 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
148 #[deprecated]
149 pub fn CSSM_CSP_CreateSymmetricContext(
150 csp_handle: CSSM_CSP_HANDLE,
151 algorithm_id: CSSM_ALGORITHMS,
152 mode: CSSM_ENCRYPT_MODE,
153 access_cred: *const CSSM_ACCESS_CREDENTIALS,
154 key: *const CSSM_KEY,
155 init_vector: *const SecAsn1Item,
156 padding: CSSM_PADDING,
157 reserved: *mut c_void,
158 new_context_handle: *mut CSSM_CC_HANDLE,
159 ) -> CSSM_RETURN;
160}
161
162extern "C-unwind" {
163 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
164 #[deprecated]
165 pub fn CSSM_CSP_CreateDigestContext(
166 csp_handle: CSSM_CSP_HANDLE,
167 algorithm_id: CSSM_ALGORITHMS,
168 new_context_handle: *mut CSSM_CC_HANDLE,
169 ) -> CSSM_RETURN;
170}
171
172extern "C-unwind" {
173 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
174 #[deprecated]
175 pub fn CSSM_CSP_CreateMacContext(
176 csp_handle: CSSM_CSP_HANDLE,
177 algorithm_id: CSSM_ALGORITHMS,
178 key: *const CSSM_KEY,
179 new_context_handle: *mut CSSM_CC_HANDLE,
180 ) -> CSSM_RETURN;
181}
182
183extern "C-unwind" {
184 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
185 #[deprecated]
186 pub fn CSSM_CSP_CreateRandomGenContext(
187 csp_handle: CSSM_CSP_HANDLE,
188 algorithm_id: CSSM_ALGORITHMS,
189 seed: *const CSSM_CRYPTO_DATA,
190 length: CSSM_SIZE,
191 new_context_handle: *mut CSSM_CC_HANDLE,
192 ) -> CSSM_RETURN;
193}
194
195extern "C-unwind" {
196 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
197 #[deprecated]
198 pub fn CSSM_CSP_CreateAsymmetricContext(
199 csp_handle: CSSM_CSP_HANDLE,
200 algorithm_id: CSSM_ALGORITHMS,
201 access_cred: *const CSSM_ACCESS_CREDENTIALS,
202 key: *const CSSM_KEY,
203 padding: CSSM_PADDING,
204 new_context_handle: *mut CSSM_CC_HANDLE,
205 ) -> CSSM_RETURN;
206}
207
208extern "C-unwind" {
209 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
210 #[deprecated]
211 pub fn CSSM_CSP_CreateDeriveKeyContext(
212 csp_handle: CSSM_CSP_HANDLE,
213 algorithm_id: CSSM_ALGORITHMS,
214 derive_key_type: CSSM_KEY_TYPE,
215 derive_key_length_in_bits: uint32,
216 access_cred: *const CSSM_ACCESS_CREDENTIALS,
217 base_key: *const CSSM_KEY,
218 iteration_count: uint32,
219 salt: *const SecAsn1Item,
220 seed: *const CSSM_CRYPTO_DATA,
221 new_context_handle: *mut CSSM_CC_HANDLE,
222 ) -> CSSM_RETURN;
223}
224
225extern "C-unwind" {
226 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
227 #[deprecated]
228 pub fn CSSM_CSP_CreateKeyGenContext(
229 csp_handle: CSSM_CSP_HANDLE,
230 algorithm_id: CSSM_ALGORITHMS,
231 key_size_in_bits: uint32,
232 seed: *const CSSM_CRYPTO_DATA,
233 salt: *const SecAsn1Item,
234 start_date: *const CSSM_DATE,
235 end_date: *const CSSM_DATE,
236 params: *const SecAsn1Item,
237 new_context_handle: *mut CSSM_CC_HANDLE,
238 ) -> CSSM_RETURN;
239}
240
241extern "C-unwind" {
242 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
243 #[deprecated]
244 pub fn CSSM_CSP_CreatePassThroughContext(
245 csp_handle: CSSM_CSP_HANDLE,
246 key: *const CSSM_KEY,
247 new_context_handle: *mut CSSM_CC_HANDLE,
248 ) -> CSSM_RETURN;
249}
250
251extern "C-unwind" {
252 #[cfg(all(
253 feature = "SecAsn1Types",
254 feature = "cssmconfig",
255 feature = "cssmkrapi",
256 feature = "cssmtype"
257 ))]
258 #[deprecated]
259 pub fn CSSM_GetContext(
260 cc_handle: CSSM_CC_HANDLE,
261 context: *mut CSSM_CONTEXT_PTR,
262 ) -> CSSM_RETURN;
263}
264
265extern "C-unwind" {
266 #[cfg(all(
267 feature = "SecAsn1Types",
268 feature = "cssmconfig",
269 feature = "cssmkrapi",
270 feature = "cssmtype"
271 ))]
272 #[deprecated]
273 pub fn CSSM_FreeContext(context: CSSM_CONTEXT_PTR) -> CSSM_RETURN;
274}
275
276extern "C-unwind" {
277 #[cfg(all(
278 feature = "SecAsn1Types",
279 feature = "cssmconfig",
280 feature = "cssmkrapi",
281 feature = "cssmtype"
282 ))]
283 #[deprecated]
284 pub fn CSSM_SetContext(cc_handle: CSSM_CC_HANDLE, context: *const CSSM_CONTEXT) -> CSSM_RETURN;
285}
286
287extern "C-unwind" {
288 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
289 #[deprecated]
290 pub fn CSSM_DeleteContext(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
291}
292
293extern "C-unwind" {
294 #[cfg(all(
295 feature = "SecAsn1Types",
296 feature = "cssmconfig",
297 feature = "cssmkrapi",
298 feature = "cssmtype"
299 ))]
300 #[deprecated]
301 pub fn CSSM_GetContextAttribute(
302 context: *const CSSM_CONTEXT,
303 attribute_type: uint32,
304 context_attribute: *mut CSSM_CONTEXT_ATTRIBUTE_PTR,
305 ) -> CSSM_RETURN;
306}
307
308extern "C-unwind" {
309 #[cfg(all(
310 feature = "SecAsn1Types",
311 feature = "cssmconfig",
312 feature = "cssmkrapi",
313 feature = "cssmtype"
314 ))]
315 #[deprecated]
316 pub fn CSSM_UpdateContextAttributes(
317 cc_handle: CSSM_CC_HANDLE,
318 number_of_attributes: uint32,
319 context_attributes: *const CSSM_CONTEXT_ATTRIBUTE,
320 ) -> CSSM_RETURN;
321}
322
323extern "C-unwind" {
324 #[cfg(all(
325 feature = "SecAsn1Types",
326 feature = "cssmconfig",
327 feature = "cssmkrapi",
328 feature = "cssmtype"
329 ))]
330 #[deprecated]
331 pub fn CSSM_DeleteContextAttributes(
332 cc_handle: CSSM_CC_HANDLE,
333 number_of_attributes: uint32,
334 context_attributes: *const CSSM_CONTEXT_ATTRIBUTE,
335 ) -> CSSM_RETURN;
336}
337
338extern "C-unwind" {
339 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
340 #[deprecated]
341 pub fn CSSM_CSP_Login(
342 csp_handle: CSSM_CSP_HANDLE,
343 access_cred: *const CSSM_ACCESS_CREDENTIALS,
344 login_name: *const SecAsn1Item,
345 reserved: *const c_void,
346 ) -> CSSM_RETURN;
347}
348
349extern "C-unwind" {
350 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
351 #[deprecated]
352 pub fn CSSM_CSP_Logout(csp_handle: CSSM_CSP_HANDLE) -> CSSM_RETURN;
353}
354
355extern "C-unwind" {
356 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
357 #[deprecated]
358 pub fn CSSM_CSP_GetLoginAcl(
359 csp_handle: CSSM_CSP_HANDLE,
360 selection_tag: *const CSSM_STRING,
361 number_of_acl_infos: *mut uint32,
362 acl_infos: *mut CSSM_ACL_ENTRY_INFO_PTR,
363 ) -> CSSM_RETURN;
364}
365
366extern "C-unwind" {
367 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
368 #[deprecated]
369 pub fn CSSM_CSP_ChangeLoginAcl(
370 csp_handle: CSSM_CSP_HANDLE,
371 access_cred: *const CSSM_ACCESS_CREDENTIALS,
372 acl_edit: *const CSSM_ACL_EDIT,
373 ) -> CSSM_RETURN;
374}
375
376extern "C-unwind" {
377 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
378 #[deprecated]
379 pub fn CSSM_GetKeyAcl(
380 csp_handle: CSSM_CSP_HANDLE,
381 key: *const CSSM_KEY,
382 selection_tag: *const CSSM_STRING,
383 number_of_acl_infos: *mut uint32,
384 acl_infos: *mut CSSM_ACL_ENTRY_INFO_PTR,
385 ) -> CSSM_RETURN;
386}
387
388extern "C-unwind" {
389 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
390 #[deprecated]
391 pub fn CSSM_ChangeKeyAcl(
392 csp_handle: CSSM_CSP_HANDLE,
393 access_cred: *const CSSM_ACCESS_CREDENTIALS,
394 acl_edit: *const CSSM_ACL_EDIT,
395 key: *const CSSM_KEY,
396 ) -> CSSM_RETURN;
397}
398
399extern "C-unwind" {
400 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
401 #[deprecated]
402 pub fn CSSM_GetKeyOwner(
403 csp_handle: CSSM_CSP_HANDLE,
404 key: *const CSSM_KEY,
405 owner: CSSM_ACL_OWNER_PROTOTYPE_PTR,
406 ) -> CSSM_RETURN;
407}
408
409extern "C-unwind" {
410 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
411 #[deprecated]
412 pub fn CSSM_ChangeKeyOwner(
413 csp_handle: CSSM_CSP_HANDLE,
414 access_cred: *const CSSM_ACCESS_CREDENTIALS,
415 key: *const CSSM_KEY,
416 new_owner: *const CSSM_ACL_OWNER_PROTOTYPE,
417 ) -> CSSM_RETURN;
418}
419
420extern "C-unwind" {
421 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
422 #[deprecated]
423 pub fn CSSM_CSP_GetLoginOwner(
424 csp_handle: CSSM_CSP_HANDLE,
425 owner: CSSM_ACL_OWNER_PROTOTYPE_PTR,
426 ) -> CSSM_RETURN;
427}
428
429extern "C-unwind" {
430 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
431 #[deprecated]
432 pub fn CSSM_CSP_ChangeLoginOwner(
433 csp_handle: CSSM_CSP_HANDLE,
434 access_cred: *const CSSM_ACCESS_CREDENTIALS,
435 new_owner: *const CSSM_ACL_OWNER_PROTOTYPE,
436 ) -> CSSM_RETURN;
437}
438
439extern "C-unwind" {
440 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
441 #[deprecated]
442 pub fn CSSM_SignData(
443 cc_handle: CSSM_CC_HANDLE,
444 data_bufs: *const SecAsn1Item,
445 data_buf_count: uint32,
446 digest_algorithm: CSSM_ALGORITHMS,
447 signature: CSSM_DATA_PTR,
448 ) -> CSSM_RETURN;
449}
450
451extern "C-unwind" {
452 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
453 #[deprecated]
454 pub fn CSSM_SignDataInit(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
455}
456
457extern "C-unwind" {
458 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
459 #[deprecated]
460 pub fn CSSM_SignDataUpdate(
461 cc_handle: CSSM_CC_HANDLE,
462 data_bufs: *const SecAsn1Item,
463 data_buf_count: uint32,
464 ) -> CSSM_RETURN;
465}
466
467extern "C-unwind" {
468 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
469 #[deprecated]
470 pub fn CSSM_SignDataFinal(cc_handle: CSSM_CC_HANDLE, signature: CSSM_DATA_PTR) -> CSSM_RETURN;
471}
472
473extern "C-unwind" {
474 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
475 #[deprecated]
476 pub fn CSSM_VerifyData(
477 cc_handle: CSSM_CC_HANDLE,
478 data_bufs: *const SecAsn1Item,
479 data_buf_count: uint32,
480 digest_algorithm: CSSM_ALGORITHMS,
481 signature: *const SecAsn1Item,
482 ) -> CSSM_RETURN;
483}
484
485extern "C-unwind" {
486 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
487 #[deprecated]
488 pub fn CSSM_VerifyDataInit(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
489}
490
491extern "C-unwind" {
492 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
493 #[deprecated]
494 pub fn CSSM_VerifyDataUpdate(
495 cc_handle: CSSM_CC_HANDLE,
496 data_bufs: *const SecAsn1Item,
497 data_buf_count: uint32,
498 ) -> CSSM_RETURN;
499}
500
501extern "C-unwind" {
502 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
503 #[deprecated]
504 pub fn CSSM_VerifyDataFinal(
505 cc_handle: CSSM_CC_HANDLE,
506 signature: *const SecAsn1Item,
507 ) -> CSSM_RETURN;
508}
509
510extern "C-unwind" {
511 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
512 #[deprecated]
513 pub fn CSSM_DigestData(
514 cc_handle: CSSM_CC_HANDLE,
515 data_bufs: *const SecAsn1Item,
516 data_buf_count: uint32,
517 digest: CSSM_DATA_PTR,
518 ) -> CSSM_RETURN;
519}
520
521extern "C-unwind" {
522 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
523 #[deprecated]
524 pub fn CSSM_DigestDataInit(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
525}
526
527extern "C-unwind" {
528 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
529 #[deprecated]
530 pub fn CSSM_DigestDataUpdate(
531 cc_handle: CSSM_CC_HANDLE,
532 data_bufs: *const SecAsn1Item,
533 data_buf_count: uint32,
534 ) -> CSSM_RETURN;
535}
536
537extern "C-unwind" {
538 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
539 #[deprecated]
540 pub fn CSSM_DigestDataClone(
541 cc_handle: CSSM_CC_HANDLE,
542 clonednew_cc_handle: *mut CSSM_CC_HANDLE,
543 ) -> CSSM_RETURN;
544}
545
546extern "C-unwind" {
547 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
548 #[deprecated]
549 pub fn CSSM_DigestDataFinal(cc_handle: CSSM_CC_HANDLE, digest: CSSM_DATA_PTR) -> CSSM_RETURN;
550}
551
552extern "C-unwind" {
553 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
554 #[deprecated]
555 pub fn CSSM_GenerateMac(
556 cc_handle: CSSM_CC_HANDLE,
557 data_bufs: *const SecAsn1Item,
558 data_buf_count: uint32,
559 mac: CSSM_DATA_PTR,
560 ) -> CSSM_RETURN;
561}
562
563extern "C-unwind" {
564 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
565 #[deprecated]
566 pub fn CSSM_GenerateMacInit(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
567}
568
569extern "C-unwind" {
570 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
571 #[deprecated]
572 pub fn CSSM_GenerateMacUpdate(
573 cc_handle: CSSM_CC_HANDLE,
574 data_bufs: *const SecAsn1Item,
575 data_buf_count: uint32,
576 ) -> CSSM_RETURN;
577}
578
579extern "C-unwind" {
580 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
581 #[deprecated]
582 pub fn CSSM_GenerateMacFinal(cc_handle: CSSM_CC_HANDLE, mac: CSSM_DATA_PTR) -> CSSM_RETURN;
583}
584
585extern "C-unwind" {
586 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
587 #[deprecated]
588 pub fn CSSM_VerifyMac(
589 cc_handle: CSSM_CC_HANDLE,
590 data_bufs: *const SecAsn1Item,
591 data_buf_count: uint32,
592 mac: *const SecAsn1Item,
593 ) -> CSSM_RETURN;
594}
595
596extern "C-unwind" {
597 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
598 #[deprecated]
599 pub fn CSSM_VerifyMacInit(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
600}
601
602extern "C-unwind" {
603 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
604 #[deprecated]
605 pub fn CSSM_VerifyMacUpdate(
606 cc_handle: CSSM_CC_HANDLE,
607 data_bufs: *const SecAsn1Item,
608 data_buf_count: uint32,
609 ) -> CSSM_RETURN;
610}
611
612extern "C-unwind" {
613 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
614 #[deprecated]
615 pub fn CSSM_VerifyMacFinal(cc_handle: CSSM_CC_HANDLE, mac: *const SecAsn1Item) -> CSSM_RETURN;
616}
617
618extern "C-unwind" {
619 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
620 #[deprecated]
621 pub fn CSSM_QuerySize(
622 cc_handle: CSSM_CC_HANDLE,
623 encrypt: CSSM_BOOL,
624 query_size_count: uint32,
625 data_block_sizes: CSSM_QUERY_SIZE_DATA_PTR,
626 ) -> CSSM_RETURN;
627}
628
629extern "C-unwind" {
630 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
631 #[deprecated]
632 pub fn CSSM_EncryptData(
633 cc_handle: CSSM_CC_HANDLE,
634 clear_bufs: *const SecAsn1Item,
635 clear_buf_count: uint32,
636 cipher_bufs: CSSM_DATA_PTR,
637 cipher_buf_count: uint32,
638 bytes_encrypted: *mut CSSM_SIZE,
639 rem_data: CSSM_DATA_PTR,
640 ) -> CSSM_RETURN;
641}
642
643extern "C-unwind" {
644 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
645 #[deprecated]
646 pub fn CSSM_EncryptDataP(
647 cc_handle: CSSM_CC_HANDLE,
648 clear_bufs: *const SecAsn1Item,
649 clear_buf_count: uint32,
650 cipher_bufs: CSSM_DATA_PTR,
651 cipher_buf_count: uint32,
652 bytes_encrypted: *mut CSSM_SIZE,
653 rem_data: CSSM_DATA_PTR,
654 privilege: CSSM_PRIVILEGE,
655 ) -> CSSM_RETURN;
656}
657
658extern "C-unwind" {
659 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
660 #[deprecated]
661 pub fn CSSM_EncryptDataInit(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
662}
663
664extern "C-unwind" {
665 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
666 #[deprecated]
667 pub fn CSSM_EncryptDataInitP(
668 cc_handle: CSSM_CC_HANDLE,
669 privilege: CSSM_PRIVILEGE,
670 ) -> CSSM_RETURN;
671}
672
673extern "C-unwind" {
674 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
675 #[deprecated]
676 pub fn CSSM_EncryptDataUpdate(
677 cc_handle: CSSM_CC_HANDLE,
678 clear_bufs: *const SecAsn1Item,
679 clear_buf_count: uint32,
680 cipher_bufs: CSSM_DATA_PTR,
681 cipher_buf_count: uint32,
682 bytes_encrypted: *mut CSSM_SIZE,
683 ) -> CSSM_RETURN;
684}
685
686extern "C-unwind" {
687 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
688 #[deprecated]
689 pub fn CSSM_EncryptDataFinal(cc_handle: CSSM_CC_HANDLE, rem_data: CSSM_DATA_PTR)
690 -> CSSM_RETURN;
691}
692
693extern "C-unwind" {
694 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
695 #[deprecated]
696 pub fn CSSM_DecryptData(
697 cc_handle: CSSM_CC_HANDLE,
698 cipher_bufs: *const SecAsn1Item,
699 cipher_buf_count: uint32,
700 clear_bufs: CSSM_DATA_PTR,
701 clear_buf_count: uint32,
702 bytes_decrypted: *mut CSSM_SIZE,
703 rem_data: CSSM_DATA_PTR,
704 ) -> CSSM_RETURN;
705}
706
707extern "C-unwind" {
708 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
709 #[deprecated]
710 pub fn CSSM_DecryptDataP(
711 cc_handle: CSSM_CC_HANDLE,
712 cipher_bufs: *const SecAsn1Item,
713 cipher_buf_count: uint32,
714 clear_bufs: CSSM_DATA_PTR,
715 clear_buf_count: uint32,
716 bytes_decrypted: *mut CSSM_SIZE,
717 rem_data: CSSM_DATA_PTR,
718 privilege: CSSM_PRIVILEGE,
719 ) -> CSSM_RETURN;
720}
721
722extern "C-unwind" {
723 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
724 #[deprecated]
725 pub fn CSSM_DecryptDataInit(cc_handle: CSSM_CC_HANDLE) -> CSSM_RETURN;
726}
727
728extern "C-unwind" {
729 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
730 #[deprecated]
731 pub fn CSSM_DecryptDataInitP(
732 cc_handle: CSSM_CC_HANDLE,
733 privilege: CSSM_PRIVILEGE,
734 ) -> CSSM_RETURN;
735}
736
737extern "C-unwind" {
738 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
739 #[deprecated]
740 pub fn CSSM_DecryptDataUpdate(
741 cc_handle: CSSM_CC_HANDLE,
742 cipher_bufs: *const SecAsn1Item,
743 cipher_buf_count: uint32,
744 clear_bufs: CSSM_DATA_PTR,
745 clear_buf_count: uint32,
746 bytes_decrypted: *mut CSSM_SIZE,
747 ) -> CSSM_RETURN;
748}
749
750extern "C-unwind" {
751 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
752 #[deprecated]
753 pub fn CSSM_DecryptDataFinal(cc_handle: CSSM_CC_HANDLE, rem_data: CSSM_DATA_PTR)
754 -> CSSM_RETURN;
755}
756
757extern "C-unwind" {
758 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
759 #[deprecated]
760 pub fn CSSM_QueryKeySizeInBits(
761 csp_handle: CSSM_CSP_HANDLE,
762 cc_handle: CSSM_CC_HANDLE,
763 key: *const CSSM_KEY,
764 key_size: CSSM_KEY_SIZE_PTR,
765 ) -> CSSM_RETURN;
766}
767
768extern "C-unwind" {
769 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
770 #[deprecated]
771 pub fn CSSM_GenerateKey(
772 cc_handle: CSSM_CC_HANDLE,
773 key_usage: uint32,
774 key_attr: uint32,
775 key_label: *const SecAsn1Item,
776 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
777 key: CSSM_KEY_PTR,
778 ) -> CSSM_RETURN;
779}
780
781extern "C-unwind" {
782 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
783 #[deprecated]
784 pub fn CSSM_GenerateKeyP(
785 cc_handle: CSSM_CC_HANDLE,
786 key_usage: uint32,
787 key_attr: uint32,
788 key_label: *const SecAsn1Item,
789 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
790 key: CSSM_KEY_PTR,
791 privilege: CSSM_PRIVILEGE,
792 ) -> CSSM_RETURN;
793}
794
795extern "C-unwind" {
796 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
797 #[deprecated]
798 pub fn CSSM_GenerateKeyPair(
799 cc_handle: CSSM_CC_HANDLE,
800 public_key_usage: uint32,
801 public_key_attr: uint32,
802 public_key_label: *const SecAsn1Item,
803 public_key: CSSM_KEY_PTR,
804 private_key_usage: uint32,
805 private_key_attr: uint32,
806 private_key_label: *const SecAsn1Item,
807 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
808 private_key: CSSM_KEY_PTR,
809 ) -> CSSM_RETURN;
810}
811
812extern "C-unwind" {
813 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
814 #[deprecated]
815 pub fn CSSM_GenerateKeyPairP(
816 cc_handle: CSSM_CC_HANDLE,
817 public_key_usage: uint32,
818 public_key_attr: uint32,
819 public_key_label: *const SecAsn1Item,
820 public_key: CSSM_KEY_PTR,
821 private_key_usage: uint32,
822 private_key_attr: uint32,
823 private_key_label: *const SecAsn1Item,
824 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
825 private_key: CSSM_KEY_PTR,
826 privilege: CSSM_PRIVILEGE,
827 ) -> CSSM_RETURN;
828}
829
830extern "C-unwind" {
831 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
832 #[deprecated]
833 pub fn CSSM_GenerateRandom(
834 cc_handle: CSSM_CC_HANDLE,
835 random_number: CSSM_DATA_PTR,
836 ) -> CSSM_RETURN;
837}
838
839extern "C-unwind" {
840 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
841 #[deprecated]
842 pub fn CSSM_CSP_ObtainPrivateKeyFromPublicKey(
843 csp_handle: CSSM_CSP_HANDLE,
844 public_key: *const CSSM_KEY,
845 private_key: CSSM_KEY_PTR,
846 ) -> CSSM_RETURN;
847}
848
849extern "C-unwind" {
850 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
851 #[deprecated]
852 pub fn CSSM_WrapKey(
853 cc_handle: CSSM_CC_HANDLE,
854 access_cred: *const CSSM_ACCESS_CREDENTIALS,
855 key: *const CSSM_KEY,
856 descriptive_data: *const SecAsn1Item,
857 wrapped_key: CSSM_WRAP_KEY_PTR,
858 ) -> CSSM_RETURN;
859}
860
861extern "C-unwind" {
862 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
863 #[deprecated]
864 pub fn CSSM_UnwrapKey(
865 cc_handle: CSSM_CC_HANDLE,
866 public_key: *const CSSM_KEY,
867 wrapped_key: *const CSSM_WRAP_KEY,
868 key_usage: uint32,
869 key_attr: uint32,
870 key_label: *const SecAsn1Item,
871 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
872 unwrapped_key: CSSM_KEY_PTR,
873 descriptive_data: CSSM_DATA_PTR,
874 ) -> CSSM_RETURN;
875}
876
877extern "C-unwind" {
878 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
879 #[deprecated]
880 pub fn CSSM_WrapKeyP(
881 cc_handle: CSSM_CC_HANDLE,
882 access_cred: *const CSSM_ACCESS_CREDENTIALS,
883 key: *const CSSM_KEY,
884 descriptive_data: *const SecAsn1Item,
885 wrapped_key: CSSM_WRAP_KEY_PTR,
886 privilege: CSSM_PRIVILEGE,
887 ) -> CSSM_RETURN;
888}
889
890extern "C-unwind" {
891 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
892 #[deprecated]
893 pub fn CSSM_UnwrapKeyP(
894 cc_handle: CSSM_CC_HANDLE,
895 public_key: *const CSSM_KEY,
896 wrapped_key: *const CSSM_WRAP_KEY,
897 key_usage: uint32,
898 key_attr: uint32,
899 key_label: *const SecAsn1Item,
900 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
901 unwrapped_key: CSSM_KEY_PTR,
902 descriptive_data: CSSM_DATA_PTR,
903 privilege: CSSM_PRIVILEGE,
904 ) -> CSSM_RETURN;
905}
906
907extern "C-unwind" {
908 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
909 #[deprecated]
910 pub fn CSSM_DeriveKey(
911 cc_handle: CSSM_CC_HANDLE,
912 param: CSSM_DATA_PTR,
913 key_usage: uint32,
914 key_attr: uint32,
915 key_label: *const SecAsn1Item,
916 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
917 derived_key: CSSM_KEY_PTR,
918 ) -> CSSM_RETURN;
919}
920
921extern "C-unwind" {
922 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
923 #[deprecated]
924 pub fn CSSM_FreeKey(
925 csp_handle: CSSM_CSP_HANDLE,
926 access_cred: *const CSSM_ACCESS_CREDENTIALS,
927 key_ptr: CSSM_KEY_PTR,
928 delete: CSSM_BOOL,
929 ) -> CSSM_RETURN;
930}
931
932extern "C-unwind" {
933 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
934 #[deprecated]
935 pub fn CSSM_GenerateAlgorithmParams(
936 cc_handle: CSSM_CC_HANDLE,
937 param_bits: uint32,
938 param: CSSM_DATA_PTR,
939 ) -> CSSM_RETURN;
940}
941
942extern "C-unwind" {
943 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
944 #[deprecated]
945 pub fn CSSM_CSP_GetOperationalStatistics(
946 csp_handle: CSSM_CSP_HANDLE,
947 statistics: *mut CSSM_CSP_OPERATIONAL_STATISTICS,
948 ) -> CSSM_RETURN;
949}
950
951extern "C-unwind" {
952 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
953 #[deprecated]
954 pub fn CSSM_GetTimeValue(
955 csp_handle: CSSM_CSP_HANDLE,
956 time_algorithm: CSSM_ALGORITHMS,
957 time_data: *mut SecAsn1Item,
958 ) -> CSSM_RETURN;
959}
960
961extern "C-unwind" {
962 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
963 #[deprecated]
964 pub fn CSSM_RetrieveUniqueId(
965 csp_handle: CSSM_CSP_HANDLE,
966 unique_id: CSSM_DATA_PTR,
967 ) -> CSSM_RETURN;
968}
969
970extern "C-unwind" {
971 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
972 #[deprecated]
973 pub fn CSSM_RetrieveCounter(csp_handle: CSSM_CSP_HANDLE, counter: CSSM_DATA_PTR)
974 -> CSSM_RETURN;
975}
976
977extern "C-unwind" {
978 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
979 #[deprecated]
980 pub fn CSSM_VerifyDevice(
981 csp_handle: CSSM_CSP_HANDLE,
982 device_cert: *const SecAsn1Item,
983 ) -> CSSM_RETURN;
984}
985
986extern "C-unwind" {
987 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
988 #[deprecated]
989 pub fn CSSM_CSP_PassThrough(
990 cc_handle: CSSM_CC_HANDLE,
991 pass_through_id: uint32,
992 in_data: *const c_void,
993 out_data: *mut *mut c_void,
994 ) -> CSSM_RETURN;
995}
996
997extern "C-unwind" {
998 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
999 #[deprecated]
1000 pub fn CSSM_TP_SubmitCredRequest(
1001 tp_handle: CSSM_TP_HANDLE,
1002 preferred_authority: *const CSSM_TP_AUTHORITY_ID,
1003 request_type: CSSM_TP_AUTHORITY_REQUEST_TYPE,
1004 request_input: *const CSSM_TP_REQUEST_SET,
1005 caller_auth_context: *const CSSM_TP_CALLERAUTH_CONTEXT,
1006 estimated_time: *mut sint32,
1007 reference_identifier: CSSM_DATA_PTR,
1008 ) -> CSSM_RETURN;
1009}
1010
1011extern "C-unwind" {
1012 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1013 #[deprecated]
1014 pub fn CSSM_TP_RetrieveCredResult(
1015 tp_handle: CSSM_TP_HANDLE,
1016 reference_identifier: *const SecAsn1Item,
1017 caller_auth_credentials: *const CSSM_TP_CALLERAUTH_CONTEXT,
1018 estimated_time: *mut sint32,
1019 confirmation_required: *mut CSSM_BOOL,
1020 retrieve_output: *mut CSSM_TP_RESULT_SET_PTR,
1021 ) -> CSSM_RETURN;
1022}
1023
1024extern "C-unwind" {
1025 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1026 #[deprecated]
1027 pub fn CSSM_TP_ConfirmCredResult(
1028 tp_handle: CSSM_TP_HANDLE,
1029 reference_identifier: *const SecAsn1Item,
1030 caller_auth_credentials: *const CSSM_TP_CALLERAUTH_CONTEXT,
1031 responses: *const CSSM_TP_CONFIRM_RESPONSE,
1032 preferred_authority: *const CSSM_TP_AUTHORITY_ID,
1033 ) -> CSSM_RETURN;
1034}
1035
1036extern "C-unwind" {
1037 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1038 #[deprecated]
1039 pub fn CSSM_TP_ReceiveConfirmation(
1040 tp_handle: CSSM_TP_HANDLE,
1041 reference_identifier: *const SecAsn1Item,
1042 responses: *mut CSSM_TP_CONFIRM_RESPONSE_PTR,
1043 elapsed_time: *mut sint32,
1044 ) -> CSSM_RETURN;
1045}
1046
1047extern "C-unwind" {
1048 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1049 #[deprecated]
1050 pub fn CSSM_TP_CertReclaimKey(
1051 tp_handle: CSSM_TP_HANDLE,
1052 cert_group: *const CSSM_CERTGROUP,
1053 cert_index: uint32,
1054 key_cache_handle: CSSM_LONG_HANDLE,
1055 csp_handle: CSSM_CSP_HANDLE,
1056 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
1057 ) -> CSSM_RETURN;
1058}
1059
1060extern "C-unwind" {
1061 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1062 #[deprecated]
1063 pub fn CSSM_TP_CertReclaimAbort(
1064 tp_handle: CSSM_TP_HANDLE,
1065 key_cache_handle: CSSM_LONG_HANDLE,
1066 ) -> CSSM_RETURN;
1067}
1068
1069extern "C-unwind" {
1070 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1071 #[deprecated]
1072 pub fn CSSM_TP_FormRequest(
1073 tp_handle: CSSM_TP_HANDLE,
1074 preferred_authority: *const CSSM_TP_AUTHORITY_ID,
1075 form_type: CSSM_TP_FORM_TYPE,
1076 blank_form: CSSM_DATA_PTR,
1077 ) -> CSSM_RETURN;
1078}
1079
1080extern "C-unwind" {
1081 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1082 #[deprecated]
1083 pub fn CSSM_TP_FormSubmit(
1084 tp_handle: CSSM_TP_HANDLE,
1085 form_type: CSSM_TP_FORM_TYPE,
1086 form: *const SecAsn1Item,
1087 clearance_authority: *const CSSM_TP_AUTHORITY_ID,
1088 represented_authority: *const CSSM_TP_AUTHORITY_ID,
1089 credentials: CSSM_ACCESS_CREDENTIALS_PTR,
1090 ) -> CSSM_RETURN;
1091}
1092
1093extern "C-unwind" {
1094 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1095 #[deprecated]
1096 pub fn CSSM_TP_CertGroupVerify(
1097 tp_handle: CSSM_TP_HANDLE,
1098 cl_handle: CSSM_CL_HANDLE,
1099 csp_handle: CSSM_CSP_HANDLE,
1100 cert_group_to_be_verified: *const CSSM_CERTGROUP,
1101 verify_context: *const CSSM_TP_VERIFY_CONTEXT,
1102 verify_context_result: CSSM_TP_VERIFY_CONTEXT_RESULT_PTR,
1103 ) -> CSSM_RETURN;
1104}
1105
1106extern "C-unwind" {
1107 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1108 #[deprecated]
1109 pub fn CSSM_TP_CertCreateTemplate(
1110 tp_handle: CSSM_TP_HANDLE,
1111 cl_handle: CSSM_CL_HANDLE,
1112 number_of_fields: uint32,
1113 cert_fields: *const CSSM_FIELD,
1114 cert_template: CSSM_DATA_PTR,
1115 ) -> CSSM_RETURN;
1116}
1117
1118extern "C-unwind" {
1119 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1120 #[deprecated]
1121 pub fn CSSM_TP_CertGetAllTemplateFields(
1122 tp_handle: CSSM_TP_HANDLE,
1123 cl_handle: CSSM_CL_HANDLE,
1124 cert_template: *const SecAsn1Item,
1125 number_of_fields: *mut uint32,
1126 cert_fields: *mut CSSM_FIELD_PTR,
1127 ) -> CSSM_RETURN;
1128}
1129
1130extern "C-unwind" {
1131 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1132 #[deprecated]
1133 pub fn CSSM_TP_CertSign(
1134 tp_handle: CSSM_TP_HANDLE,
1135 cl_handle: CSSM_CL_HANDLE,
1136 cc_handle: CSSM_CC_HANDLE,
1137 cert_template_to_be_signed: *const SecAsn1Item,
1138 signer_cert_group: *const CSSM_CERTGROUP,
1139 signer_verify_context: *const CSSM_TP_VERIFY_CONTEXT,
1140 signer_verify_result: CSSM_TP_VERIFY_CONTEXT_RESULT_PTR,
1141 signed_cert: CSSM_DATA_PTR,
1142 ) -> CSSM_RETURN;
1143}
1144
1145extern "C-unwind" {
1146 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1147 #[deprecated]
1148 pub fn CSSM_TP_CrlVerify(
1149 tp_handle: CSSM_TP_HANDLE,
1150 cl_handle: CSSM_CL_HANDLE,
1151 csp_handle: CSSM_CSP_HANDLE,
1152 crl_to_be_verified: *const CSSM_ENCODED_CRL,
1153 signer_cert_group: *const CSSM_CERTGROUP,
1154 verify_context: *const CSSM_TP_VERIFY_CONTEXT,
1155 revoker_verify_result: CSSM_TP_VERIFY_CONTEXT_RESULT_PTR,
1156 ) -> CSSM_RETURN;
1157}
1158
1159extern "C-unwind" {
1160 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1161 #[deprecated]
1162 pub fn CSSM_TP_CrlCreateTemplate(
1163 tp_handle: CSSM_TP_HANDLE,
1164 cl_handle: CSSM_CL_HANDLE,
1165 number_of_fields: uint32,
1166 crl_fields: *const CSSM_FIELD,
1167 new_crl_template: CSSM_DATA_PTR,
1168 ) -> CSSM_RETURN;
1169}
1170
1171extern "C-unwind" {
1172 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1173 #[deprecated]
1174 pub fn CSSM_TP_CertRevoke(
1175 tp_handle: CSSM_TP_HANDLE,
1176 cl_handle: CSSM_CL_HANDLE,
1177 csp_handle: CSSM_CSP_HANDLE,
1178 old_crl_template: *const SecAsn1Item,
1179 cert_group_to_be_revoked: *const CSSM_CERTGROUP,
1180 revoker_cert_group: *const CSSM_CERTGROUP,
1181 revoker_verify_context: *const CSSM_TP_VERIFY_CONTEXT,
1182 revoker_verify_result: CSSM_TP_VERIFY_CONTEXT_RESULT_PTR,
1183 reason: CSSM_TP_CERTCHANGE_REASON,
1184 new_crl_template: CSSM_DATA_PTR,
1185 ) -> CSSM_RETURN;
1186}
1187
1188extern "C-unwind" {
1189 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1190 #[deprecated]
1191 pub fn CSSM_TP_CertRemoveFromCrlTemplate(
1192 tp_handle: CSSM_TP_HANDLE,
1193 cl_handle: CSSM_CL_HANDLE,
1194 csp_handle: CSSM_CSP_HANDLE,
1195 old_crl_template: *const SecAsn1Item,
1196 cert_group_to_be_removed: *const CSSM_CERTGROUP,
1197 revoker_cert_group: *const CSSM_CERTGROUP,
1198 revoker_verify_context: *const CSSM_TP_VERIFY_CONTEXT,
1199 revoker_verify_result: CSSM_TP_VERIFY_CONTEXT_RESULT_PTR,
1200 new_crl_template: CSSM_DATA_PTR,
1201 ) -> CSSM_RETURN;
1202}
1203
1204extern "C-unwind" {
1205 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1206 #[deprecated]
1207 pub fn CSSM_TP_CrlSign(
1208 tp_handle: CSSM_TP_HANDLE,
1209 cl_handle: CSSM_CL_HANDLE,
1210 cc_handle: CSSM_CC_HANDLE,
1211 crl_to_be_signed: *const CSSM_ENCODED_CRL,
1212 signer_cert_group: *const CSSM_CERTGROUP,
1213 signer_verify_context: *const CSSM_TP_VERIFY_CONTEXT,
1214 signer_verify_result: CSSM_TP_VERIFY_CONTEXT_RESULT_PTR,
1215 signed_crl: CSSM_DATA_PTR,
1216 ) -> CSSM_RETURN;
1217}
1218
1219extern "C-unwind" {
1220 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1221 #[deprecated]
1222 pub fn CSSM_TP_ApplyCrlToDb(
1223 tp_handle: CSSM_TP_HANDLE,
1224 cl_handle: CSSM_CL_HANDLE,
1225 csp_handle: CSSM_CSP_HANDLE,
1226 crl_to_be_applied: *const CSSM_ENCODED_CRL,
1227 signer_cert_group: *const CSSM_CERTGROUP,
1228 apply_crl_verify_context: *const CSSM_TP_VERIFY_CONTEXT,
1229 apply_crl_verify_result: CSSM_TP_VERIFY_CONTEXT_RESULT_PTR,
1230 ) -> CSSM_RETURN;
1231}
1232
1233extern "C-unwind" {
1234 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1235 #[deprecated]
1236 pub fn CSSM_TP_CertGroupConstruct(
1237 tp_handle: CSSM_TP_HANDLE,
1238 cl_handle: CSSM_CL_HANDLE,
1239 csp_handle: CSSM_CSP_HANDLE,
1240 db_list: *const CSSM_DL_DB_LIST,
1241 construct_params: *const c_void,
1242 cert_group_frag: *const CSSM_CERTGROUP,
1243 cert_group: *mut CSSM_CERTGROUP_PTR,
1244 ) -> CSSM_RETURN;
1245}
1246
1247extern "C-unwind" {
1248 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1249 #[deprecated]
1250 pub fn CSSM_TP_CertGroupPrune(
1251 tp_handle: CSSM_TP_HANDLE,
1252 cl_handle: CSSM_CL_HANDLE,
1253 db_list: *const CSSM_DL_DB_LIST,
1254 ordered_cert_group: *const CSSM_CERTGROUP,
1255 pruned_cert_group: *mut CSSM_CERTGROUP_PTR,
1256 ) -> CSSM_RETURN;
1257}
1258
1259extern "C-unwind" {
1260 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1261 #[deprecated]
1262 pub fn CSSM_TP_CertGroupToTupleGroup(
1263 tp_handle: CSSM_TP_HANDLE,
1264 cl_handle: CSSM_CL_HANDLE,
1265 cert_group: *const CSSM_CERTGROUP,
1266 tuple_group: *mut CSSM_TUPLEGROUP_PTR,
1267 ) -> CSSM_RETURN;
1268}
1269
1270extern "C-unwind" {
1271 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1272 #[deprecated]
1273 pub fn CSSM_TP_TupleGroupToCertGroup(
1274 tp_handle: CSSM_TP_HANDLE,
1275 cl_handle: CSSM_CL_HANDLE,
1276 tuple_group: *const CSSM_TUPLEGROUP,
1277 cert_templates: *mut CSSM_CERTGROUP_PTR,
1278 ) -> CSSM_RETURN;
1279}
1280
1281extern "C-unwind" {
1282 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1283 #[deprecated]
1284 pub fn CSSM_TP_PassThrough(
1285 tp_handle: CSSM_TP_HANDLE,
1286 cl_handle: CSSM_CL_HANDLE,
1287 cc_handle: CSSM_CC_HANDLE,
1288 db_list: *const CSSM_DL_DB_LIST,
1289 pass_through_id: uint32,
1290 input_params: *const c_void,
1291 output_params: *mut *mut c_void,
1292 ) -> CSSM_RETURN;
1293}
1294
1295extern "C-unwind" {
1296 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1297 #[deprecated]
1298 pub fn CSSM_AC_AuthCompute(
1299 ac_handle: CSSM_AC_HANDLE,
1300 base_authorizations: *const CSSM_TUPLEGROUP,
1301 credentials: *const CSSM_TUPLEGROUP,
1302 number_of_requestors: uint32,
1303 requestors: *const CSSM_LIST,
1304 requested_authorization_period: *const CSSM_LIST,
1305 requested_authorization: *const CSSM_LIST,
1306 authorization_result: CSSM_TUPLEGROUP_PTR,
1307 ) -> CSSM_RETURN;
1308}
1309
1310extern "C-unwind" {
1311 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1312 #[deprecated]
1313 pub fn CSSM_AC_PassThrough(
1314 ac_handle: CSSM_AC_HANDLE,
1315 tp_handle: CSSM_TP_HANDLE,
1316 cl_handle: CSSM_CL_HANDLE,
1317 cc_handle: CSSM_CC_HANDLE,
1318 db_list: *const CSSM_DL_DB_LIST,
1319 pass_through_id: uint32,
1320 input_params: *const c_void,
1321 output_params: *mut *mut c_void,
1322 ) -> CSSM_RETURN;
1323}
1324
1325extern "C-unwind" {
1326 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1327 #[deprecated]
1328 pub fn CSSM_CL_CertCreateTemplate(
1329 cl_handle: CSSM_CL_HANDLE,
1330 number_of_fields: uint32,
1331 cert_fields: *const CSSM_FIELD,
1332 cert_template: CSSM_DATA_PTR,
1333 ) -> CSSM_RETURN;
1334}
1335
1336extern "C-unwind" {
1337 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1338 #[deprecated]
1339 pub fn CSSM_CL_CertGetAllTemplateFields(
1340 cl_handle: CSSM_CL_HANDLE,
1341 cert_template: *const SecAsn1Item,
1342 number_of_fields: *mut uint32,
1343 cert_fields: *mut CSSM_FIELD_PTR,
1344 ) -> CSSM_RETURN;
1345}
1346
1347extern "C-unwind" {
1348 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1349 #[deprecated]
1350 pub fn CSSM_CL_CertSign(
1351 cl_handle: CSSM_CL_HANDLE,
1352 cc_handle: CSSM_CC_HANDLE,
1353 cert_template: *const SecAsn1Item,
1354 sign_scope: *const CSSM_FIELD,
1355 scope_size: uint32,
1356 signed_cert: CSSM_DATA_PTR,
1357 ) -> CSSM_RETURN;
1358}
1359
1360extern "C-unwind" {
1361 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1362 #[deprecated]
1363 pub fn CSSM_CL_CertVerify(
1364 cl_handle: CSSM_CL_HANDLE,
1365 cc_handle: CSSM_CC_HANDLE,
1366 cert_to_be_verified: *const SecAsn1Item,
1367 signer_cert: *const SecAsn1Item,
1368 verify_scope: *const CSSM_FIELD,
1369 scope_size: uint32,
1370 ) -> CSSM_RETURN;
1371}
1372
1373extern "C-unwind" {
1374 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1375 #[deprecated]
1376 pub fn CSSM_CL_CertVerifyWithKey(
1377 cl_handle: CSSM_CL_HANDLE,
1378 cc_handle: CSSM_CC_HANDLE,
1379 cert_to_be_verified: *const SecAsn1Item,
1380 ) -> CSSM_RETURN;
1381}
1382
1383extern "C-unwind" {
1384 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1385 #[deprecated]
1386 pub fn CSSM_CL_CertGetFirstFieldValue(
1387 cl_handle: CSSM_CL_HANDLE,
1388 cert: *const SecAsn1Item,
1389 cert_field: *const SecAsn1Oid,
1390 results_handle: CSSM_HANDLE_PTR,
1391 number_of_matched_fields: *mut uint32,
1392 value: *mut CSSM_DATA_PTR,
1393 ) -> CSSM_RETURN;
1394}
1395
1396extern "C-unwind" {
1397 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1398 #[deprecated]
1399 pub fn CSSM_CL_CertGetNextFieldValue(
1400 cl_handle: CSSM_CL_HANDLE,
1401 results_handle: CSSM_HANDLE,
1402 value: *mut CSSM_DATA_PTR,
1403 ) -> CSSM_RETURN;
1404}
1405
1406extern "C-unwind" {
1407 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1408 #[deprecated]
1409 pub fn CSSM_CL_CertAbortQuery(
1410 cl_handle: CSSM_CL_HANDLE,
1411 results_handle: CSSM_HANDLE,
1412 ) -> CSSM_RETURN;
1413}
1414
1415extern "C-unwind" {
1416 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1417 #[deprecated]
1418 pub fn CSSM_CL_CertGetKeyInfo(
1419 cl_handle: CSSM_CL_HANDLE,
1420 cert: *const SecAsn1Item,
1421 key: *mut CSSM_KEY_PTR,
1422 ) -> CSSM_RETURN;
1423}
1424
1425extern "C-unwind" {
1426 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1427 #[deprecated]
1428 pub fn CSSM_CL_CertGetAllFields(
1429 cl_handle: CSSM_CL_HANDLE,
1430 cert: *const SecAsn1Item,
1431 number_of_fields: *mut uint32,
1432 cert_fields: *mut CSSM_FIELD_PTR,
1433 ) -> CSSM_RETURN;
1434}
1435
1436extern "C-unwind" {
1437 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1438 #[deprecated]
1439 pub fn CSSM_CL_FreeFields(
1440 cl_handle: CSSM_CL_HANDLE,
1441 number_of_fields: uint32,
1442 fields: *mut CSSM_FIELD_PTR,
1443 ) -> CSSM_RETURN;
1444}
1445
1446extern "C-unwind" {
1447 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1448 #[deprecated]
1449 pub fn CSSM_CL_FreeFieldValue(
1450 cl_handle: CSSM_CL_HANDLE,
1451 cert_or_crl_oid: *const SecAsn1Oid,
1452 value: CSSM_DATA_PTR,
1453 ) -> CSSM_RETURN;
1454}
1455
1456extern "C-unwind" {
1457 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1458 #[deprecated]
1459 pub fn CSSM_CL_CertCache(
1460 cl_handle: CSSM_CL_HANDLE,
1461 cert: *const SecAsn1Item,
1462 cert_handle: CSSM_HANDLE_PTR,
1463 ) -> CSSM_RETURN;
1464}
1465
1466extern "C-unwind" {
1467 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1468 #[deprecated]
1469 pub fn CSSM_CL_CertGetFirstCachedFieldValue(
1470 cl_handle: CSSM_CL_HANDLE,
1471 cert_handle: CSSM_HANDLE,
1472 cert_field: *const SecAsn1Oid,
1473 results_handle: CSSM_HANDLE_PTR,
1474 number_of_matched_fields: *mut uint32,
1475 value: *mut CSSM_DATA_PTR,
1476 ) -> CSSM_RETURN;
1477}
1478
1479extern "C-unwind" {
1480 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1481 #[deprecated]
1482 pub fn CSSM_CL_CertGetNextCachedFieldValue(
1483 cl_handle: CSSM_CL_HANDLE,
1484 results_handle: CSSM_HANDLE,
1485 value: *mut CSSM_DATA_PTR,
1486 ) -> CSSM_RETURN;
1487}
1488
1489extern "C-unwind" {
1490 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1491 #[deprecated]
1492 pub fn CSSM_CL_CertAbortCache(
1493 cl_handle: CSSM_CL_HANDLE,
1494 cert_handle: CSSM_HANDLE,
1495 ) -> CSSM_RETURN;
1496}
1497
1498extern "C-unwind" {
1499 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1500 #[deprecated]
1501 pub fn CSSM_CL_CertGroupToSignedBundle(
1502 cl_handle: CSSM_CL_HANDLE,
1503 cc_handle: CSSM_CC_HANDLE,
1504 cert_group_to_bundle: *const CSSM_CERTGROUP,
1505 bundle_info: *const CSSM_CERT_BUNDLE_HEADER,
1506 signed_bundle: CSSM_DATA_PTR,
1507 ) -> CSSM_RETURN;
1508}
1509
1510extern "C-unwind" {
1511 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1512 #[deprecated]
1513 pub fn CSSM_CL_CertGroupFromVerifiedBundle(
1514 cl_handle: CSSM_CL_HANDLE,
1515 cc_handle: CSSM_CC_HANDLE,
1516 cert_bundle: *const CSSM_CERT_BUNDLE,
1517 signer_cert: *const SecAsn1Item,
1518 cert_group: *mut CSSM_CERTGROUP_PTR,
1519 ) -> CSSM_RETURN;
1520}
1521
1522extern "C-unwind" {
1523 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1524 #[deprecated]
1525 pub fn CSSM_CL_CertDescribeFormat(
1526 cl_handle: CSSM_CL_HANDLE,
1527 number_of_fields: *mut uint32,
1528 oid_list: *mut CSSM_OID_PTR,
1529 ) -> CSSM_RETURN;
1530}
1531
1532extern "C-unwind" {
1533 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1534 #[deprecated]
1535 pub fn CSSM_CL_CrlCreateTemplate(
1536 cl_handle: CSSM_CL_HANDLE,
1537 number_of_fields: uint32,
1538 crl_template: *const CSSM_FIELD,
1539 new_crl: CSSM_DATA_PTR,
1540 ) -> CSSM_RETURN;
1541}
1542
1543extern "C-unwind" {
1544 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1545 #[deprecated]
1546 pub fn CSSM_CL_CrlSetFields(
1547 cl_handle: CSSM_CL_HANDLE,
1548 number_of_fields: uint32,
1549 crl_template: *const CSSM_FIELD,
1550 old_crl: *const SecAsn1Item,
1551 modified_crl: CSSM_DATA_PTR,
1552 ) -> CSSM_RETURN;
1553}
1554
1555extern "C-unwind" {
1556 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1557 #[deprecated]
1558 pub fn CSSM_CL_CrlAddCert(
1559 cl_handle: CSSM_CL_HANDLE,
1560 cc_handle: CSSM_CC_HANDLE,
1561 cert: *const SecAsn1Item,
1562 number_of_fields: uint32,
1563 crl_entry_fields: *const CSSM_FIELD,
1564 old_crl: *const SecAsn1Item,
1565 new_crl: CSSM_DATA_PTR,
1566 ) -> CSSM_RETURN;
1567}
1568
1569extern "C-unwind" {
1570 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1571 #[deprecated]
1572 pub fn CSSM_CL_CrlRemoveCert(
1573 cl_handle: CSSM_CL_HANDLE,
1574 cert: *const SecAsn1Item,
1575 old_crl: *const SecAsn1Item,
1576 new_crl: CSSM_DATA_PTR,
1577 ) -> CSSM_RETURN;
1578}
1579
1580extern "C-unwind" {
1581 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1582 #[deprecated]
1583 pub fn CSSM_CL_CrlSign(
1584 cl_handle: CSSM_CL_HANDLE,
1585 cc_handle: CSSM_CC_HANDLE,
1586 unsigned_crl: *const SecAsn1Item,
1587 sign_scope: *const CSSM_FIELD,
1588 scope_size: uint32,
1589 signed_crl: CSSM_DATA_PTR,
1590 ) -> CSSM_RETURN;
1591}
1592
1593extern "C-unwind" {
1594 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1595 #[deprecated]
1596 pub fn CSSM_CL_CrlVerify(
1597 cl_handle: CSSM_CL_HANDLE,
1598 cc_handle: CSSM_CC_HANDLE,
1599 crl_to_be_verified: *const SecAsn1Item,
1600 signer_cert: *const SecAsn1Item,
1601 verify_scope: *const CSSM_FIELD,
1602 scope_size: uint32,
1603 ) -> CSSM_RETURN;
1604}
1605
1606extern "C-unwind" {
1607 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1608 #[deprecated]
1609 pub fn CSSM_CL_CrlVerifyWithKey(
1610 cl_handle: CSSM_CL_HANDLE,
1611 cc_handle: CSSM_CC_HANDLE,
1612 crl_to_be_verified: *const SecAsn1Item,
1613 ) -> CSSM_RETURN;
1614}
1615
1616extern "C-unwind" {
1617 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1618 #[deprecated]
1619 pub fn CSSM_CL_IsCertInCrl(
1620 cl_handle: CSSM_CL_HANDLE,
1621 cert: *const SecAsn1Item,
1622 crl: *const SecAsn1Item,
1623 cert_found: *mut CSSM_BOOL,
1624 ) -> CSSM_RETURN;
1625}
1626
1627extern "C-unwind" {
1628 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1629 #[deprecated]
1630 pub fn CSSM_CL_CrlGetFirstFieldValue(
1631 cl_handle: CSSM_CL_HANDLE,
1632 crl: *const SecAsn1Item,
1633 crl_field: *const SecAsn1Oid,
1634 results_handle: CSSM_HANDLE_PTR,
1635 number_of_matched_fields: *mut uint32,
1636 value: *mut CSSM_DATA_PTR,
1637 ) -> CSSM_RETURN;
1638}
1639
1640extern "C-unwind" {
1641 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1642 #[deprecated]
1643 pub fn CSSM_CL_CrlGetNextFieldValue(
1644 cl_handle: CSSM_CL_HANDLE,
1645 results_handle: CSSM_HANDLE,
1646 value: *mut CSSM_DATA_PTR,
1647 ) -> CSSM_RETURN;
1648}
1649
1650extern "C-unwind" {
1651 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1652 #[deprecated]
1653 pub fn CSSM_CL_CrlAbortQuery(
1654 cl_handle: CSSM_CL_HANDLE,
1655 results_handle: CSSM_HANDLE,
1656 ) -> CSSM_RETURN;
1657}
1658
1659extern "C-unwind" {
1660 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1661 #[deprecated]
1662 pub fn CSSM_CL_CrlGetAllFields(
1663 cl_handle: CSSM_CL_HANDLE,
1664 crl: *const SecAsn1Item,
1665 number_of_crl_fields: *mut uint32,
1666 crl_fields: *mut CSSM_FIELD_PTR,
1667 ) -> CSSM_RETURN;
1668}
1669
1670extern "C-unwind" {
1671 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1672 #[deprecated]
1673 pub fn CSSM_CL_CrlCache(
1674 cl_handle: CSSM_CL_HANDLE,
1675 crl: *const SecAsn1Item,
1676 crl_handle: CSSM_HANDLE_PTR,
1677 ) -> CSSM_RETURN;
1678}
1679
1680extern "C-unwind" {
1681 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1682 #[deprecated]
1683 pub fn CSSM_CL_IsCertInCachedCrl(
1684 cl_handle: CSSM_CL_HANDLE,
1685 cert: *const SecAsn1Item,
1686 crl_handle: CSSM_HANDLE,
1687 cert_found: *mut CSSM_BOOL,
1688 crl_record_index: CSSM_DATA_PTR,
1689 ) -> CSSM_RETURN;
1690}
1691
1692extern "C-unwind" {
1693 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1694 #[deprecated]
1695 pub fn CSSM_CL_CrlGetFirstCachedFieldValue(
1696 cl_handle: CSSM_CL_HANDLE,
1697 crl_handle: CSSM_HANDLE,
1698 crl_record_index: *const SecAsn1Item,
1699 crl_field: *const SecAsn1Oid,
1700 results_handle: CSSM_HANDLE_PTR,
1701 number_of_matched_fields: *mut uint32,
1702 value: *mut CSSM_DATA_PTR,
1703 ) -> CSSM_RETURN;
1704}
1705
1706extern "C-unwind" {
1707 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1708 #[deprecated]
1709 pub fn CSSM_CL_CrlGetNextCachedFieldValue(
1710 cl_handle: CSSM_CL_HANDLE,
1711 results_handle: CSSM_HANDLE,
1712 value: *mut CSSM_DATA_PTR,
1713 ) -> CSSM_RETURN;
1714}
1715
1716extern "C-unwind" {
1717 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1718 #[deprecated]
1719 pub fn CSSM_CL_CrlGetAllCachedRecordFields(
1720 cl_handle: CSSM_CL_HANDLE,
1721 crl_handle: CSSM_HANDLE,
1722 crl_record_index: *const SecAsn1Item,
1723 number_of_fields: *mut uint32,
1724 crl_fields: *mut CSSM_FIELD_PTR,
1725 ) -> CSSM_RETURN;
1726}
1727
1728extern "C-unwind" {
1729 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1730 #[deprecated]
1731 pub fn CSSM_CL_CrlAbortCache(cl_handle: CSSM_CL_HANDLE, crl_handle: CSSM_HANDLE)
1732 -> CSSM_RETURN;
1733}
1734
1735extern "C-unwind" {
1736 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1737 #[deprecated]
1738 pub fn CSSM_CL_CrlDescribeFormat(
1739 cl_handle: CSSM_CL_HANDLE,
1740 number_of_fields: *mut uint32,
1741 oid_list: *mut CSSM_OID_PTR,
1742 ) -> CSSM_RETURN;
1743}
1744
1745extern "C-unwind" {
1746 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1747 #[deprecated]
1748 pub fn CSSM_CL_PassThrough(
1749 cl_handle: CSSM_CL_HANDLE,
1750 cc_handle: CSSM_CC_HANDLE,
1751 pass_through_id: uint32,
1752 input_params: *const c_void,
1753 output_params: *mut *mut c_void,
1754 ) -> CSSM_RETURN;
1755}
1756
1757extern "C-unwind" {
1758 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1759 #[deprecated]
1760 pub fn CSSM_DL_DbOpen(
1761 dl_handle: CSSM_DL_HANDLE,
1762 db_name: *const c_char,
1763 db_location: *const CSSM_NET_ADDRESS,
1764 access_request: CSSM_DB_ACCESS_TYPE,
1765 access_cred: *const CSSM_ACCESS_CREDENTIALS,
1766 open_parameters: *const c_void,
1767 db_handle: *mut CSSM_DB_HANDLE,
1768 ) -> CSSM_RETURN;
1769}
1770
1771extern "C-unwind" {
1772 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1773 #[deprecated]
1774 pub fn CSSM_DL_DbClose(dldb_handle: CSSM_DL_DB_HANDLE) -> CSSM_RETURN;
1775}
1776
1777extern "C-unwind" {
1778 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1779 #[deprecated]
1780 pub fn CSSM_DL_DbCreate(
1781 dl_handle: CSSM_DL_HANDLE,
1782 db_name: *const c_char,
1783 db_location: *const CSSM_NET_ADDRESS,
1784 db_info: *const CSSM_DBINFO,
1785 access_request: CSSM_DB_ACCESS_TYPE,
1786 cred_and_acl_entry: *const CSSM_RESOURCE_CONTROL_CONTEXT,
1787 open_parameters: *const c_void,
1788 db_handle: *mut CSSM_DB_HANDLE,
1789 ) -> CSSM_RETURN;
1790}
1791
1792extern "C-unwind" {
1793 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1794 #[deprecated]
1795 pub fn CSSM_DL_DbDelete(
1796 dl_handle: CSSM_DL_HANDLE,
1797 db_name: *const c_char,
1798 db_location: *const CSSM_NET_ADDRESS,
1799 access_cred: *const CSSM_ACCESS_CREDENTIALS,
1800 ) -> CSSM_RETURN;
1801}
1802
1803extern "C-unwind" {
1804 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1805 #[deprecated]
1806 pub fn CSSM_DL_CreateRelation(
1807 dldb_handle: CSSM_DL_DB_HANDLE,
1808 relation_id: CSSM_DB_RECORDTYPE,
1809 relation_name: *const c_char,
1810 number_of_attributes: uint32,
1811 p_attribute_info: *const CSSM_DB_SCHEMA_ATTRIBUTE_INFO,
1812 number_of_indexes: uint32,
1813 p_index_info: *const CSSM_DB_SCHEMA_INDEX_INFO,
1814 ) -> CSSM_RETURN;
1815}
1816
1817extern "C-unwind" {
1818 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1819 #[deprecated]
1820 pub fn CSSM_DL_DestroyRelation(
1821 dldb_handle: CSSM_DL_DB_HANDLE,
1822 relation_id: CSSM_DB_RECORDTYPE,
1823 ) -> CSSM_RETURN;
1824}
1825
1826extern "C-unwind" {
1827 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1828 #[deprecated]
1829 pub fn CSSM_DL_Authenticate(
1830 dldb_handle: CSSM_DL_DB_HANDLE,
1831 access_request: CSSM_DB_ACCESS_TYPE,
1832 access_cred: *const CSSM_ACCESS_CREDENTIALS,
1833 ) -> CSSM_RETURN;
1834}
1835
1836extern "C-unwind" {
1837 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1838 #[deprecated]
1839 pub fn CSSM_DL_GetDbAcl(
1840 dldb_handle: CSSM_DL_DB_HANDLE,
1841 selection_tag: *const CSSM_STRING,
1842 number_of_acl_infos: *mut uint32,
1843 acl_infos: *mut CSSM_ACL_ENTRY_INFO_PTR,
1844 ) -> CSSM_RETURN;
1845}
1846
1847extern "C-unwind" {
1848 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1849 #[deprecated]
1850 pub fn CSSM_DL_ChangeDbAcl(
1851 dldb_handle: CSSM_DL_DB_HANDLE,
1852 access_cred: *const CSSM_ACCESS_CREDENTIALS,
1853 acl_edit: *const CSSM_ACL_EDIT,
1854 ) -> CSSM_RETURN;
1855}
1856
1857extern "C-unwind" {
1858 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1859 #[deprecated]
1860 pub fn CSSM_DL_GetDbOwner(
1861 dldb_handle: CSSM_DL_DB_HANDLE,
1862 owner: CSSM_ACL_OWNER_PROTOTYPE_PTR,
1863 ) -> CSSM_RETURN;
1864}
1865
1866extern "C-unwind" {
1867 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1868 #[deprecated]
1869 pub fn CSSM_DL_ChangeDbOwner(
1870 dldb_handle: CSSM_DL_DB_HANDLE,
1871 access_cred: *const CSSM_ACCESS_CREDENTIALS,
1872 new_owner: *const CSSM_ACL_OWNER_PROTOTYPE,
1873 ) -> CSSM_RETURN;
1874}
1875
1876extern "C-unwind" {
1877 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1878 #[deprecated]
1879 pub fn CSSM_DL_GetDbNames(
1880 dl_handle: CSSM_DL_HANDLE,
1881 name_list: *mut CSSM_NAME_LIST_PTR,
1882 ) -> CSSM_RETURN;
1883}
1884
1885extern "C-unwind" {
1886 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1887 #[deprecated]
1888 pub fn CSSM_DL_GetDbNameFromHandle(
1889 dldb_handle: CSSM_DL_DB_HANDLE,
1890 db_name: *mut *mut c_char,
1891 ) -> CSSM_RETURN;
1892}
1893
1894extern "C-unwind" {
1895 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1896 #[deprecated]
1897 pub fn CSSM_DL_FreeNameList(
1898 dl_handle: CSSM_DL_HANDLE,
1899 name_list: CSSM_NAME_LIST_PTR,
1900 ) -> CSSM_RETURN;
1901}
1902
1903extern "C-unwind" {
1904 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1905 #[deprecated]
1906 pub fn CSSM_DL_DataInsert(
1907 dldb_handle: CSSM_DL_DB_HANDLE,
1908 record_type: CSSM_DB_RECORDTYPE,
1909 attributes: *const CSSM_DB_RECORD_ATTRIBUTE_DATA,
1910 data: *const SecAsn1Item,
1911 unique_id: *mut CSSM_DB_UNIQUE_RECORD_PTR,
1912 ) -> CSSM_RETURN;
1913}
1914
1915extern "C-unwind" {
1916 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1917 #[deprecated]
1918 pub fn CSSM_DL_DataDelete(
1919 dldb_handle: CSSM_DL_DB_HANDLE,
1920 unique_record_identifier: *const CSSM_DB_UNIQUE_RECORD,
1921 ) -> CSSM_RETURN;
1922}
1923
1924extern "C-unwind" {
1925 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1926 #[deprecated]
1927 pub fn CSSM_DL_DataModify(
1928 dldb_handle: CSSM_DL_DB_HANDLE,
1929 record_type: CSSM_DB_RECORDTYPE,
1930 unique_record_identifier: CSSM_DB_UNIQUE_RECORD_PTR,
1931 attributes_to_be_modified: *const CSSM_DB_RECORD_ATTRIBUTE_DATA,
1932 data_to_be_modified: *const SecAsn1Item,
1933 modify_mode: CSSM_DB_MODIFY_MODE,
1934 ) -> CSSM_RETURN;
1935}
1936
1937extern "C-unwind" {
1938 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1939 #[deprecated]
1940 pub fn CSSM_DL_DataGetFirst(
1941 dldb_handle: CSSM_DL_DB_HANDLE,
1942 query: *const CSSM_QUERY,
1943 results_handle: CSSM_HANDLE_PTR,
1944 attributes: CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR,
1945 data: CSSM_DATA_PTR,
1946 unique_id: *mut CSSM_DB_UNIQUE_RECORD_PTR,
1947 ) -> CSSM_RETURN;
1948}
1949
1950extern "C-unwind" {
1951 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1952 #[deprecated]
1953 pub fn CSSM_DL_DataGetNext(
1954 dldb_handle: CSSM_DL_DB_HANDLE,
1955 results_handle: CSSM_HANDLE,
1956 attributes: CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR,
1957 data: CSSM_DATA_PTR,
1958 unique_id: *mut CSSM_DB_UNIQUE_RECORD_PTR,
1959 ) -> CSSM_RETURN;
1960}
1961
1962extern "C-unwind" {
1963 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1964 #[deprecated]
1965 pub fn CSSM_DL_DataAbortQuery(
1966 dldb_handle: CSSM_DL_DB_HANDLE,
1967 results_handle: CSSM_HANDLE,
1968 ) -> CSSM_RETURN;
1969}
1970
1971extern "C-unwind" {
1972 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1973 #[deprecated]
1974 pub fn CSSM_DL_DataGetFromUniqueRecordId(
1975 dldb_handle: CSSM_DL_DB_HANDLE,
1976 unique_record: *const CSSM_DB_UNIQUE_RECORD,
1977 attributes: CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR,
1978 data: CSSM_DATA_PTR,
1979 ) -> CSSM_RETURN;
1980}
1981
1982extern "C-unwind" {
1983 #[cfg(all(feature = "SecAsn1Types", feature = "cssmconfig", feature = "cssmtype"))]
1984 #[deprecated]
1985 pub fn CSSM_DL_FreeUniqueRecord(
1986 dldb_handle: CSSM_DL_DB_HANDLE,
1987 unique_record: CSSM_DB_UNIQUE_RECORD_PTR,
1988 ) -> CSSM_RETURN;
1989}
1990
1991extern "C-unwind" {
1992 #[cfg(all(feature = "cssmconfig", feature = "cssmtype"))]
1993 #[deprecated]
1994 pub fn CSSM_DL_PassThrough(
1995 dldb_handle: CSSM_DL_DB_HANDLE,
1996 pass_through_id: uint32,
1997 input_params: *const c_void,
1998 output_params: *mut *mut c_void,
1999 ) -> CSSM_RETURN;
2000}