LCOV - code coverage report
Current view: top level - src - visibility.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 90 318 28.3 %
Date: 2016-09-12 12:51:24 Functions: 42 149 28.2 %

          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          76 : ksba_free ( void *a )
      93             : {
      94          76 :   if (a)
      95          64 :     _ksba_free (a);
      96          76 : }
      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             : }

Generated by: LCOV version 1.11