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