LCOV - code coverage report
Current view: top level - src - visibility.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 379 603 62.9 %
Date: 2016-09-12 12:56:58 Functions: 142 204 69.6 %

          Line data    Source code
       1             : /* visibility.c - Wrapper for all public functions.
       2             :  * Copyright (C) 2007, 2008, 2011  Free Software Foundation, Inc.
       3             :  * Copyright (C) 2013  g10 Code GmbH
       4             :  *
       5             :  * This file is part of Libgcrypt.
       6             :  *
       7             :  * Libgcrypt is free software; you can redistribute it and/or modify
       8             :  * it under the terms of the GNU Lesser General Public License as
       9             :  * published by the Free Software Foundation; either version 2.1 of
      10             :  * the License, or (at your option) any later version.
      11             :  *
      12             :  * Libgcrypt is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :  * GNU Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
      19             :  */
      20             : 
      21             : #include <config.h>
      22             : #include <stdarg.h>
      23             : 
      24             : #define _GCRY_INCLUDED_BY_VISIBILITY_C
      25             : #include "g10lib.h"
      26             : #include "cipher-proto.h"
      27             : #include "context.h"
      28             : #include "mpi.h"
      29             : 
      30             : const char *
      31           0 : gcry_strerror (gcry_error_t err)
      32             : {
      33           0 :   return _gcry_strerror (err);
      34             : }
      35             : 
      36             : const char *
      37           0 : gcry_strsource (gcry_error_t err)
      38             : {
      39           0 :   return _gcry_strsource (err);
      40             : }
      41             : 
      42             : gcry_err_code_t
      43           0 : gcry_err_code_from_errno (int err)
      44             : {
      45           0 :   return _gcry_err_code_from_errno (err);
      46             : }
      47             : 
      48             : int
      49           0 : gcry_err_code_to_errno (gcry_err_code_t code)
      50             : {
      51           0 :   return _gcry_err_code_to_errno (code);
      52             : }
      53             : 
      54             : gcry_error_t
      55           0 : gcry_err_make_from_errno (gcry_err_source_t source, int err)
      56             : {
      57           0 :   return _gcry_err_make_from_errno (source, err);
      58             : }
      59             : 
      60             : gcry_error_t
      61           0 : gcry_error_from_errno (int err)
      62             : {
      63           0 :   return _gcry_error_from_errno (err);
      64             : }
      65             : 
      66             : const char *
      67          34 : gcry_check_version (const char *req_version)
      68             : {
      69          34 :   return _gcry_check_version (req_version);
      70             : }
      71             : 
      72             : gcry_error_t
      73       23651 : gcry_control (enum gcry_ctl_cmds cmd, ...)
      74             : {
      75             :   gcry_error_t err;
      76             :   va_list arg_ptr;
      77             : 
      78       23651 :   va_start (arg_ptr, cmd);
      79       23651 :   err = gpg_error (_gcry_vcontrol (cmd, arg_ptr));
      80       24048 :   va_end(arg_ptr);
      81       24048 :   return err;
      82             : }
      83             : 
      84             : gcry_error_t
      85         338 : gcry_sexp_new (gcry_sexp_t *retsexp,
      86             :                const void *buffer, size_t length,
      87             :                int autodetect)
      88             : {
      89         338 :   return gpg_error (_gcry_sexp_new (retsexp, buffer, length, autodetect));
      90             : }
      91             : 
      92             : gcry_error_t
      93          30 : gcry_sexp_create (gcry_sexp_t *retsexp,
      94             :                   void *buffer, size_t length,
      95             :                   int autodetect, void (*freefnc) (void *))
      96             : {
      97          30 :   return gpg_error (_gcry_sexp_create (retsexp, buffer, length,
      98             :                                        autodetect, freefnc));
      99             : }
     100             : 
     101             : gcry_error_t
     102         455 : gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
     103             :                  const char *buffer, size_t length)
     104             : {
     105         455 :   return gpg_error (_gcry_sexp_sscan (retsexp, erroff, buffer, length));
     106             : }
     107             : 
     108             : gcry_error_t
     109        5174 : gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
     110             :                  const char *format, ...)
     111             : {
     112             :   gcry_err_code_t rc;
     113             :   va_list arg_ptr;
     114             : 
     115        5174 :   va_start (arg_ptr, format);
     116        5174 :   rc = _gcry_sexp_vbuild (retsexp, erroff, format, arg_ptr);
     117        5174 :   va_end (arg_ptr);
     118        5174 :   return gpg_error (rc);
     119             : }
     120             : 
     121             : gcry_error_t
     122           0 : gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
     123             :                        const char *format, void **arg_list)
     124             : {
     125           0 :   return gpg_error (_gcry_sexp_build_array (retsexp, erroff, format, arg_list));
     126             : }
     127             : 
     128             : void
     129       15018 : gcry_sexp_release (gcry_sexp_t sexp)
     130             : {
     131       15018 :   _gcry_sexp_release (sexp);
     132       15018 : }
     133             : 
     134             : size_t
     135          14 : gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
     136             :                      size_t *erroff, gcry_error_t *errcode)
     137             : {
     138             :   size_t n;
     139             :   gpg_err_code_t rc;
     140             : 
     141          14 :   n = _gcry_sexp_canon_len (buffer, length, erroff, &rc);
     142          14 :   if (errcode)
     143          14 :     *errcode = gpg_error (rc);
     144          14 :   return n;
     145             : }
     146             : 
     147             : size_t
     148         410 : gcry_sexp_sprint (gcry_sexp_t sexp, int mode, void *buffer, size_t maxlength)
     149             : {
     150         410 :   return _gcry_sexp_sprint (sexp, mode, buffer, maxlength);
     151             : }
     152             : 
     153             : void
     154           0 : gcry_sexp_dump (const gcry_sexp_t a)
     155             : {
     156           0 :   _gcry_sexp_dump (a);
     157           0 : }
     158             : 
     159             : gcry_sexp_t
     160           0 : gcry_sexp_cons (const gcry_sexp_t a, const gcry_sexp_t b)
     161             : {
     162           0 :   return _gcry_sexp_cons (a, b);
     163             : }
     164             : 
     165             : gcry_sexp_t
     166           0 : gcry_sexp_alist (const gcry_sexp_t *array)
     167             : {
     168           0 :   return _gcry_sexp_alist (array);
     169             : }
     170             : 
     171             : gcry_sexp_t
     172           0 : gcry_sexp_vlist (const gcry_sexp_t a, ...)
     173             : {
     174             :   /* This is not yet implemented in sexp.c.  */
     175             :   (void)a;
     176           0 :   BUG ();
     177             :   return NULL;
     178             : }
     179             : 
     180             : gcry_sexp_t
     181           0 : gcry_sexp_append (const gcry_sexp_t a, const gcry_sexp_t n)
     182             : {
     183           0 :   return _gcry_sexp_append (a, n);
     184             : }
     185             : 
     186             : gcry_sexp_t
     187           0 : gcry_sexp_prepend (const gcry_sexp_t a, const gcry_sexp_t n)
     188             : {
     189           0 :   return _gcry_sexp_prepend (a, n);
     190             : }
     191             : 
     192             : 
     193             : gcry_sexp_t
     194        5901 : gcry_sexp_find_token (gcry_sexp_t list, const char *tok, size_t toklen)
     195             : {
     196        5901 :   return _gcry_sexp_find_token (list, tok, toklen);
     197             : }
     198             : 
     199             : int
     200           0 : gcry_sexp_length (const gcry_sexp_t list)
     201             : {
     202           0 :   return _gcry_sexp_length (list);
     203             : }
     204             : 
     205             : gcry_sexp_t
     206           4 : gcry_sexp_nth (const gcry_sexp_t list, int number)
     207             : {
     208           4 :   return _gcry_sexp_nth (list, number);
     209             : }
     210             : 
     211             : gcry_sexp_t
     212           0 : gcry_sexp_car (const gcry_sexp_t list)
     213             : {
     214           0 :   return _gcry_sexp_car (list);
     215             : }
     216             : 
     217             : gcry_sexp_t
     218          24 : gcry_sexp_cdr (const gcry_sexp_t list)
     219             : {
     220          24 :   return _gcry_sexp_cdr (list);
     221             : }
     222             : 
     223             : gcry_sexp_t
     224           0 : gcry_sexp_cadr (const gcry_sexp_t list)
     225             : {
     226           0 :   return _gcry_sexp_cadr (list);
     227             : }
     228             : 
     229             : const char *
     230        1436 : gcry_sexp_nth_data (const gcry_sexp_t list, int number, size_t *datalen)
     231             : {
     232        1436 :   return _gcry_sexp_nth_data (list, number, datalen);
     233             : }
     234             : 
     235             : void *
     236        2071 : gcry_sexp_nth_buffer (const gcry_sexp_t list, int number, size_t *rlength)
     237             : {
     238        2071 :   return _gcry_sexp_nth_buffer (list, number, rlength);
     239             : }
     240             : 
     241             : char *
     242          10 : gcry_sexp_nth_string (gcry_sexp_t list, int number)
     243             : {
     244          10 :   return _gcry_sexp_nth_string (list, number);
     245             : }
     246             : 
     247             : gcry_mpi_t
     248         120 : gcry_sexp_nth_mpi (gcry_sexp_t list, int number, int mpifmt)
     249             : {
     250         120 :   return _gcry_sexp_nth_mpi (list, number, mpifmt);
     251             : }
     252             : 
     253             : gpg_error_t
     254          20 : gcry_sexp_extract_param (gcry_sexp_t sexp, const char *path,
     255             :                          const char *list, ...)
     256             : {
     257             :   gcry_err_code_t rc;
     258             :   va_list arg_ptr;
     259             : 
     260          20 :   va_start (arg_ptr, list);
     261          20 :   rc = _gcry_sexp_vextract_param (sexp, path, list, arg_ptr);
     262          20 :   va_end (arg_ptr);
     263          20 :   return gpg_error (rc);
     264             : }
     265             : 
     266             : 
     267             : 
     268             : gcry_mpi_t
     269         180 : gcry_mpi_new (unsigned int nbits)
     270             : {
     271         180 :   return _gcry_mpi_new (nbits);
     272             : }
     273             : 
     274             : gcry_mpi_t
     275           0 : gcry_mpi_snew (unsigned int nbits)
     276             : {
     277           0 :   return _gcry_mpi_snew (nbits);
     278             : }
     279             : 
     280             : void
     281        3862 : gcry_mpi_release (gcry_mpi_t a)
     282             : {
     283        3862 :   _gcry_mpi_release (a);
     284        3862 : }
     285             : 
     286             : gcry_mpi_t
     287        3005 : gcry_mpi_copy (const gcry_mpi_t a)
     288             : {
     289        3005 :   return _gcry_mpi_copy (a);
     290             : }
     291             : 
     292             : void
     293           0 : gcry_mpi_snatch (gcry_mpi_t w, const gcry_mpi_t u)
     294             : {
     295           0 :   _gcry_mpi_snatch (w, u);
     296           0 : }
     297             : 
     298             : gcry_mpi_t
     299        1003 : gcry_mpi_set (gcry_mpi_t w, const gcry_mpi_t u)
     300             : {
     301        1003 :   return _gcry_mpi_set (w, u);
     302             : }
     303             : 
     304             : gcry_mpi_t
     305          92 : gcry_mpi_set_ui (gcry_mpi_t w, unsigned long u)
     306             : {
     307          92 :   return _gcry_mpi_set_ui (w, u);
     308             : }
     309             : 
     310             : gcry_error_t
     311           0 : gcry_mpi_get_ui (gcry_mpi_t w, unsigned long *u)
     312             : {
     313           0 :   return gpg_error (_gcry_mpi_get_ui (w, u));
     314             : }
     315             : 
     316             : void
     317           0 : gcry_mpi_swap (gcry_mpi_t a, gcry_mpi_t b)
     318             : {
     319           0 :   _gcry_mpi_swap (a, b);
     320           0 : }
     321             : 
     322             : int
     323          70 : gcry_mpi_is_neg (gcry_mpi_t a)
     324             : {
     325          70 :   return _gcry_mpi_is_neg (a);
     326             : }
     327             : 
     328             : void
     329          36 : gcry_mpi_neg (gcry_mpi_t w, gcry_mpi_t u)
     330             : {
     331          36 :   _gcry_mpi_neg (w, u);
     332          36 : }
     333             : 
     334             : void
     335           1 : gcry_mpi_abs (gcry_mpi_t w)
     336             : {
     337           1 :   _gcry_mpi_abs (w);
     338           1 : }
     339             : 
     340             : int
     341         347 : gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v)
     342             : {
     343         347 :   return _gcry_mpi_cmp (u, v);
     344             : }
     345             : 
     346             : int
     347          46 : gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v)
     348             : {
     349          46 :   return _gcry_mpi_cmp_ui (u, v);
     350             : }
     351             : 
     352             : gcry_error_t
     353         344 : gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
     354             :                const void *buffer, size_t buflen,
     355             :                size_t *nscanned)
     356             : {
     357         344 :   return gpg_error (_gcry_mpi_scan (ret_mpi, format, buffer, buflen, nscanned));
     358             : }
     359             : 
     360             : gcry_error_t
     361           2 : gcry_mpi_print (enum gcry_mpi_format format,
     362             :                 unsigned char *buffer, size_t buflen,
     363             :                 size_t *nwritten,
     364             :                 const gcry_mpi_t a)
     365             : {
     366           2 :   return gpg_error (_gcry_mpi_print (format, buffer, buflen, nwritten, a));
     367             : }
     368             : 
     369             : gcry_error_t
     370         129 : gcry_mpi_aprint (enum gcry_mpi_format format,
     371             :                  unsigned char **buffer, size_t *nwritten,
     372             :                  const gcry_mpi_t a)
     373             : {
     374         129 :   return gpg_error (_gcry_mpi_aprint (format, buffer, nwritten, a));
     375             : }
     376             : 
     377             : void
     378           0 : gcry_mpi_dump (const gcry_mpi_t a)
     379             : {
     380           0 :   _gcry_log_printmpi (NULL, a);
     381           0 : }
     382             : 
     383             : void
     384           2 : gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
     385             : {
     386           2 :   _gcry_mpi_add (w, u, v);
     387           2 : }
     388             : 
     389             : void
     390           3 : gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v)
     391             : {
     392           3 :   _gcry_mpi_add_ui (w, u, v);
     393           3 : }
     394             : 
     395             : void
     396           0 : gcry_mpi_addm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
     397             : {
     398           0 :   _gcry_mpi_addm (w, u, v, m);
     399           0 : }
     400             : 
     401             : void
     402           1 : gcry_mpi_sub (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
     403             : {
     404           1 :   _gcry_mpi_sub (w, u, v);
     405           1 : }
     406             : 
     407             : void
     408           5 : gcry_mpi_sub_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
     409             : {
     410           5 :   _gcry_mpi_sub_ui (w, u, v);
     411           5 : }
     412             : 
     413             : void
     414           0 : gcry_mpi_subm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
     415             : {
     416           0 :   _gcry_mpi_subm (w, u, v, m);
     417           0 : }
     418             : 
     419             : void
     420           1 : gcry_mpi_mul (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
     421             : {
     422           1 :   _gcry_mpi_mul (w, u, v);
     423           1 : }
     424             : 
     425             : void
     426           0 : gcry_mpi_mul_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
     427             : {
     428           0 :   _gcry_mpi_mul_ui (w, u, v);
     429           0 : }
     430             : 
     431             : void
     432           0 : gcry_mpi_mulm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
     433             : {
     434           0 :   _gcry_mpi_mulm (w, u, v, m);
     435           0 : }
     436             : 
     437             : void
     438           0 : gcry_mpi_mul_2exp (gcry_mpi_t w, gcry_mpi_t u, unsigned long cnt)
     439             : {
     440           0 :   _gcry_mpi_mul_2exp (w, u, cnt);
     441           0 : }
     442             : 
     443             : void
     444           2 : gcry_mpi_div (gcry_mpi_t q, gcry_mpi_t r,
     445             :               gcry_mpi_t dividend, gcry_mpi_t divisor, int round)
     446             : {
     447           2 :   _gcry_mpi_div (q, r, dividend, divisor, round);
     448           2 : }
     449             : 
     450             : void
     451           1 : gcry_mpi_mod (gcry_mpi_t r, gcry_mpi_t dividend, gcry_mpi_t divisor)
     452             : {
     453           1 :   _gcry_mpi_mod (r, dividend, divisor);
     454           1 : }
     455             : 
     456             : void
     457        3015 : gcry_mpi_powm (gcry_mpi_t w, const gcry_mpi_t b, const gcry_mpi_t e,
     458             :                const gcry_mpi_t m)
     459             : {
     460        3015 :   _gcry_mpi_powm (w, b, e, m);
     461        3015 : }
     462             : 
     463             : int
     464           0 : gcry_mpi_gcd (gcry_mpi_t g, gcry_mpi_t a, gcry_mpi_t b)
     465             : {
     466           0 :   return _gcry_mpi_gcd (g, a, b);
     467             : }
     468             : 
     469             : int
     470           0 : gcry_mpi_invm (gcry_mpi_t x, gcry_mpi_t a, gcry_mpi_t m)
     471             : {
     472           0 :   return _gcry_mpi_invm (x, a, m);
     473             : }
     474             : 
     475             : gcry_mpi_point_t
     476           8 : gcry_mpi_point_new (unsigned int nbits)
     477             : {
     478           8 :   return _gcry_mpi_point_new (nbits);
     479             : }
     480             : 
     481             : void
     482          11 : gcry_mpi_point_release (gcry_mpi_point_t point)
     483             : {
     484          11 :   _gcry_mpi_point_release (point);
     485          11 : }
     486             : 
     487             : void
     488           6 : gcry_mpi_point_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
     489             :                     gcry_mpi_point_t point)
     490             : {
     491           6 :   _gcry_mpi_point_get (x, y, z, point);
     492           6 : }
     493             : 
     494             : void
     495           9 : gcry_mpi_point_snatch_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
     496             :                            gcry_mpi_point_t point)
     497             : {
     498           9 :   _gcry_mpi_point_snatch_get (x, y, z, point);
     499           9 : }
     500             : 
     501             : gcry_mpi_point_t
     502        1004 : gcry_mpi_point_set (gcry_mpi_point_t point,
     503             :                     gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z)
     504             : {
     505        1004 :   return _gcry_mpi_point_set (point, x, y, z);
     506             : }
     507             : 
     508             : gcry_mpi_point_t
     509           2 : gcry_mpi_point_snatch_set (gcry_mpi_point_t point,
     510             :                            gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z)
     511             : {
     512           2 :   return _gcry_mpi_point_snatch_set (point, x, y, z);
     513             : }
     514             : 
     515             : gpg_error_t
     516          16 : gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
     517             :                  gcry_sexp_t keyparam, const char *curvename)
     518             : {
     519          16 :   return gpg_error (_gcry_mpi_ec_new (r_ctx, keyparam, curvename));
     520             : }
     521             : 
     522             : gcry_mpi_t
     523          53 : gcry_mpi_ec_get_mpi (const char *name, gcry_ctx_t ctx, int copy)
     524             : {
     525          53 :   return _gcry_mpi_ec_get_mpi (name, ctx, copy);
     526             : }
     527             : 
     528             : gcry_mpi_point_t
     529          10 : gcry_mpi_ec_get_point (const char *name, gcry_ctx_t ctx, int copy)
     530             : {
     531          10 :   return _gcry_mpi_ec_get_point (name, ctx, copy);
     532             : }
     533             : 
     534             : gpg_error_t
     535           8 : gcry_mpi_ec_set_mpi (const char *name, gcry_mpi_t newvalue, gcry_ctx_t ctx)
     536             : {
     537           8 :   return gpg_error (_gcry_mpi_ec_set_mpi (name, newvalue, ctx));
     538             : }
     539             : 
     540             : gpg_error_t
     541           2 : gcry_mpi_ec_set_point (const char *name, gcry_mpi_point_t newvalue,
     542             :                         gcry_ctx_t ctx)
     543             : {
     544           2 :   return gpg_error (_gcry_mpi_ec_set_point (name, newvalue, ctx));
     545             : }
     546             : 
     547             : gpg_error_t
     548           0 : gcry_mpi_ec_decode_point (gcry_mpi_point_t result, gcry_mpi_t value,
     549             :                           gcry_ctx_t ctx)
     550             : {
     551           0 :   return gpg_error (_gcry_mpi_ec_decode_point
     552             :                     (result, value,
     553             :                      ctx? _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC) : NULL));
     554             : }
     555             : 
     556             : int
     557        1006 : gcry_mpi_ec_get_affine (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_point_t point,
     558             :                         gcry_ctx_t ctx)
     559             : {
     560        1006 :   return _gcry_mpi_ec_get_affine (x, y, point,
     561        1006 :                                   _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
     562             : }
     563             : 
     564             : void
     565           0 : gcry_mpi_ec_dup (gcry_mpi_point_t w, gcry_mpi_point_t u, gcry_ctx_t ctx)
     566             : {
     567           0 :   _gcry_mpi_ec_dup_point (w, u, _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
     568           0 : }
     569             : 
     570             : void
     571           0 : gcry_mpi_ec_add (gcry_mpi_point_t w,
     572             :                  gcry_mpi_point_t u, gcry_mpi_point_t v, gcry_ctx_t ctx)
     573             : {
     574           0 :   _gcry_mpi_ec_add_points (w, u, v,
     575           0 :                            _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
     576           0 : }
     577             : 
     578             : void
     579           0 : gcry_mpi_ec_sub (gcry_mpi_point_t w,
     580             :                  gcry_mpi_point_t u, gcry_mpi_point_t v, gcry_ctx_t ctx)
     581             : {
     582           0 :   _gcry_mpi_ec_sub_points (w, u, v,
     583           0 :                            _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
     584           0 : }
     585             : 
     586             : void
     587        1007 : gcry_mpi_ec_mul (gcry_mpi_point_t w, gcry_mpi_t n, gcry_mpi_point_t u,
     588             :                  gcry_ctx_t ctx)
     589             : {
     590        1007 :   _gcry_mpi_ec_mul_point (w, n, u,
     591        1007 :                           _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
     592        1007 : }
     593             : 
     594             : int
     595           1 : gcry_mpi_ec_curve_point (gcry_mpi_point_t point, gcry_ctx_t ctx)
     596             : {
     597           1 :   return _gcry_mpi_ec_curve_point
     598           1 :     (point, _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
     599             : }
     600             : 
     601             : unsigned int
     602       10500 : gcry_mpi_get_nbits (gcry_mpi_t a)
     603             : {
     604       10500 :   return _gcry_mpi_get_nbits (a);
     605             : }
     606             : 
     607             : int
     608      771145 : gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n)
     609             : {
     610      771145 :   return _gcry_mpi_test_bit (a, n);
     611             : }
     612             : 
     613             : void
     614        1003 : gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n)
     615             : {
     616        1003 :   _gcry_mpi_set_bit (a, n);
     617        1003 : }
     618             : 
     619             : void
     620        4006 : gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n)
     621             : {
     622        4006 :   _gcry_mpi_clear_bit (a, n);
     623        4006 : }
     624             : 
     625             : void
     626           2 : gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n)
     627             : {
     628           2 :   _gcry_mpi_set_highbit (a, n);
     629           2 : }
     630             : 
     631             : void
     632          70 : gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n)
     633             : {
     634          70 :   _gcry_mpi_clear_highbit (a, n);
     635          70 : }
     636             : 
     637             : void
     638         750 : gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
     639             : {
     640         750 :   _gcry_mpi_rshift (x, a, n);
     641         750 : }
     642             : 
     643             : void
     644        5250 : gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
     645             : {
     646        5250 :   _gcry_mpi_lshift (x, a, n);
     647        5250 : }
     648             : 
     649             : gcry_mpi_t
     650          14 : gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits)
     651             : {
     652          14 :   return _gcry_mpi_set_opaque (a, p, nbits);
     653             : }
     654             : 
     655             : gcry_mpi_t
     656           1 : gcry_mpi_set_opaque_copy (gcry_mpi_t a, const void *p, unsigned int nbits)
     657             : {
     658           1 :   return _gcry_mpi_set_opaque_copy (a, p, nbits);
     659             : }
     660             : 
     661             : void *
     662           2 : gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits)
     663             : {
     664           2 :   return _gcry_mpi_get_opaque (a, nbits);
     665             : }
     666             : 
     667             : void
     668           2 : gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
     669             : {
     670           2 :   _gcry_mpi_set_flag (a, flag);
     671           2 : }
     672             : 
     673             : void
     674           2 : gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
     675             : {
     676           2 :   _gcry_mpi_clear_flag (a, flag);
     677           2 : }
     678             : 
     679             : int
     680         168 : gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
     681             : {
     682         168 :   return _gcry_mpi_get_flag (a, flag);
     683             : }
     684             : 
     685             : gcry_mpi_t
     686        1012 : _gcry_mpi_get_const (int no)
     687             : {
     688        1012 :   switch (no)
     689             :     {
     690        1005 :     case 1: return _gcry_mpi_const (MPI_C_ONE);
     691           5 :     case 2: return _gcry_mpi_const (MPI_C_TWO);
     692           0 :     case 3: return _gcry_mpi_const (MPI_C_THREE);
     693           2 :     case 4: return _gcry_mpi_const (MPI_C_FOUR);
     694           0 :     case 8: return _gcry_mpi_const (MPI_C_EIGHT);
     695           0 :     default: log_bug("unsupported GCRYMPI_CONST_ macro used\n");
     696             :     }
     697             : }
     698             : 
     699             : gcry_error_t
     700        4224 : gcry_cipher_open (gcry_cipher_hd_t *handle,
     701             :                   int algo, int mode, unsigned int flags)
     702             : {
     703        4224 :   if (!fips_is_operational ())
     704             :     {
     705           0 :       *handle = NULL;
     706           0 :       return gpg_error (fips_not_operational ());
     707             :     }
     708             : 
     709        4224 :   return gpg_error (_gcry_cipher_open (handle, algo, mode, flags));
     710             : }
     711             : 
     712             : void
     713        4226 : gcry_cipher_close (gcry_cipher_hd_t h)
     714             : {
     715        4226 :   _gcry_cipher_close (h);
     716        4226 : }
     717             : 
     718             : gcry_error_t
     719        4304 : gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
     720             : {
     721        4304 :   if (!fips_is_operational ())
     722           0 :     return gpg_error (fips_not_operational ());
     723             : 
     724        4304 :   return gcry_error (_gcry_cipher_setkey (hd, key, keylen));
     725             : }
     726             : 
     727             : gcry_error_t
     728      179002 : gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
     729             : {
     730      179002 :   if (!fips_is_operational ())
     731           0 :     return gpg_error (fips_not_operational ());
     732             : 
     733      179002 :   return gcry_error (_gcry_cipher_setiv (hd, iv, ivlen));
     734             : }
     735             : 
     736             : gpg_error_t
     737          20 : gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
     738             : {
     739          20 :   if (!fips_is_operational ())
     740           0 :     return gpg_error (fips_not_operational ());
     741             : 
     742          20 :   return gcry_error (_gcry_cipher_setctr (hd, ctr, ctrlen));
     743             : }
     744             : 
     745             : gcry_error_t
     746       51429 : gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf, size_t abuflen)
     747             : {
     748       51429 :   if (!fips_is_operational ())
     749           0 :     return gpg_error (fips_not_operational ());
     750             : 
     751       51429 :   return gpg_error (_gcry_cipher_authenticate (hd, abuf, abuflen));
     752             : }
     753             : 
     754             : gcry_error_t
     755      109123 : gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
     756             : {
     757      109123 :   if (!fips_is_operational ())
     758           0 :     return gpg_error (fips_not_operational ());
     759             : 
     760      109123 :   return gpg_error (_gcry_cipher_gettag (hd, outtag, taglen));
     761             : }
     762             : 
     763             : gcry_error_t
     764       42810 : gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
     765             : {
     766       42810 :   if (!fips_is_operational ())
     767           0 :     return gpg_error (fips_not_operational ());
     768             : 
     769       42810 :   return gpg_error (_gcry_cipher_checktag (hd, intag, taglen));
     770             : }
     771             : 
     772             : 
     773             : gcry_error_t
     774      325015 : gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
     775             : {
     776      325015 :   if (!fips_is_operational ())
     777           0 :     return gpg_error (fips_not_operational ());
     778             : 
     779      325015 :   return gpg_error (_gcry_cipher_ctl (h, cmd, buffer, buflen));
     780             : }
     781             : 
     782             : gcry_error_t
     783         452 : gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, size_t *nbytes)
     784             : {
     785         452 :   return gpg_error (_gcry_cipher_info (h, what, buffer, nbytes));
     786             : }
     787             : 
     788             : gcry_error_t
     789         982 : gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
     790             : {
     791         982 :   if (!fips_is_operational ())
     792           0 :     return gpg_error (fips_not_operational ());
     793             : 
     794         982 :   return gpg_error (_gcry_cipher_algo_info (algo, what, buffer, nbytes));
     795             : }
     796             : 
     797             : const char *
     798          72 : gcry_cipher_algo_name (int algorithm)
     799             : {
     800          72 :   return _gcry_cipher_algo_name (algorithm);
     801             : }
     802             : 
     803             : int
     804          24 : gcry_cipher_map_name (const char *name)
     805             : {
     806          24 :   return _gcry_cipher_map_name (name);
     807             : }
     808             : 
     809             : int
     810           0 : gcry_cipher_mode_from_oid (const char *string)
     811             : {
     812           0 :   return _gcry_cipher_mode_from_oid (string);
     813             : }
     814             : 
     815             : gcry_error_t
     816      443098 : gcry_cipher_encrypt (gcry_cipher_hd_t h,
     817             :                      void *out, size_t outsize,
     818             :                      const void *in, size_t inlen)
     819             : {
     820      443098 :   if (!fips_is_operational ())
     821             :     {
     822             :       /* Make sure that the plaintext will never make it to OUT. */
     823           0 :       if (out)
     824           0 :         memset (out, 0x42, outsize);
     825           0 :       return gpg_error (fips_not_operational ());
     826             :     }
     827             : 
     828      443098 :   return gpg_error (_gcry_cipher_encrypt (h, out, outsize, in, inlen));
     829             : }
     830             : 
     831             : gcry_error_t
     832      353563 : gcry_cipher_decrypt (gcry_cipher_hd_t h,
     833             :                      void *out, size_t outsize,
     834             :                      const void *in, size_t inlen)
     835             : {
     836      353563 :   if (!fips_is_operational ())
     837           0 :     return gpg_error (fips_not_operational ());
     838             : 
     839      353563 :   return gpg_error (_gcry_cipher_decrypt (h, out, outsize, in, inlen));
     840             : }
     841             : 
     842             : size_t
     843        3265 : gcry_cipher_get_algo_keylen (int algo)
     844             : {
     845        3265 :   return _gcry_cipher_get_algo_keylen (algo);
     846             : }
     847             : 
     848             : size_t
     849        3481 : gcry_cipher_get_algo_blklen (int algo)
     850             : {
     851        3481 :   return _gcry_cipher_get_algo_blklen (algo);
     852             : }
     853             : 
     854             : gcry_error_t
     855        1388 : gcry_mac_algo_info (int algo, int what, void *buffer, size_t *nbytes)
     856             : {
     857        1388 :   if (!fips_is_operational ())
     858           0 :     return gpg_error (fips_not_operational ());
     859             : 
     860        1388 :   return gpg_error (_gcry_mac_algo_info (algo, what, buffer, nbytes));
     861             : }
     862             : 
     863             : const char *
     864         117 : gcry_mac_algo_name (int algorithm)
     865             : {
     866         117 :   return _gcry_mac_algo_name (algorithm);
     867             : }
     868             : 
     869             : int
     870          39 : gcry_mac_map_name (const char *string)
     871             : {
     872          39 :   return _gcry_mac_map_name (string);
     873             : }
     874             : 
     875             : int
     876         190 : gcry_mac_get_algo (gcry_mac_hd_t hd)
     877             : {
     878         190 :   return _gcry_mac_get_algo (hd);
     879             : }
     880             : 
     881             : unsigned int
     882         229 : gcry_mac_get_algo_maclen (int algo)
     883             : {
     884         229 :   return _gcry_mac_get_algo_maclen (algo);
     885             : }
     886             : 
     887             : unsigned int
     888          78 : gcry_mac_get_algo_keylen (int algo)
     889             : {
     890          78 :   return _gcry_mac_get_algo_keylen (algo);
     891             : }
     892             : 
     893             : gcry_error_t
     894         268 : gcry_mac_open (gcry_mac_hd_t *handle, int algo, unsigned int flags,
     895             :                gcry_ctx_t ctx)
     896             : {
     897         268 :   if (!fips_is_operational ())
     898             :     {
     899           0 :       *handle = NULL;
     900           0 :       return gpg_error (fips_not_operational ());
     901             :     }
     902             : 
     903         268 :   return gpg_error (_gcry_mac_open (handle, algo, flags, ctx));
     904             : }
     905             : 
     906             : void
     907         268 : gcry_mac_close (gcry_mac_hd_t hd)
     908             : {
     909         268 :   _gcry_mac_close (hd);
     910         268 : }
     911             : 
     912             : gcry_error_t
     913         268 : gcry_mac_setkey (gcry_mac_hd_t hd, const void *key, size_t keylen)
     914             : {
     915         268 :   if (!fips_is_operational ())
     916           0 :     return gpg_error (fips_not_operational ());
     917             : 
     918         268 :   return gpg_error (_gcry_mac_setkey (hd, key, keylen));
     919             : }
     920             : 
     921             : gcry_error_t
     922          26 : gcry_mac_setiv (gcry_mac_hd_t hd, const void *iv, size_t ivlen)
     923             : {
     924          26 :   if (!fips_is_operational ())
     925           0 :     return gpg_error (fips_not_operational ());
     926             : 
     927          26 :   return gpg_error (_gcry_mac_setiv (hd, iv, ivlen));
     928             : }
     929             : 
     930             : gcry_error_t
     931     4359897 : gcry_mac_write (gcry_mac_hd_t hd, const void *buf, size_t buflen)
     932             : {
     933     4359897 :   if (!fips_is_operational ())
     934           0 :     return gpg_error (fips_not_operational ());
     935             : 
     936     4359897 :   return gpg_error (_gcry_mac_write (hd, buf, buflen));
     937             : }
     938             : 
     939             : gcry_error_t
     940       26089 : gcry_mac_read (gcry_mac_hd_t hd, void *outbuf, size_t *outlen)
     941             : {
     942       26089 :   if (!fips_is_operational ())
     943           0 :     return gpg_error (fips_not_operational ());
     944             : 
     945       26089 :   return gpg_error (_gcry_mac_read (hd, outbuf, outlen));
     946             : }
     947             : 
     948             : gcry_error_t
     949         190 : gcry_mac_verify (gcry_mac_hd_t hd, const void *buf, size_t buflen)
     950             : {
     951         190 :   if (!fips_is_operational ())
     952           0 :     return gpg_error (fips_not_operational ());
     953             : 
     954         190 :   return gpg_error (_gcry_mac_verify (hd, buf, buflen));
     955             : }
     956             : 
     957             : gcry_error_t
     958       25860 : gcry_mac_ctl (gcry_mac_hd_t h, int cmd, void *buffer, size_t buflen)
     959             : {
     960       25860 :   if (!fips_is_operational ())
     961           0 :     return gpg_error (fips_not_operational ());
     962             : 
     963       25860 :   return gpg_error (_gcry_mac_ctl (h, cmd, buffer, buflen));
     964             : }
     965             : 
     966             : gcry_error_t
     967         611 : gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey)
     968             : {
     969         611 :   if (!fips_is_operational ())
     970             :     {
     971           0 :       *result = NULL;
     972           0 :       return gpg_error (fips_not_operational ());
     973             :     }
     974         611 :   return gpg_error (_gcry_pk_encrypt (result, data, pkey));
     975             : }
     976             : 
     977             : gcry_error_t
     978         554 : gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
     979             : {
     980         554 :   if (!fips_is_operational ())
     981             :     {
     982           0 :       *result = NULL;
     983           0 :       return gpg_error (fips_not_operational ());
     984             :     }
     985         554 :   return gpg_error (_gcry_pk_decrypt (result, data, skey));
     986             : }
     987             : 
     988             : gcry_error_t
     989        1805 : gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
     990             : {
     991        1805 :   if (!fips_is_operational ())
     992             :     {
     993           0 :       *result = NULL;
     994           0 :       return gpg_error (fips_not_operational ());
     995             :     }
     996        1805 :   return gpg_error (_gcry_pk_sign (result, data, skey));
     997             : }
     998             : 
     999             : gcry_error_t
    1000        1844 : gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey)
    1001             : {
    1002        1844 :   if (!fips_is_operational ())
    1003           0 :     return gpg_error (fips_not_operational ());
    1004        1844 :   return gpg_error (_gcry_pk_verify (sigval, data, pkey));
    1005             : }
    1006             : 
    1007             : gcry_error_t
    1008          28 : gcry_pk_testkey (gcry_sexp_t key)
    1009             : {
    1010          28 :   if (!fips_is_operational ())
    1011           0 :     return gpg_error (fips_not_operational ());
    1012          28 :   return gpg_error (_gcry_pk_testkey (key));
    1013             : }
    1014             : 
    1015             : gcry_error_t
    1016          80 : gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
    1017             : {
    1018          80 :   if (!fips_is_operational ())
    1019             :     {
    1020           0 :       *r_key = NULL;
    1021           0 :       return gpg_error (fips_not_operational ());
    1022             :     }
    1023          80 :   return gpg_error (_gcry_pk_genkey (r_key, s_parms));
    1024             : }
    1025             : 
    1026             : gcry_error_t
    1027           0 : gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
    1028             : {
    1029           0 :   return gpg_error (_gcry_pk_ctl (cmd, buffer, buflen));
    1030             : }
    1031             : 
    1032             : gcry_error_t
    1033          34 : gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes)
    1034             : {
    1035          34 :   if (!fips_is_operational ())
    1036           0 :     return gpg_error (fips_not_operational ());
    1037             : 
    1038          34 :   return gpg_error (_gcry_pk_algo_info (algo, what, buffer, nbytes));
    1039             : }
    1040             : 
    1041             : const char *
    1042           0 : gcry_pk_algo_name (int algorithm)
    1043             : {
    1044           0 :   return _gcry_pk_algo_name (algorithm);
    1045             : }
    1046             : 
    1047             : int
    1048           0 : gcry_pk_map_name (const char *name)
    1049             : {
    1050           0 :   return _gcry_pk_map_name (name);
    1051             : }
    1052             : 
    1053             : unsigned int
    1054           8 : gcry_pk_get_nbits (gcry_sexp_t key)
    1055             : {
    1056           8 :   if (!fips_is_operational ())
    1057             :     {
    1058             :       (void)fips_not_operational ();
    1059           0 :       return 0;
    1060             :     }
    1061             : 
    1062           8 :   return _gcry_pk_get_nbits (key);
    1063             : }
    1064             : 
    1065             : unsigned char *
    1066          12 : gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
    1067             : {
    1068          12 :   if (!fips_is_operational ())
    1069             :     {
    1070             :       (void)fips_not_operational ();
    1071           0 :       return NULL;
    1072             :     }
    1073          12 :   return _gcry_pk_get_keygrip (key, array);
    1074             : }
    1075             : 
    1076             : const char *
    1077          28 : gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
    1078             : {
    1079          28 :   if (!fips_is_operational ())
    1080             :     {
    1081             :       (void)fips_not_operational ();
    1082           0 :       return NULL;
    1083             :     }
    1084          28 :   return _gcry_pk_get_curve (key, iterator, r_nbits);
    1085             : }
    1086             : 
    1087             : gcry_sexp_t
    1088           2 : gcry_pk_get_param (int algo, const char *name)
    1089             : {
    1090           2 :   if (!fips_is_operational ())
    1091             :     {
    1092             :       (void)fips_not_operational ();
    1093           0 :       return NULL;
    1094             :     }
    1095           2 :   return _gcry_pk_get_param (algo, name);
    1096             : }
    1097             : 
    1098             : gcry_error_t
    1099          11 : gcry_pubkey_get_sexp (gcry_sexp_t *r_sexp, int mode, gcry_ctx_t ctx)
    1100             : {
    1101          11 :   if (!fips_is_operational ())
    1102             :     {
    1103           0 :       *r_sexp = NULL;
    1104           0 :       return gpg_error (fips_not_operational ());
    1105             :     }
    1106          11 :   return gpg_error (_gcry_pubkey_get_sexp (r_sexp, mode, ctx));
    1107             : }
    1108             : 
    1109             : gcry_error_t
    1110        1252 : gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
    1111             : {
    1112        1252 :   if (!fips_is_operational ())
    1113             :     {
    1114           0 :       *h = NULL;
    1115           0 :       return gpg_error (fips_not_operational ());
    1116             :     }
    1117             : 
    1118        1252 :   return gpg_error (_gcry_md_open (h, algo, flags));
    1119             : }
    1120             : 
    1121             : void
    1122        2451 : gcry_md_close (gcry_md_hd_t hd)
    1123             : {
    1124        2451 :   _gcry_md_close (hd);
    1125        2451 : }
    1126             : 
    1127             : gcry_error_t
    1128           0 : gcry_md_enable (gcry_md_hd_t hd, int algo)
    1129             : {
    1130           0 :   if (!fips_is_operational ())
    1131           0 :     return gpg_error (fips_not_operational ());
    1132           0 :   return gpg_error (_gcry_md_enable (hd, algo));
    1133             : }
    1134             : 
    1135             : gcry_error_t
    1136        1199 : gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd)
    1137             : {
    1138        1199 :   if (!fips_is_operational ())
    1139             :     {
    1140           0 :       *bhd = NULL;
    1141           0 :       return gpg_error (fips_not_operational ());
    1142             :     }
    1143        1199 :   return gpg_error (_gcry_md_copy (bhd, ahd));
    1144             : }
    1145             : 
    1146             : void
    1147       37034 : gcry_md_reset (gcry_md_hd_t hd)
    1148             : {
    1149       37034 :   _gcry_md_reset (hd);
    1150       37034 : }
    1151             : 
    1152             : gcry_error_t
    1153       37084 : gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
    1154             : {
    1155       37084 :   if (!fips_is_operational ())
    1156           0 :     return gpg_error (fips_not_operational ());
    1157       37084 :   return gpg_error (_gcry_md_ctl (hd, cmd, buffer, buflen));
    1158             : }
    1159             : 
    1160             : void
    1161    25421140 : gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length)
    1162             : {
    1163    25421140 :   if (!fips_is_operational ())
    1164             :     {
    1165             :       (void)fips_not_operational ();
    1166    25421140 :       return;
    1167             :     }
    1168    25421140 :   _gcry_md_write (hd, buffer, length);
    1169             : }
    1170             : 
    1171             : unsigned char *
    1172        1196 : gcry_md_read (gcry_md_hd_t hd, int algo)
    1173             : {
    1174        1196 :   return _gcry_md_read (hd, algo);
    1175             : }
    1176             : 
    1177             : gcry_err_code_t
    1178        8936 : gcry_md_extract (gcry_md_hd_t hd, int algo, void *buffer, size_t length)
    1179             : {
    1180        8936 :   return _gcry_md_extract(hd, algo, buffer, length);
    1181             : }
    1182             : 
    1183             : void
    1184        2745 : gcry_md_hash_buffer (int algo, void *digest,
    1185             :                      const void *buffer, size_t length)
    1186             : {
    1187        2745 :   if (!fips_is_operational ())
    1188             :     {
    1189             :       (void)fips_not_operational ();
    1190           0 :       fips_signal_error ("called in non-operational state");
    1191             :     }
    1192        2745 :   _gcry_md_hash_buffer (algo, digest, buffer, length);
    1193        2745 : }
    1194             : 
    1195             : gpg_error_t
    1196        1123 : gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
    1197             :                       const gcry_buffer_t *iov, int iovcnt)
    1198             : {
    1199        1123 :   if (!fips_is_operational ())
    1200             :     {
    1201             :       (void)fips_not_operational ();
    1202           0 :       fips_signal_error ("called in non-operational state");
    1203             :     }
    1204        1123 :   return gpg_error (_gcry_md_hash_buffers (algo, flags, digest, iov, iovcnt));
    1205             : }
    1206             : 
    1207             : int
    1208           0 : gcry_md_get_algo (gcry_md_hd_t hd)
    1209             : {
    1210           0 :   if (!fips_is_operational ())
    1211             :     {
    1212             :       (void)fips_not_operational ();
    1213           0 :       fips_signal_error ("used in non-operational state");
    1214           0 :       return 0;
    1215             :     }
    1216           0 :   return _gcry_md_get_algo (hd);
    1217             : }
    1218             : 
    1219             : unsigned int
    1220        2504 : gcry_md_get_algo_dlen (int algo)
    1221             : {
    1222        2504 :   return _gcry_md_get_algo_dlen (algo);
    1223             : }
    1224             : 
    1225             : int
    1226           0 : gcry_md_is_enabled (gcry_md_hd_t a, int algo)
    1227             : {
    1228           0 :   if (!fips_is_operational ())
    1229             :     {
    1230             :       (void)fips_not_operational ();
    1231           0 :       return 0;
    1232             :     }
    1233             : 
    1234           0 :   return _gcry_md_is_enabled (a, algo);
    1235             : }
    1236             : 
    1237             : int
    1238           0 : gcry_md_is_secure (gcry_md_hd_t a)
    1239             : {
    1240           0 :   return _gcry_md_is_secure (a);
    1241             : }
    1242             : 
    1243             : gcry_error_t
    1244           0 : gcry_md_info (gcry_md_hd_t h, int what, void *buffer, size_t *nbytes)
    1245             : {
    1246           0 :   if (!fips_is_operational ())
    1247           0 :     return gpg_error (fips_not_operational ());
    1248             : 
    1249           0 :   return gpg_error (_gcry_md_info (h, what, buffer, nbytes));
    1250             : }
    1251             : 
    1252             : gcry_error_t
    1253        4011 : gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
    1254             : {
    1255        4011 :   return gpg_error (_gcry_md_algo_info (algo, what, buffer, nbytes));
    1256             : }
    1257             : 
    1258             : const char *
    1259          94 : gcry_md_algo_name (int algo)
    1260             : {
    1261          94 :   return _gcry_md_algo_name (algo);
    1262             : }
    1263             : 
    1264             : int
    1265          95 : gcry_md_map_name (const char* name)
    1266             : {
    1267          95 :   return _gcry_md_map_name (name);
    1268             : }
    1269             : 
    1270             : gcry_error_t
    1271          35 : gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
    1272             : {
    1273          35 :   if (!fips_is_operational ())
    1274           0 :     return gpg_error (fips_not_operational ());
    1275          35 :   return gpg_error (_gcry_md_setkey (hd, key, keylen));
    1276             : }
    1277             : 
    1278             : void
    1279           0 : gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
    1280             : {
    1281           0 :   _gcry_md_debug (hd, suffix);
    1282           0 : }
    1283             : 
    1284             : gpg_error_t
    1285        6093 : gcry_kdf_derive (const void *passphrase, size_t passphraselen,
    1286             :                  int algo, int hashalgo,
    1287             :                  const void *salt, size_t saltlen,
    1288             :                  unsigned long iterations,
    1289             :                  size_t keysize, void *keybuffer)
    1290             : {
    1291        6093 :   return gpg_error (_gcry_kdf_derive (passphrase, passphraselen, algo, hashalgo,
    1292             :                                       salt, saltlen, iterations,
    1293             :                                       keysize, keybuffer));
    1294             : }
    1295             : 
    1296             : void
    1297         235 : gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
    1298             : {
    1299         235 :   if (!fips_is_operational ())
    1300             :     {
    1301             :       (void)fips_not_operational ();
    1302           0 :       fips_signal_fatal_error ("called in non-operational state");
    1303           0 :       fips_noreturn ();
    1304             :     }
    1305         235 :   _gcry_randomize (buffer, length, level);
    1306         235 : }
    1307             : 
    1308             : gcry_error_t
    1309           0 : gcry_random_add_bytes (const void *buffer, size_t length, int quality)
    1310             : {
    1311           0 :   if (!fips_is_operational ())
    1312           0 :     return gpg_error (fips_not_operational ());
    1313           0 :   return gpg_error (_gcry_random_add_bytes (buffer, length, quality));
    1314             : }
    1315             : 
    1316             : void *
    1317           0 : gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
    1318             : {
    1319           0 :   if (!fips_is_operational ())
    1320             :     {
    1321             :       (void)fips_not_operational ();
    1322           0 :       fips_signal_fatal_error ("called in non-operational state");
    1323           0 :       fips_noreturn ();
    1324             :     }
    1325             : 
    1326           0 :   return _gcry_random_bytes (nbytes,level);
    1327             : }
    1328             : 
    1329             : void *
    1330           0 : gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
    1331             : {
    1332           0 :   if (!fips_is_operational ())
    1333             :     {
    1334             :       (void)fips_not_operational ();
    1335           0 :       fips_signal_fatal_error ("called in non-operational state");
    1336           0 :       fips_noreturn ();
    1337             :     }
    1338             : 
    1339           0 :   return _gcry_random_bytes_secure (nbytes, level);
    1340             : }
    1341             : 
    1342             : void
    1343         128 : gcry_mpi_randomize (gcry_mpi_t w,
    1344             :                     unsigned int nbits, enum gcry_random_level level)
    1345             : {
    1346         128 :   _gcry_mpi_randomize (w, nbits, level);
    1347         128 : }
    1348             : 
    1349             : void
    1350        8019 : gcry_create_nonce (void *buffer, size_t length)
    1351             : {
    1352        8019 :   if (!fips_is_operational ())
    1353             :     {
    1354             :       (void)fips_not_operational ();
    1355           0 :       fips_signal_fatal_error ("called in non-operational state");
    1356           0 :       fips_noreturn ();
    1357             :     }
    1358        8017 :   _gcry_create_nonce (buffer, length);
    1359        8022 : }
    1360             : 
    1361             : gcry_error_t
    1362           2 : gcry_prime_generate (gcry_mpi_t *prime,
    1363             :                      unsigned int prime_bits,
    1364             :                      unsigned int factor_bits,
    1365             :                      gcry_mpi_t **factors,
    1366             :                      gcry_prime_check_func_t cb_func,
    1367             :                      void *cb_arg,
    1368             :                      gcry_random_level_t random_level,
    1369             :                      unsigned int flags)
    1370             : {
    1371           2 :   return gpg_error (_gcry_prime_generate (prime, prime_bits, factor_bits,
    1372             :                                           factors, cb_func, cb_arg,
    1373             :                                           random_level, flags));
    1374             : }
    1375             : 
    1376             : gcry_error_t
    1377           2 : gcry_prime_group_generator (gcry_mpi_t *r_g,
    1378             :                             gcry_mpi_t prime, gcry_mpi_t *factors,
    1379             :                             gcry_mpi_t start_g)
    1380             : {
    1381           2 :   return gpg_error (_gcry_prime_group_generator (r_g, prime, factors, start_g));
    1382             : }
    1383             : 
    1384             : void
    1385           2 : gcry_prime_release_factors (gcry_mpi_t *factors)
    1386             : {
    1387           2 :   _gcry_prime_release_factors (factors);
    1388           2 : }
    1389             : 
    1390             : gcry_error_t
    1391           4 : gcry_prime_check (gcry_mpi_t x, unsigned int flags)
    1392             : {
    1393           4 :   return gpg_error (_gcry_prime_check (x, flags));
    1394             : }
    1395             : 
    1396             : void
    1397          15 : gcry_ctx_release (gcry_ctx_t ctx)
    1398             : {
    1399          15 :   _gcry_ctx_release (ctx);
    1400          15 : }
    1401             : 
    1402             : void
    1403           0 : gcry_log_debug (const char *fmt, ...)
    1404             : {
    1405             :   va_list arg_ptr ;
    1406             : 
    1407           0 :   va_start( arg_ptr, fmt ) ;
    1408           0 :   _gcry_logv (GCRY_LOG_DEBUG, fmt, arg_ptr);
    1409           0 :   va_end (arg_ptr);
    1410           0 : }
    1411             : 
    1412             : void
    1413           0 : gcry_log_debughex (const char *text, const void *buffer, size_t length)
    1414             : {
    1415           0 :   _gcry_log_printhex (text, buffer, length);
    1416           0 : }
    1417             : 
    1418             : void
    1419           0 : gcry_log_debugmpi (const char *text, gcry_mpi_t mpi)
    1420             : {
    1421           0 :   _gcry_log_printmpi (text, mpi);
    1422           0 : }
    1423             : 
    1424             : void
    1425           0 : gcry_log_debugpnt (const char *text, mpi_point_t point, gcry_ctx_t ctx)
    1426             : {
    1427           0 :   mpi_ec_t ec = ctx? _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC) : NULL;
    1428             : 
    1429           0 :   _gcry_mpi_point_log (text, point, ec);
    1430           0 : }
    1431             : 
    1432             : void
    1433           0 : gcry_log_debugsxp (const char *text, gcry_sexp_t sexp)
    1434             : {
    1435           0 :   _gcry_log_printsxp (text, sexp);
    1436           0 : }
    1437             : 
    1438             : void
    1439           1 : gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data)
    1440             : {
    1441           1 :   _gcry_set_progress_handler (cb, cb_data);
    1442           1 : }
    1443             : 
    1444             : void
    1445           0 : gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
    1446             :                              gcry_handler_alloc_t func_alloc_secure,
    1447             :                              gcry_handler_secure_check_t func_secure_check,
    1448             :                              gcry_handler_realloc_t func_realloc,
    1449             :                              gcry_handler_free_t func_free)
    1450             : {
    1451           0 :   _gcry_set_allocation_handler (func_alloc, func_alloc_secure,
    1452             :                                 func_secure_check, func_realloc, func_free);
    1453           0 : }
    1454             : 
    1455             : void
    1456           0 : gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque)
    1457             : {
    1458           0 :   _gcry_set_outofcore_handler (h, opaque);
    1459           0 : }
    1460             : 
    1461             : void
    1462           0 : gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque)
    1463             : {
    1464           0 :   _gcry_set_fatalerror_handler (fnc, opaque);
    1465           0 : }
    1466             : 
    1467             : void
    1468           0 : gcry_set_log_handler (gcry_handler_log_t f, void *opaque)
    1469             : {
    1470           0 :   _gcry_set_log_handler (f, opaque);
    1471           0 : }
    1472             : 
    1473             : void
    1474           0 : gcry_set_gettext_handler (const char *(*f)(const char*))
    1475             : {
    1476           0 :   _gcry_set_gettext_handler (f);
    1477           0 : }
    1478             : 
    1479             : void *
    1480         180 : gcry_malloc (size_t n)
    1481             : {
    1482         180 :   return _gcry_malloc (n);
    1483             : }
    1484             : 
    1485             : void *
    1486           0 : gcry_calloc (size_t n, size_t m)
    1487             : {
    1488           0 :   return _gcry_calloc (n, m);
    1489             : }
    1490             : 
    1491             : void *
    1492           0 : gcry_malloc_secure (size_t n)
    1493             : {
    1494           0 :   return _gcry_malloc_secure (n);
    1495             : }
    1496             : 
    1497             : void *
    1498           0 : gcry_calloc_secure (size_t n, size_t m)
    1499             : {
    1500           0 :   return _gcry_calloc_secure (n,m);
    1501             : }
    1502             : 
    1503             : void *
    1504           0 : gcry_realloc (void *a, size_t n)
    1505             : {
    1506           0 :   return _gcry_realloc (a, n);
    1507             : }
    1508             : 
    1509             : char *
    1510           0 : gcry_strdup (const char *string)
    1511             : {
    1512           0 :   return _gcry_strdup (string);
    1513             : }
    1514             : 
    1515             : void *
    1516       25526 : gcry_xmalloc (size_t n)
    1517             : {
    1518       25526 :   return _gcry_xmalloc (n);
    1519             : }
    1520             : 
    1521             : void *
    1522          24 : gcry_xcalloc (size_t n, size_t m)
    1523             : {
    1524          24 :   return _gcry_xcalloc (n, m);
    1525             : }
    1526             : 
    1527             : void *
    1528           1 : gcry_xmalloc_secure (size_t n)
    1529             : {
    1530           1 :   return _gcry_xmalloc_secure (n);
    1531             : }
    1532             : 
    1533             : void *
    1534           0 : gcry_xcalloc_secure (size_t n, size_t m)
    1535             : {
    1536           0 :   return _gcry_xcalloc_secure (n, m);
    1537             : }
    1538             : 
    1539             : void *
    1540           0 : gcry_xrealloc (void *a, size_t n)
    1541             : {
    1542           0 :   return _gcry_xrealloc (a, n);
    1543             : }
    1544             : 
    1545             : char *
    1546        9242 : gcry_xstrdup (const char *a)
    1547             : {
    1548        9242 :   return _gcry_xstrdup (a);
    1549             : }
    1550             : 
    1551             : void
    1552       41295 : gcry_free (void *a)
    1553             : {
    1554       41295 :   _gcry_free (a);
    1555       41295 : }
    1556             : 
    1557             : int
    1558           1 : gcry_is_secure (const void *a)
    1559             : {
    1560           1 :   return _gcry_is_secure (a);
    1561             : }

Generated by: LCOV version 1.11