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