Debian Codegraph @

src/visibility.c

raw
1 /* visibility.c - Wrapper for all public functions
2 * Copyright (C) 2008, 2012 g10 Code GmbH
3 *
4 * This file is part of KSBA.
5 *
6 * KSBA is free software; you can redistribute it and/or modify
7 * it under the terms of either
8 *
9 * - the GNU Lesser General Public License as published by the Free
10 * Software Foundation; either version 3 of the License, or (at
11 * your option) any later version.
12 *
13 * or
14 *
15 * - the GNU General Public License as published by the Free
16 * Software Foundation; either version 2 of the License, or (at
17 * your option) any later version.
18 *
19 * or both in parallel, as here.
20 *
21 * KSBA is distributed in the hope that it will be useful, but WITHOUT
22 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
23 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
24 * License for more details.
25 *
26 * You should have received a copies of the GNU General Public License
27 * and the GNU Lesser General Public License along with this program;
28 * if not, see <http://www.gnu.org/licenses/>.
29 */
30
31 #include <config.h>
32 #include <stdarg.h>
33
34 #define _KSBA_INCLUDED_BY_VISIBILITY_C
35 #include "util.h"
36
37
38 /*--version.c --*/
39 const char *
40 ksba_check_version (const char *req_version)
41 {
42 return _ksba_check_version (req_version);
43 }
44
45
46 /*-- util.c --*/
47 void
48 ksba_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
49 void *(*new_realloc_func)(void *p, size_t n),
50 void (*new_free_func)(void*) )
51 {
52 _ksba_set_malloc_hooks (new_alloc_func, new_realloc_func, new_free_func);
53 }
54
55
56 void
57 ksba_set_hash_buffer_function ( gpg_error_t (*fnc)
58 (void *arg, const char *oid,
59 const void *buffer, size_t length,
60 size_t resultsize,
61 unsigned char *result,
62 size_t *resultlen),
63 void *fnc_arg)
64 {
65 _ksba_set_hash_buffer_function (fnc, fnc_arg);
66 }
67
68 void *
69 ksba_malloc (size_t n )
70 {
71 return _ksba_malloc (n);
72 }
73
74 void *
75 ksba_calloc (size_t n, size_t m )
76 {
77 return _ksba_calloc (n, m);
78 }
79
80 void *
81 ksba_realloc (void *p, size_t n)
82 {
83 return _ksba_realloc (p, n);
84 }
85
86 char *
87 ksba_strdup (const char *p)
88 {
89 return _ksba_strdup (p);
90 }
91
92 void
93 ksba_free ( void *a )
94 {
95 if (a)
96 _ksba_free (a);
97 }
98
99
100 /*-- cert.c --*/
101 gpg_error_t
102 ksba_cert_new (ksba_cert_t *acert)
103 {
104 return _ksba_cert_new (acert);
105 }
106
107
108 void
109 ksba_cert_ref (ksba_cert_t cert)
110 {
111 _ksba_cert_ref (cert);
112 }
113
114
115 void
116 ksba_cert_release (ksba_cert_t cert)
117 {
118 _ksba_cert_release (cert);
119 }
120
121
122 gpg_error_t
123 ksba_cert_set_user_data (ksba_cert_t cert, const char *key,
124 const void *data, size_t datalen)
125 {
126 return _ksba_cert_set_user_data (cert, key, data, datalen);
127 }
128
129
130 gpg_error_t
131 ksba_cert_get_user_data (ksba_cert_t cert, const char *key,
132 void *buffer, size_t bufferlen,
133 size_t *datalen)
134 {
135 return _ksba_cert_get_user_data (cert, key, buffer, bufferlen, datalen);
136 }
137
138
139
140 gpg_error_t
141 ksba_cert_read_der (ksba_cert_t cert, ksba_reader_t reader)
142 {
143 return _ksba_cert_read_der (cert, reader);
144 }
145
146
147 gpg_error_t
148 ksba_cert_init_from_mem (ksba_cert_t cert,
149 const void *buffer, size_t length)
150 {
151 return _ksba_cert_init_from_mem (cert, buffer, length);
152 }
153
154
155 const unsigned char *
156 ksba_cert_get_image (ksba_cert_t cert, size_t *r_length)
157 {
158 return _ksba_cert_get_image (cert, r_length);
159 }
160
161
162 gpg_error_t
163 ksba_cert_hash (ksba_cert_t cert,
164 int what,
165 void (*hasher)(void *,
166 const void *,
167 size_t length),
168 void *hasher_arg)
169 {
170 return _ksba_cert_hash (cert, what, hasher, hasher_arg);
171 }
172
173
174 const char *
175 ksba_cert_get_digest_algo (ksba_cert_t cert)
176 {
177 return _ksba_cert_get_digest_algo (cert);
178 }
179
180
181 ksba_sexp_t
182 ksba_cert_get_serial (ksba_cert_t cert)
183 {
184 return _ksba_cert_get_serial (cert);
185 }
186
187
188 char *
189 ksba_cert_get_issuer (ksba_cert_t cert, int idx)
190 {
191 return _ksba_cert_get_issuer (cert, idx);
192 }
193
194
195 gpg_error_t
196 ksba_cert_get_validity (ksba_cert_t cert, int what,
197 ksba_isotime_t r_time)
198 {
199 return _ksba_cert_get_validity (cert, what, r_time);
200 }
201
202
203 char *
204 ksba_cert_get_subject (ksba_cert_t cert, int idx)
205 {
206 return _ksba_cert_get_subject (cert, idx);
207 }
208
209
210 ksba_sexp_t
211 ksba_cert_get_public_key (ksba_cert_t cert)
212 {
213 return _ksba_cert_get_public_key (cert);
214 }
215
216
217 ksba_sexp_t
218 ksba_cert_get_sig_val (ksba_cert_t cert)
219 {
220 return _ksba_cert_get_sig_val (cert);
221 }
222
223
224
225 gpg_error_t
226 ksba_cert_get_extension (ksba_cert_t cert, int idx,
227 char const **r_oid, int *r_crit,
228 size_t *r_deroff, size_t *r_derlen)
229 {
230 return _ksba_cert_get_extension (cert, idx, r_oid, r_crit,
231 r_deroff, r_derlen);
232 }
233
234
235
236 gpg_error_t
237 ksba_cert_is_ca (ksba_cert_t cert, int *r_ca, int *r_pathlen)
238 {
239 return _ksba_cert_is_ca (cert, r_ca, r_pathlen);
240 }
241
242
243 gpg_error_t
244 ksba_cert_get_key_usage (ksba_cert_t cert, unsigned int *r_flags)
245 {
246 return _ksba_cert_get_key_usage (cert, r_flags);
247 }
248
249
250 gpg_error_t
251 ksba_cert_get_cert_policies (ksba_cert_t cert, char **r_policies)
252 {
253 return _ksba_cert_get_cert_policies (cert, r_policies);
254 }
255
256
257 gpg_error_t
258 ksba_cert_get_ext_key_usages (ksba_cert_t cert, char **result)
259 {
260 return _ksba_cert_get_ext_key_usages (cert, result);
261 }
262
263
264 gpg_error_t
265 ksba_cert_get_crl_dist_point (ksba_cert_t cert, int idx,
266 ksba_name_t *r_distpoint,
267 ksba_name_t *r_issuer,
268 ksba_crl_reason_t *r_reason)
269 {
270 return _ksba_cert_get_crl_dist_point (cert, idx, r_distpoint, r_issuer,
271 r_reason);
272 }
273
274
275 gpg_error_t
276 ksba_cert_get_auth_key_id (ksba_cert_t cert,
277 ksba_sexp_t *r_keyid,
278 ksba_name_t *r_name,
279 ksba_sexp_t *r_serial)
280 {
281 return _ksba_cert_get_auth_key_id (cert, r_keyid, r_name, r_serial);
282 }
283
284
285 gpg_error_t
286 ksba_cert_get_subj_key_id (ksba_cert_t cert,
287 int *r_crit,
288 ksba_sexp_t *r_keyid)
289 {
290 return _ksba_cert_get_subj_key_id (cert, r_crit, r_keyid);
291 }
292
293
294 gpg_error_t
295 ksba_cert_get_authority_info_access (ksba_cert_t cert, int idx,
296 char **r_method,
297 ksba_name_t *r_location)
298 {
299 return _ksba_cert_get_authority_info_access (cert, idx,
300 r_method, r_location);
301 }
302
303
304 gpg_error_t
305 ksba_cert_get_subject_info_access (ksba_cert_t cert, int idx,
306 char **r_method,
307 ksba_name_t *r_location)
308 {
309 return _ksba_cert_get_subject_info_access (cert, idx, r_method, r_location);
310 }
311
312
313
314
315 /*-- cms.c --*/
316 ksba_content_type_t
317 ksba_cms_identify (ksba_reader_t reader)
318 {
319 return _ksba_cms_identify (reader);
320 }
321
322
323
324 gpg_error_t
325 ksba_cms_new (ksba_cms_t *r_cms)
326 {
327 return _ksba_cms_new (r_cms);
328 }
329
330
331 void
332 ksba_cms_release (ksba_cms_t cms)
333 {
334 _ksba_cms_release (cms);
335 }
336
337
338 gpg_error_t
339 ksba_cms_set_reader_writer (ksba_cms_t cms,
340 ksba_reader_t r, ksba_writer_t w)
341 {
342 return _ksba_cms_set_reader_writer (cms, r, w);
343 }
344
345
346
347 gpg_error_t
348 ksba_cms_parse (ksba_cms_t cms, ksba_stop_reason_t *r_stopreason)
349 {
350 return _ksba_cms_parse (cms, r_stopreason);
351 }
352
353
354 gpg_error_t
355 ksba_cms_build (ksba_cms_t cms, ksba_stop_reason_t *r_stopreason)
356 {
357 return _ksba_cms_build (cms, r_stopreason);
358 }
359
360
361 ksba_content_type_t
362 ksba_cms_get_content_type (ksba_cms_t cms, int what)
363 {
364 return _ksba_cms_get_content_type (cms, what);
365 }
366
367
368 const char *
369 ksba_cms_get_content_oid (ksba_cms_t cms, int what)
370 {
371 return _ksba_cms_get_content_oid (cms, what);
372 }
373
374
375 gpg_error_t
376 ksba_cms_get_content_enc_iv (ksba_cms_t cms, void *iv,
377 size_t maxivlen, size_t *ivlen)
378 {
379 return _ksba_cms_get_content_enc_iv (cms, iv, maxivlen, ivlen);
380 }
381
382
383 const char *
384 ksba_cms_get_digest_algo_list (ksba_cms_t cms, int idx)
385 {
386 return _ksba_cms_get_digest_algo_list (cms, idx);
387 }
388
389
390 gpg_error_t
391 ksba_cms_get_issuer_serial (ksba_cms_t cms, int idx,
392 char **r_issuer,
393 ksba_sexp_t *r_serial)
394 {
395 return _ksba_cms_get_issuer_serial (cms, idx, r_issuer, r_serial);
396 }
397
398
399 const char *
400 ksba_cms_get_digest_algo (ksba_cms_t cms, int idx)
401 {
402 return _ksba_cms_get_digest_algo (cms, idx);
403 }
404
405
406 ksba_cert_t
407 ksba_cms_get_cert (ksba_cms_t cms, int idx)
408 {
409 return _ksba_cms_get_cert (cms, idx);
410 }
411
412
413 gpg_error_t
414 ksba_cms_get_attribute (ksba_cms_t cms, int signer, int idx, int unprotected,
415 char **r_oid, unsigned char **r_der, size_t *r_derlen)
416 {
417 return _ksba_cms_get_attribute (cms, signer, idx, unprotected,
418 r_oid, r_der, r_derlen);
419 }
420
421
422 gpg_error_t
423 ksba_cms_get_message_digest (ksba_cms_t cms, int idx,
424 char **r_digest, size_t *r_digest_len)
425 {
426 return _ksba_cms_get_message_digest (cms, idx, r_digest, r_digest_len);
427 }
428
429
430 gpg_error_t
431 ksba_cms_get_signing_time (ksba_cms_t cms, int idx,
432 ksba_isotime_t r_sigtime)
433 {
434 return _ksba_cms_get_signing_time (cms, idx, r_sigtime);
435 }
436
437
438 gpg_error_t
439 ksba_cms_get_sigattr_oids (ksba_cms_t cms, int idx,
440 const char *reqoid, char **r_value)
441 {
442 return _ksba_cms_get_sigattr_oids (cms, idx, reqoid, r_value);
443 }
444
445
446 ksba_sexp_t
447 ksba_cms_get_sig_val (ksba_cms_t cms, int idx)
448 {
449 return _ksba_cms_get_sig_val (cms, idx);
450 }
451
452
453 ksba_sexp_t
454 ksba_cms_get_enc_val (ksba_cms_t cms, int idx)
455 {
456 return _ksba_cms_get_enc_val (cms, idx);
457 }
458
459
460 void
461 ksba_cms_set_hash_function (ksba_cms_t cms,
462 void (*hash_fnc)(void *, const void *, size_t),
463 void *hash_fnc_arg)
464 {
465 _ksba_cms_set_hash_function (cms, hash_fnc, hash_fnc_arg);
466 }
467
468
469 gpg_error_t
470 ksba_cms_hash_signed_attrs (ksba_cms_t cms, int idx)
471 {
472 return _ksba_cms_hash_signed_attrs (cms, idx);
473 }
474
475
476
477 gpg_error_t
478 ksba_cms_set_content_type (ksba_cms_t cms, int what,
479 ksba_content_type_t type)
480 {
481 return _ksba_cms_set_content_type (cms, what, type);
482 }
483
484
485 gpg_error_t
486 ksba_cms_add_digest_algo (ksba_cms_t cms, const char *oid)
487 {
488 return _ksba_cms_add_digest_algo (cms, oid);
489 }
490
491
492 gpg_error_t
493 ksba_cms_add_signer (ksba_cms_t cms, ksba_cert_t cert)
494 {
495 return _ksba_cms_add_signer (cms, cert);
496 }
497
498
499 gpg_error_t
500 ksba_cms_add_cert (ksba_cms_t cms, ksba_cert_t cert)
501 {
502 return _ksba_cms_add_cert (cms, cert);
503 }
504
505
506 gpg_error_t
507 ksba_cms_add_smime_capability (ksba_cms_t cms, const char *oid,
508 const unsigned char *der,
509 size_t derlen)
510 {
511 return _ksba_cms_add_smime_capability (cms, oid, der, derlen);
512 }
513
514 gpg_error_t
515 ksba_cms_add_attribute (ksba_cms_t cms, int idx,
516 const char *oid, int unprotected,
517 const unsigned char *der, size_t derlen)
518 {
519 return _ksba_cms_add_attribute (cms, idx, oid, unprotected, der, derlen);
520 }
521
522 gpg_error_t
523 ksba_cms_set_message_digest (ksba_cms_t cms, int idx,
524 const unsigned char *digest,
525 size_t digest_len)
526 {
527 return _ksba_cms_set_message_digest (cms, idx, digest, digest_len);
528 }
529
530
531 gpg_error_t
532 ksba_cms_set_signing_time (ksba_cms_t cms, int idx,
533 const ksba_isotime_t sigtime)
534 {
535 return _ksba_cms_set_signing_time (cms, idx, sigtime);
536 }
537
538
539 gpg_error_t
540 ksba_cms_set_sig_val (ksba_cms_t cms,
541 int idx, ksba_const_sexp_t sigval)
542 {
543 return _ksba_cms_set_sig_val (cms, idx, sigval);
544 }
545
546
547
548 gpg_error_t
549 ksba_cms_set_content_enc_algo (ksba_cms_t cms,
550 const char *oid,
551 const void *iv,
552 size_t ivlen)
553 {
554 return _ksba_cms_set_content_enc_algo (cms, oid, iv, ivlen);
555 }
556
557
558 gpg_error_t
559 ksba_cms_add_recipient (ksba_cms_t cms, ksba_cert_t cert)
560 {
561 return _ksba_cms_add_recipient (cms, cert);
562 }
563
564
565 gpg_error_t
566 ksba_cms_set_enc_val (ksba_cms_t cms,
567 int idx, ksba_const_sexp_t encval)
568 {
569 return _ksba_cms_set_enc_val (cms, idx, encval);
570 }
571
572
573
574
575 /*-- crl.c --*/
576 gpg_error_t
577 ksba_crl_new (ksba_crl_t *r_crl)
578 {
579 return _ksba_crl_new (r_crl);
580 }
581
582
583 void
584 ksba_crl_release (ksba_crl_t crl)
585 {
586 _ksba_crl_release (crl);
587 }
588
589
590 gpg_error_t
591 ksba_crl_set_reader (ksba_crl_t crl, ksba_reader_t r)
592 {
593 return _ksba_crl_set_reader (crl, r);
594 }
595
596
597 void
598 ksba_crl_set_hash_function (ksba_crl_t crl,
599 void (*hash_fnc)(void *,
600 const void *, size_t),
601 void *hash_fnc_arg)
602 {
603 _ksba_crl_set_hash_function (crl, hash_fnc, hash_fnc_arg);
604 }
605
606
607 const char *
608 ksba_crl_get_digest_algo (ksba_crl_t crl)
609 {
610 return _ksba_crl_get_digest_algo (crl);
611 }
612
613
614 gpg_error_t
615 ksba_crl_get_issuer (ksba_crl_t crl, char **r_issuer)
616 {
617 return _ksba_crl_get_issuer (crl, r_issuer);
618 }
619
620
621 gpg_error_t
622 ksba_crl_get_extension (ksba_crl_t crl, int idx,
623 char const **oid, int *critical,
624 unsigned char const **der, size_t *derlen)
625 {
626 return _ksba_crl_get_extension (crl, idx, oid, critical, der, derlen);
627 }
628
629
630 gpg_error_t
631 ksba_crl_get_auth_key_id (ksba_crl_t crl,
632 ksba_sexp_t *r_keyid,
633 ksba_name_t *r_name,
634 ksba_sexp_t *r_serial)
635 {
636 return _ksba_crl_get_auth_key_id (crl, r_keyid, r_name, r_serial);
637 }
638
639
640 gpg_error_t
641 ksba_crl_get_crl_number (ksba_crl_t crl, ksba_sexp_t *number)
642 {
643 return _ksba_crl_get_crl_number (crl, number);
644 }
645
646
647 gpg_error_t
648 ksba_crl_get_update_times (ksba_crl_t crl,
649 ksba_isotime_t this_update,
650 ksba_isotime_t next_update)
651 {
652 return _ksba_crl_get_update_times (crl, this_update, next_update);
653 }
654
655
656 gpg_error_t
657 ksba_crl_get_item (ksba_crl_t crl,
658 ksba_sexp_t *r_serial,
659 ksba_isotime_t r_revocation_date,
660 ksba_crl_reason_t *r_reason)
661 {
662 return _ksba_crl_get_item (crl, r_serial, r_revocation_date, r_reason);
663 }
664
665
666 ksba_sexp_t
667 ksba_crl_get_sig_val (ksba_crl_t crl)
668 {
669 return _ksba_crl_get_sig_val (crl);
670 }
671
672
673 gpg_error_t
674 ksba_crl_parse (ksba_crl_t crl, ksba_stop_reason_t *r_stopreason)
675 {
676 return _ksba_crl_parse (crl, r_stopreason);
677 }
678
679
680
681
682 /*-- ocsp.c --*/
683 gpg_error_t
684 ksba_ocsp_new (ksba_ocsp_t *r_oscp)
685 {
686 return _ksba_ocsp_new (r_oscp);
687 }
688
689
690 void
691 ksba_ocsp_release (ksba_ocsp_t ocsp)
692 {
693 _ksba_ocsp_release (ocsp);
694 }
695
696
697 gpg_error_t
698 ksba_ocsp_set_digest_algo (ksba_ocsp_t ocsp, const char *oid)
699 {
700 return _ksba_ocsp_set_digest_algo (ocsp, oid);
701 }
702
703
704 gpg_error_t
705 ksba_ocsp_set_requestor (ksba_ocsp_t ocsp, ksba_cert_t cert)
706 {
707 return _ksba_ocsp_set_requestor (ocsp, cert);
708 }
709
710
711 gpg_error_t
712 ksba_ocsp_add_target (ksba_ocsp_t ocsp,
713 ksba_cert_t cert, ksba_cert_t issuer_cert)
714 {
715 return _ksba_ocsp_add_target (ocsp, cert, issuer_cert);
716 }
717
718
719 size_t
720 ksba_ocsp_set_nonce (ksba_ocsp_t ocsp,
721 unsigned char *nonce, size_t noncelen)
722 {
723 return _ksba_ocsp_set_nonce (ocsp, nonce, noncelen);
724 }
725
726
727
728 gpg_error_t
729 ksba_ocsp_prepare_request (ksba_ocsp_t ocsp)
730 {
731 return _ksba_ocsp_prepare_request (ocsp);
732 }
733
734
735 gpg_error_t
736 ksba_ocsp_hash_request (ksba_ocsp_t ocsp,
737 void (*hasher)(void *, const void *,
738 size_t length),
739 void *hasher_arg)
740 {
741 return _ksba_ocsp_hash_request (ocsp, hasher, hasher_arg);
742 }
743
744
745 gpg_error_t
746 ksba_ocsp_set_sig_val (ksba_ocsp_t ocsp,
747 ksba_const_sexp_t sigval)
748 {
749 return _ksba_ocsp_set_sig_val (ocsp, sigval);
750 }
751
752
753 gpg_error_t
754 ksba_ocsp_add_cert (ksba_ocsp_t ocsp, ksba_cert_t cert)
755 {
756 return _ksba_ocsp_add_cert (ocsp, cert);
757 }
758
759
760 gpg_error_t
761 ksba_ocsp_build_request (ksba_ocsp_t ocsp,
762 unsigned char **r_buffer,
763 size_t *r_buflen)
764 {
765 return _ksba_ocsp_build_request (ocsp, r_buffer, r_buflen);
766 }
767
768
769
770 gpg_error_t
771 ksba_ocsp_parse_response (ksba_ocsp_t ocsp,
772 const unsigned char *msg, size_t msglen,
773 ksba_ocsp_response_status_t *resp_status)
774 {
775 return _ksba_ocsp_parse_response (ocsp, msg, msglen, resp_status);
776 }
777
778
779
780 const char *
781 ksba_ocsp_get_digest_algo (ksba_ocsp_t ocsp)
782 {
783 return _ksba_ocsp_get_digest_algo (ocsp);
784 }
785
786
787 gpg_error_t
788 ksba_ocsp_hash_response (ksba_ocsp_t ocsp,
789 const unsigned char *msg, size_t msglen,
790 void (*hasher)(void *, const void *,
791 size_t length),
792 void *hasher_arg)
793 {
794 return _ksba_ocsp_hash_response (ocsp, msg, msglen, hasher, hasher_arg);
795 }
796
797
798 ksba_sexp_t
799 ksba_ocsp_get_sig_val (ksba_ocsp_t ocsp,
800 ksba_isotime_t produced_at)
801 {
802 return _ksba_ocsp_get_sig_val (ocsp, produced_at);
803 }
804
805
806 gpg_error_t
807 ksba_ocsp_get_responder_id (ksba_ocsp_t ocsp,
808 char **r_name,
809 ksba_sexp_t *r_keyid)
810 {
811 return _ksba_ocsp_get_responder_id (ocsp, r_name, r_keyid);
812 }
813
814
815 ksba_cert_t
816 ksba_ocsp_get_cert (ksba_ocsp_t ocsp, int idx)
817 {
818 return _ksba_ocsp_get_cert (ocsp, idx);
819 }
820
821
822 gpg_error_t
823 ksba_ocsp_get_status (ksba_ocsp_t ocsp, ksba_cert_t cert,
824 ksba_status_t *r_status,
825 ksba_isotime_t r_this_update,
826 ksba_isotime_t r_next_update,
827 ksba_isotime_t r_revocation_time,
828 ksba_crl_reason_t *r_reason)
829 {
830 return _ksba_ocsp_get_status (ocsp, cert, r_status, r_this_update,
831 r_next_update, r_revocation_time, r_reason);
832 }
833
834
835 gpg_error_t
836 ksba_ocsp_get_extension (ksba_ocsp_t ocsp, ksba_cert_t cert,
837 int idx,
838 char const **r_oid, int *r_crit,
839 unsigned char const **r_der,
840 size_t *r_derlen)
841 {
842 return _ksba_ocsp_get_extension (ocsp, cert, idx, r_oid, r_crit,
843 r_der, r_derlen);
844 }
845
846
847
848
849 /*-- certreq.c --*/
850 gpg_error_t
851 ksba_certreq_new (ksba_certreq_t *r_cr)
852 {
853 return _ksba_certreq_new (r_cr);
854 }
855
856
857 void
858 ksba_certreq_release (ksba_certreq_t cr)
859 {
860 _ksba_certreq_release (cr);
861 }
862
863
864 gpg_error_t
865 ksba_certreq_set_writer (ksba_certreq_t cr, ksba_writer_t w)
866 {
867 return _ksba_certreq_set_writer (cr, w);
868 }
869
870
871 void
872 ksba_certreq_set_hash_function (ksba_certreq_t cr,
873 void (*hash_fnc)(void *, const void *, size_t),
874 void *hash_fnc_arg)
875 {
876 _ksba_certreq_set_hash_function (cr, hash_fnc, hash_fnc_arg);
877 }
878
879
880 gpg_error_t
881 ksba_certreq_set_serial (ksba_certreq_t cr, ksba_const_sexp_t sn)
882 {
883 return _ksba_certreq_set_serial (cr, sn);
884 }
885
886
887 gpg_error_t
888 ksba_certreq_set_issuer (ksba_certreq_t cr, const char *name)
889 {
890 return _ksba_certreq_set_issuer (cr, name);
891 }
892
893
894 gpg_error_t
895 ksba_certreq_add_subject (ksba_certreq_t cr, const char *name)
896 {
897 return _ksba_certreq_add_subject (cr, name);
898 }
899
900
901 gpg_error_t
902 ksba_certreq_set_public_key (ksba_certreq_t cr,
903 ksba_const_sexp_t key)
904 {
905 return _ksba_certreq_set_public_key (cr, key);
906 }
907
908
909 gpg_error_t
910 ksba_certreq_add_extension (ksba_certreq_t cr,
911 const char *oid, int is_crit,
912 const void *der,
913 size_t derlen)
914 {
915 return _ksba_certreq_add_extension (cr, oid, is_crit, der, derlen);
916 }
917
918
919 gpg_error_t
920 ksba_certreq_set_sig_val (ksba_certreq_t cr,
921 ksba_const_sexp_t sigval)
922 {
923 return _ksba_certreq_set_sig_val (cr, sigval);
924 }
925
926
927 gpg_error_t
928 ksba_certreq_build (ksba_certreq_t cr,
929 ksba_stop_reason_t *r_stopreason)
930 {
931 return _ksba_certreq_build (cr, r_stopreason);
932 }
933
934
935 gpg_error_t
936 ksba_certreq_set_validity (ksba_certreq_t cr, int what,
937 const ksba_isotime_t timebuf)
938 {
939 return _ksba_certreq_set_validity (cr, what, timebuf);
940 }
941
942
943 gpg_error_t
944 ksba_certreq_set_siginfo (ksba_certreq_t cr, ksba_const_sexp_t siginfo)
945 {
946 return _ksba_certreq_set_siginfo (cr, siginfo);
947 }
948
949
950 /*-- reader.c --*/
951 gpg_error_t
952 ksba_reader_new (ksba_reader_t *r_r)
953 {
954 return _ksba_reader_new (r_r);
955 }
956
957
958 void
959 ksba_reader_release (ksba_reader_t r)
960 {
961 _ksba_reader_release (r);
962 }
963
964
965 gpg_error_t
966 ksba_reader_clear (ksba_reader_t r,
967 unsigned char **buffer, size_t *buflen)
968 {
969 return _ksba_reader_clear (r, buffer, buflen);
970 }
971
972
973 gpg_error_t
974 ksba_reader_error (ksba_reader_t r)
975 {
976 return _ksba_reader_error (r);
977 }
978
979
980
981 gpg_error_t
982 ksba_reader_set_mem (ksba_reader_t r,
983 const void *buffer, size_t length)
984 {
985 return _ksba_reader_set_mem (r, buffer, length);
986 }
987
988
989 gpg_error_t
990 ksba_reader_set_fd (ksba_reader_t r, int fd)
991 {
992 return _ksba_reader_set_fd (r, fd);
993 }
994
995
996 gpg_error_t
997 ksba_reader_set_file (ksba_reader_t r, FILE *fp)
998 {
999 return _ksba_reader_set_file (r, fp);
1000 }
1001
1002
1003 gpg_error_t
1004 ksba_reader_set_cb (ksba_reader_t r,
1005 int (*cb)(void*,char *,size_t,size_t*),
1006 void *cb_value )
1007 {
1008 return _ksba_reader_set_cb (r, cb, cb_value);
1009 }
1010
1011
1012
1013 gpg_error_t
1014 ksba_reader_read (ksba_reader_t r,
1015 char *buffer, size_t length, size_t *nread)
1016 {
1017 return _ksba_reader_read (r, buffer, length, nread);
1018 }
1019
1020
1021 gpg_error_t
1022 ksba_reader_unread (ksba_reader_t r, const void *buffer, size_t count)
1023 {
1024 return _ksba_reader_unread (r, buffer, count);
1025 }
1026
1027
1028 unsigned long
1029 ksba_reader_tell (ksba_reader_t r)
1030 {
1031 return _ksba_reader_tell (r);
1032 }
1033
1034
1035
1036 /*-- writer.c --*/
1037 gpg_error_t
1038 ksba_writer_new (ksba_writer_t *r_w)
1039 {
1040 return _ksba_writer_new (r_w);
1041 }
1042
1043
1044 void
1045 ksba_writer_release (ksba_writer_t w)
1046 {
1047 _ksba_writer_release (w);
1048 }
1049
1050
1051 int
1052 ksba_writer_error (ksba_writer_t w)
1053 {
1054 return _ksba_writer_error (w);
1055 }
1056
1057
1058 unsigned long
1059 ksba_writer_tell (ksba_writer_t w)
1060 {
1061 return _ksba_writer_tell (w);
1062 }
1063
1064
1065 gpg_error_t
1066 ksba_writer_set_fd (ksba_writer_t w, int fd)
1067 {
1068 return _ksba_writer_set_fd (w, fd);
1069 }
1070
1071
1072 gpg_error_t
1073 ksba_writer_set_file (ksba_writer_t w, FILE *fp)
1074 {
1075 return _ksba_writer_set_file (w, fp);
1076 }
1077
1078
1079 gpg_error_t
1080 ksba_writer_set_cb (ksba_writer_t w,
1081 int (*cb)(void*,const void *,size_t),
1082 void *cb_value)
1083 {
1084 return _ksba_writer_set_cb (w, cb, cb_value);
1085 }
1086
1087
1088 gpg_error_t
1089 ksba_writer_set_mem (ksba_writer_t w, size_t initial_size)
1090 {
1091 return _ksba_writer_set_mem (w, initial_size);
1092 }
1093
1094
1095 const void *
1096 ksba_writer_get_mem (ksba_writer_t w, size_t *nbytes)
1097 {
1098 return _ksba_writer_get_mem (w, nbytes);
1099 }
1100
1101
1102 void *
1103 ksba_writer_snatch_mem (ksba_writer_t w, size_t *nbytes)
1104 {
1105 return _ksba_writer_snatch_mem (w, nbytes);
1106 }
1107
1108
1109 gpg_error_t
1110 ksba_writer_set_filter (ksba_writer_t w,
1111 gpg_error_t (*filter)(void*,
1112 const void *,size_t, size_t *,
1113 void *, size_t, size_t *),
1114 void *filter_arg)
1115 {
1116 return _ksba_writer_set_filter (w, filter, filter_arg);
1117 }
1118
1119
1120
1121 gpg_error_t
1122 ksba_writer_write (ksba_writer_t w, const void *buffer, size_t length)
1123 {
1124 return _ksba_writer_write (w, buffer, length);
1125 }
1126
1127
1128 gpg_error_t
1129 ksba_writer_write_octet_string (ksba_writer_t w,
1130 const void *buffer, size_t length,
1131 int flush)
1132 {
1133 return _ksba_writer_write_octet_string (w, buffer, length, flush);
1134 }
1135
1136
1137
1138 /*-- asn1-parse.y --*/
1139 int
1140 ksba_asn_parse_file (const char *filename, ksba_asn_tree_t *result,
1141 int debug)
1142 {
1143 return _ksba_asn_parse_file (filename, result, debug);
1144 }
1145
1146
1147 void
1148 ksba_asn_tree_release (ksba_asn_tree_t tree)
1149 {
1150 _ksba_asn_tree_release (tree);
1151 }
1152
1153
1154 /*-- asn1-func.c --*/
1155 void
1156 ksba_asn_tree_dump (ksba_asn_tree_t tree, const char *name, FILE *fp)
1157 {
1158 _ksba_asn_tree_dump (tree, name, fp);
1159 }
1160
1161
1162 gpg_error_t
1163 ksba_asn_create_tree (const char *mod_name, ksba_asn_tree_t *result)
1164 {
1165 return _ksba_asn_create_tree (mod_name, result);
1166 }
1167
1168
1169 /* This is a dummy function which we only include because it was
1170 accidently put into the public interface. */
1171 int
1172 ksba_asn_delete_structure (void *dummy)
1173 {
1174 (void)dummy;
1175 fprintf (stderr, "BUG: ksba_asn_delete_structure called\n");
1176 return -1;
1177 }
1178
1179
1180 /*-- oid.c --*/
1181 char *
1182 ksba_oid_to_str (const char *buffer, size_t length)
1183 {
1184 return _ksba_oid_to_str (buffer, length);
1185 }
1186
1187
1188 gpg_error_t
1189 ksba_oid_from_str (const char *string,
1190 unsigned char **rbuf, size_t *rlength)
1191 {
1192 return _ksba_oid_from_str (string, rbuf, rlength);
1193 }
1194
1195
1196
1197 /*-- dn.c --*/
1198 gpg_error_t
1199 ksba_dn_der2str (const void *der, size_t derlen, char **r_string)
1200 {
1201 return _ksba_dn_der2str (der, derlen, r_string);
1202 }
1203
1204
1205 gpg_error_t
1206 ksba_dn_str2der (const char *string,
1207 unsigned char **rder, size_t *rderlen)
1208 {
1209 return _ksba_dn_str2der (string, rder, rderlen);
1210 }
1211
1212
1213 gpg_error_t
1214 ksba_dn_teststr (const char *string, int seq,
1215 size_t *rerroff, size_t *rerrlen)
1216 {
1217 return _ksba_dn_teststr (string, seq, rerroff, rerrlen);
1218 }
1219
1220
1221
1222
1223 /*-- name.c --*/
1224 gpg_error_t
1225 ksba_name_new (ksba_name_t *r_name)
1226 {
1227 return _ksba_name_new (r_name);
1228 }
1229
1230
1231 void
1232 ksba_name_ref (ksba_name_t name)
1233 {
1234 _ksba_name_ref (name);
1235 }
1236
1237
1238 void
1239 ksba_name_release (ksba_name_t name)
1240 {
1241 _ksba_name_release (name);
1242 }
1243
1244
1245 const char *
1246 ksba_name_enum (ksba_name_t name, int idx)
1247 {
1248 return _ksba_name_enum (name, idx);
1249 }
1250
1251
1252 char *
1253 ksba_name_get_uri (ksba_name_t name, int idx)
1254 {
1255 return _ksba_name_get_uri (name, idx);
1256 }
1257
1258
1259 /*-- der-encoder.c --*/
1260 void
1261 ksba_der_release (ksba_der_t d)
1262 {
1263 if (d)
1264 _ksba_der_release (d);
1265 }
1266
1267 ksba_der_t
1268 ksba_der_builder_new (unsigned int nitems)
1269 {
1270 return _ksba_der_builder_new (nitems);
1271 }
1272
1273 void
1274 ksba_der_builder_reset (ksba_der_t d)
1275 {
1276 _ksba_der_builder_reset (d);
1277 }
1278
1279 void
1280 ksba_der_add_ptr (ksba_der_t d, int cls, int tag,
1281 void *value, size_t valuelen)
1282 {
1283 _ksba_der_add_ptr (d, cls, tag, value, valuelen);
1284 }
1285
1286 void
1287 ksba_der_add_val (ksba_der_t d, int cls, int tag,
1288 const void *value, size_t valuelen)
1289 {
1290 _ksba_der_add_val (d, cls, tag, value, valuelen);
1291 }
1292
1293 void
1294 ksba_der_add_int (ksba_der_t d, const void *value, size_t valuelen,
1295 int force_positive)
1296 {
1297 _ksba_der_add_int (d, value, valuelen, force_positive);
1298 }
1299
1300 void
1301 ksba_der_add_oid (ksba_der_t d, const char *oidstr)
1302 {
1303 _ksba_der_add_oid (d, oidstr);
1304 }
1305
1306 void
1307 ksba_der_add_bts (ksba_der_t d, const void *value, size_t valuelen,
1308 unsigned int unusedbits)
1309 {
1310 _ksba_der_add_bts (d, value, valuelen, unusedbits);
1311 }
1312
1313 void
1314 ksba_der_add_der (ksba_der_t d, const void *der, size_t derlen)
1315 {
1316 _ksba_der_add_der (d, der, derlen);
1317 }
1318
1319 void
1320 ksba_der_add_tag (ksba_der_t d, int cls, int tag)
1321 {
1322 _ksba_der_add_tag (d, cls, tag);
1323 }
1324
1325 void
1326 ksba_der_add_end (ksba_der_t d)
1327 {
1328 _ksba_der_add_end (d);
1329 }
1330
1331 gpg_error_t
1332 ksba_der_builder_get (ksba_der_t d, unsigned char **r_obj, size_t *r_objlen)
1333 {
1334 return _ksba_der_builder_get (d, r_obj, r_objlen);
1335 }