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