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