Fix building on mingw32
[libgcrypt.git] / src / gcrypt-int.h
1 /* gcrypt-int.h - Internal version of gcrypt.h
2  * Copyright (C) 2013 g10 Code GmbH
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 #ifndef GCRY_GCRYPT_INT_H
21 #define GCRY_GCRYPT_INT_H
22
23 #ifdef _GCRYPT_H
24 #error  gcrypt.h already included
25 #endif
26
27 #include "gcrypt.h"
28 #include "types.h"
29
30 /* These error codes are used but not defined in the required
31    libgpg-error 1.11.  Define them here. */
32 #if GPG_ERROR_VERSION_NUMBER < 0x010c00  /* 1.12 */
33 # define GPG_ERR_NO_CRYPT_CTX       191
34 # define GPG_ERR_WRONG_CRYPT_CTX    192
35 # define GPG_ERR_BAD_CRYPT_CTX      193
36 # define GPG_ERR_CRYPT_CTX_CONFLICT 194
37 # define GPG_ERR_BROKEN_PUBKEY      195
38 # define GPG_ERR_BROKEN_SECKEY      196
39 #endif
40
41 #if GPG_ERROR_VERSION_NUMBER < 0x010d00  /* 1.13 */
42 # define GPG_ERR_MAC_ALGO           197
43 #endif
44
45 \f
46 /* Context used with elliptic curve functions.  */
47 struct mpi_ec_ctx_s;
48 typedef struct mpi_ec_ctx_s *mpi_ec_t;
49
50
51 \f
52 /* Underscore prefixed internal versions of the public functions.
53    They return gpg_err_code and not gpg_error_t.  Some macros also
54    need an underscore prefixed internal version.  */
55
56 gpg_err_code_t _gcry_cipher_open (gcry_cipher_hd_t *handle,
57                                   int algo, int mode, unsigned int flags);
58 void _gcry_cipher_close (gcry_cipher_hd_t h);
59 gpg_err_code_t _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer,
60                              size_t buflen);
61 gpg_err_code_t _gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer,
62                                   size_t *nbytes);
63 gpg_err_code_t _gcry_cipher_algo_info (int algo, int what, void *buffer,
64                                        size_t *nbytes);
65 const char *_gcry_cipher_algo_name (int algorithm) _GCRY_GCC_ATTR_PURE;
66 int _gcry_cipher_map_name (const char *name) _GCRY_GCC_ATTR_PURE;
67 int _gcry_cipher_mode_from_oid (const char *string) _GCRY_GCC_ATTR_PURE;
68 gpg_err_code_t _gcry_cipher_encrypt (gcry_cipher_hd_t h,
69                                      void *out, size_t outsize,
70                                      const void *in, size_t inlen);
71 gpg_err_code_t _gcry_cipher_decrypt (gcry_cipher_hd_t h,
72                                      void *out, size_t outsize,
73                                      const void *in, size_t inlen);
74 gcry_err_code_t _gcry_cipher_setkey (gcry_cipher_hd_t hd,
75                                      const void *key, size_t keylen);
76 gcry_err_code_t _gcry_cipher_setiv (gcry_cipher_hd_t hd,
77                                     const void *iv, size_t ivlen);
78 gpg_err_code_t _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
79                                           size_t abuflen);
80 gpg_err_code_t _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag,
81                                     size_t taglen);
82 gpg_err_code_t _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag,
83                                       size_t taglen);
84 gpg_err_code_t _gcry_cipher_setctr (gcry_cipher_hd_t hd,
85                                     const void *ctr, size_t ctrlen);
86 size_t _gcry_cipher_get_algo_keylen (int algo);
87 size_t _gcry_cipher_get_algo_blklen (int algo);
88
89 #define _gcry_cipher_reset(h)  _gcry_cipher_ctl ((h), GCRYCTL_RESET, NULL, 0)
90
91
92
93 \f
94 gpg_err_code_t _gcry_pk_encrypt (gcry_sexp_t *result,
95                                  gcry_sexp_t data, gcry_sexp_t pkey);
96 gpg_err_code_t _gcry_pk_decrypt (gcry_sexp_t *result,
97                                  gcry_sexp_t data, gcry_sexp_t skey);
98 gpg_err_code_t _gcry_pk_sign (gcry_sexp_t *result,
99                               gcry_sexp_t data, gcry_sexp_t skey);
100 gpg_err_code_t _gcry_pk_verify (gcry_sexp_t sigval,
101                                 gcry_sexp_t data, gcry_sexp_t pkey);
102 gpg_err_code_t _gcry_pk_testkey (gcry_sexp_t key);
103 gpg_err_code_t _gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms);
104 gpg_err_code_t _gcry_pk_ctl (int cmd, void *buffer, size_t buflen);
105 gpg_err_code_t _gcry_pk_algo_info (int algo, int what,
106                                    void *buffer, size_t *nbytes);
107 const char *_gcry_pk_algo_name (int algorithm) _GCRY_GCC_ATTR_PURE;
108 int _gcry_pk_map_name (const char* name) _GCRY_GCC_ATTR_PURE;
109 unsigned int _gcry_pk_get_nbits (gcry_sexp_t key) _GCRY_GCC_ATTR_PURE;
110 unsigned char *_gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array);
111 const char *_gcry_pk_get_curve (gcry_sexp_t key, int iterator,
112                                 unsigned int *r_nbits);
113 gcry_sexp_t _gcry_pk_get_param (int algo, const char *name);
114 gpg_err_code_t _gcry_pubkey_get_sexp (gcry_sexp_t *r_sexp,
115                                       int mode, gcry_ctx_t ctx);
116
117 \f
118 gpg_err_code_t _gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags);
119 void _gcry_md_close (gcry_md_hd_t hd);
120 gpg_err_code_t _gcry_md_enable (gcry_md_hd_t hd, int algo);
121 gpg_err_code_t _gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd);
122 void _gcry_md_reset (gcry_md_hd_t hd);
123 gpg_err_code_t _gcry_md_ctl (gcry_md_hd_t hd, int cmd,
124                           void *buffer, size_t buflen);
125 void _gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length);
126 unsigned char *_gcry_md_read (gcry_md_hd_t hd, int algo);
127 void _gcry_md_hash_buffer (int algo, void *digest,
128                            const void *buffer, size_t length);
129 gpg_err_code_t _gcry_md_hash_buffers (int algo, unsigned int flags,
130                                       void *digest,
131                                       const gcry_buffer_t *iov, int iovcnt);
132 int _gcry_md_get_algo (gcry_md_hd_t hd);
133 unsigned int _gcry_md_get_algo_dlen (int algo);
134 int _gcry_md_is_enabled (gcry_md_hd_t a, int algo);
135 int _gcry_md_is_secure (gcry_md_hd_t a);
136 gpg_err_code_t _gcry_md_info (gcry_md_hd_t h, int what, void *buffer,
137                           size_t *nbytes);
138 gpg_err_code_t _gcry_md_algo_info (int algo, int what, void *buffer,
139                                 size_t *nbytes);
140 const char *_gcry_md_algo_name (int algo) _GCRY_GCC_ATTR_PURE;
141 int _gcry_md_map_name (const char* name) _GCRY_GCC_ATTR_PURE;
142 gpg_err_code_t _gcry_md_setkey (gcry_md_hd_t hd,
143                                 const void *key, size_t keylen);
144 void _gcry_md_debug (gcry_md_hd_t hd, const char *suffix);
145
146 #define _gcry_md_test_algo(a) \
147             _gcry_md_algo_info ((a), GCRYCTL_TEST_ALGO, NULL, NULL)
148
149 #define _gcry_md_final(a) \
150             _gcry_md_ctl ((a), GCRYCTL_FINALIZE, NULL, 0)
151
152 #define _gcry_md_putc(h,c)  \
153             do {                                          \
154                 gcry_md_hd_t h__ = (h);                   \
155                 if( (h__)->bufpos == (h__)->bufsize )     \
156                     _gcry_md_write( (h__), NULL, 0 );     \
157                 (h__)->buf[(h__)->bufpos++] = (c) & 0xff; \
158             } while(0)
159
160
161 \f
162 gpg_err_code_t _gcry_mac_open (gcry_mac_hd_t *handle, int algo,
163                             unsigned int flags, gcry_ctx_t ctx);
164 void _gcry_mac_close (gcry_mac_hd_t h);
165 gpg_err_code_t _gcry_mac_ctl (gcry_mac_hd_t h, int cmd, void *buffer,
166                            size_t buflen);
167 gpg_err_code_t _gcry_mac_algo_info (int algo, int what, void *buffer,
168                                  size_t *nbytes);
169 gpg_err_code_t _gcry_mac_setkey (gcry_mac_hd_t hd, const void *key,
170                               size_t keylen);
171 gpg_err_code_t _gcry_mac_setiv (gcry_mac_hd_t hd, const void *iv,
172                              size_t ivlen);
173 gpg_err_code_t _gcry_mac_write (gcry_mac_hd_t hd, const void *buffer,
174                              size_t length);
175 gpg_err_code_t _gcry_mac_read (gcry_mac_hd_t hd, void *buffer, size_t *buflen);
176 gpg_err_code_t _gcry_mac_verify (gcry_mac_hd_t hd, const void *buffer,
177                                  size_t buflen);
178 unsigned int _gcry_mac_get_algo_maclen (int algo);
179 unsigned int _gcry_mac_get_algo_keylen (int algo);
180 const char *_gcry_mac_algo_name (int algorithm) _GCRY_GCC_ATTR_PURE;
181 int _gcry_mac_map_name (const char *name) _GCRY_GCC_ATTR_PURE;
182
183 #define _gcry_mac_reset(h)  _gcry_mac_ctl ((h), GCRYCTL_RESET, NULL, 0)
184
185 \f
186 gpg_err_code_t _gcry_kdf_derive (const void *passphrase, size_t passphraselen,
187                                  int algo, int subalgo,
188                                  const void *salt, size_t saltlen,
189                                  unsigned long iterations,
190                                  size_t keysize, void *keybuffer);
191
192 \f
193 gpg_err_code_t _gcry_prime_generate (gcry_mpi_t *prime,
194                                      unsigned int prime_bits,
195                                      unsigned int factor_bits,
196                                      gcry_mpi_t **factors,
197                                      gcry_prime_check_func_t cb_func,
198                                      void *cb_arg,
199                                      gcry_random_level_t random_level,
200                                      unsigned int flags);
201 gpg_err_code_t _gcry_prime_group_generator (gcry_mpi_t *r_g,
202                                             gcry_mpi_t prime,
203                                             gcry_mpi_t *factors,
204                                             gcry_mpi_t start_g);
205 void _gcry_prime_release_factors (gcry_mpi_t *factors);
206 gpg_err_code_t _gcry_prime_check (gcry_mpi_t x, unsigned int flags);
207
208 \f
209 void _gcry_randomize (void *buffer, size_t length,
210                       enum gcry_random_level level);
211 gpg_err_code_t _gcry_random_add_bytes (const void *buffer, size_t length,
212                                     int quality);
213 void *_gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
214                          _GCRY_GCC_ATTR_MALLOC;
215 void *_gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
216                                 _GCRY_GCC_ATTR_MALLOC;
217 void _gcry_mpi_randomize (gcry_mpi_t w,
218                          unsigned int nbits, enum gcry_random_level level);
219 void _gcry_create_nonce (void *buffer, size_t length);
220
221 \f
222 void _gcry_ctx_release (gcry_ctx_t ctx);
223
224 \f
225 const char *_gcry_check_version (const char *req_version);
226
227 void _gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
228                                   gcry_handler_alloc_t func_alloc_secure,
229                                   gcry_handler_secure_check_t func_secure_check,
230                                   gcry_handler_realloc_t func_realloc,
231                                   gcry_handler_free_t func_free);
232 void _gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque);
233 void _gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque);
234 void _gcry_set_log_handler (gcry_handler_log_t f, void *opaque);
235 void _gcry_set_gettext_handler (const char *(*f)(const char*));
236 void _gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data);
237
238 \f
239 /* Return a pointer to a string containing a description of the error
240    code in the error value ERR.  */
241 static inline const char *
242 _gcry_strerror (gcry_error_t err)
243 {
244   return gpg_strerror (err);
245 }
246
247 /* Return a pointer to a string containing a description of the error
248    source in the error value ERR.  */
249 static inline const char *
250 _gcry_strsource (gcry_error_t err)
251 {
252   return gpg_strsource (err);
253 }
254
255 /* Retrieve the error code for the system error ERR.  This returns
256    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
257    this).  */
258 static inline gcry_err_code_t
259 _gcry_err_code_from_errno (int err)
260 {
261   return gpg_err_code_from_errno (err);
262 }
263
264 /* Retrieve the system error for the error code CODE.  This returns 0
265    if CODE is not a system error code.  */
266 static inline int
267 _gcry_err_code_to_errno (gcry_err_code_t code)
268 {
269   return gpg_err_code_from_errno (code);
270 }
271
272 /* Return an error value with the error source SOURCE and the system
273    error ERR.  */
274 static inline gcry_err_code_t
275 _gcry_err_make_from_errno (gpg_err_source_t source, int err)
276 {
277   return gpg_err_make_from_errno (source, err);
278 }
279
280
281 /* Return an error value with the system error ERR.  */
282 static inline gcry_err_code_t
283 _gcry_error_from_errno (int err)
284 {
285   return gpg_error (gpg_err_code_from_errno (err));
286 }
287
288
289 \f
290 gpg_err_code_t _gcry_sexp_new (gcry_sexp_t *retsexp,
291                                const void *buffer, size_t length,
292                                int autodetect);
293 gpg_err_code_t _gcry_sexp_create (gcry_sexp_t *retsexp,
294                                   void *buffer, size_t length,
295                                   int autodetect, void (*freefnc) (void *));
296 gpg_err_code_t _gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
297                               const char *buffer, size_t length);
298 gpg_err_code_t _gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
299                                  const char *format, ...);
300 gpg_err_code_t _gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
301                                        const char *format, void **arg_list);
302 void _gcry_sexp_release (gcry_sexp_t sexp);
303 size_t _gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
304                             size_t *erroff, gcry_err_code_t *errcode);
305 size_t _gcry_sexp_sprint (gcry_sexp_t sexp, int mode, void *buffer,
306                           size_t maxlength);
307 void _gcry_sexp_dump (const gcry_sexp_t a);
308 gcry_sexp_t _gcry_sexp_cons (const gcry_sexp_t a, const gcry_sexp_t b);
309 gcry_sexp_t _gcry_sexp_alist (const gcry_sexp_t *array);
310 gcry_sexp_t _gcry_sexp_vlist (const gcry_sexp_t a, ...);
311 gcry_sexp_t _gcry_sexp_append (const gcry_sexp_t a, const gcry_sexp_t n);
312 gcry_sexp_t _gcry_sexp_prepend (const gcry_sexp_t a, const gcry_sexp_t n);
313 gcry_sexp_t _gcry_sexp_find_token (gcry_sexp_t list,
314                                    const char *tok, size_t toklen);
315 int _gcry_sexp_length (const gcry_sexp_t list);
316 gcry_sexp_t _gcry_sexp_nth (const gcry_sexp_t list, int number);
317 gcry_sexp_t _gcry_sexp_car (const gcry_sexp_t list);
318 gcry_sexp_t _gcry_sexp_cdr (const gcry_sexp_t list);
319 gcry_sexp_t _gcry_sexp_cadr (const gcry_sexp_t list);
320 const char *_gcry_sexp_nth_data (const gcry_sexp_t list, int number,
321                                  size_t *datalen);
322 void *_gcry_sexp_nth_buffer (const gcry_sexp_t list, int number,
323                              size_t *rlength);
324 char *_gcry_sexp_nth_string (gcry_sexp_t list, int number);
325 gcry_mpi_t _gcry_sexp_nth_mpi (gcry_sexp_t list, int number, int mpifmt);
326 gpg_err_code_t _gcry_sexp_extract_param (gcry_sexp_t sexp,
327                                          const char *path,
328                                          const char *list,
329                                          ...) _GCRY_GCC_ATTR_SENTINEL(0);
330
331 #define sexp_new(a, b, c, d)         _gcry_sexp_new ((a), (b), (c), (d))
332 #define sexp_create(a, b, c, d, e)   _gcry_sexp_create ((a), (b), (c), (d), (e))
333 #define sexp_sscan(a, b, c, d)       _gcry_sexp_sscan ((a), (b), (c), (d))
334 #define sexp_build                   _gcry_sexp_build
335 #define sexp_build_array(a, b, c, d) _gcry_sexp_build_array ((a), (b), (c), (d))
336 #define sexp_release(a)              _gcry_sexp_release ((a))
337 #define sexp_canon_len(a, b, c, d)   _gcry_sexp_canon_len ((a), (b), (c), (d))
338 #define sexp_sprint(a, b, c, d)      _gcry_sexp_sprint ((a), (b), (c), (d))
339 #define sexp_dump(a)                 _gcry_sexp_dump ((a))
340 #define sexp_cons(a, b)              _gcry_sexp_cons ((a), (b))
341 #define sexp_alist(a)                _gcry_sexp_alist ((a))
342 #define sexp_vlist                   _gcry_sexp_vlist
343 #define sexp_append(a, b)            _gcry_sexp_append ((a), (b))
344 #define sexp_prepend(a, b)           _gcry_sexp_prepend ((a), (b))
345 #define sexp_find_token(a, b, c)     _gcry_sexp_find_token ((a), (b), (c))
346 #define sexp_length(a)               _gcry_sexp_length ((a))
347 #define sexp_nth(a, b)               _gcry_sexp_nth ((a), (b))
348 #define sexp_car(a)                  _gcry_sexp_car ((a))
349 #define sexp_cdr(a)                  _gcry_sexp_cdr ((a))
350 #define sexp_cadr(a)                 _gcry_sexp_cadr ((a))
351 #define sexp_nth_data(a, b, c)       _gcry_sexp_nth_data ((a), (b), (c))
352 #define sexp_nth_buffer(a, b, c)     _gcry_sexp_nth_buffer ((a), (b), (c))
353 #define sexp_nth_string(a, b)        _gcry_sexp_nth_string ((a), (b))
354 #define sexp_nth_mpi(a, b, c)        _gcry_sexp_nth_mpi ((a), (b), (c))
355 #define sexp_extract_param           _gcry_sexp_extract_param
356
357
358 \f
359 gcry_mpi_t _gcry_mpi_new (unsigned int nbits);
360 gcry_mpi_t _gcry_mpi_snew (unsigned int nbits);
361 void _gcry_mpi_release (gcry_mpi_t a);
362 gcry_mpi_t _gcry_mpi_copy (const gcry_mpi_t a);
363 void _gcry_mpi_snatch (gcry_mpi_t w, gcry_mpi_t u);
364 gcry_mpi_t _gcry_mpi_set (gcry_mpi_t w, const gcry_mpi_t u);
365 gcry_mpi_t _gcry_mpi_set_ui (gcry_mpi_t w, unsigned long u);
366 gcry_err_code_t _gcry_mpi_get_ui (gcry_mpi_t w, ulong *u);
367 void _gcry_mpi_swap (gcry_mpi_t a, gcry_mpi_t b);
368 int _gcry_mpi_is_neg (gcry_mpi_t a);
369 void _gcry_mpi_neg (gcry_mpi_t w, gcry_mpi_t u);
370 void _gcry_mpi_abs (gcry_mpi_t w);
371 int _gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v);
372 int _gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v);
373 gpg_err_code_t _gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
374                               const void *buffer, size_t buflen,
375                               size_t *nscanned);
376 gpg_err_code_t _gcry_mpi_print (enum gcry_mpi_format format,
377                                unsigned char *buffer, size_t buflen,
378                                size_t *nwritten,
379                                const gcry_mpi_t a);
380 gpg_err_code_t _gcry_mpi_aprint (enum gcry_mpi_format format,
381                                 unsigned char **buffer, size_t *nwritten,
382                                 const gcry_mpi_t a);
383 void _gcry_mpi_dump (const gcry_mpi_t a);
384 void _gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v);
385 void _gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v);
386 void _gcry_mpi_addm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m);
387 void _gcry_mpi_sub (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v);
388 void _gcry_mpi_sub_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v );
389 void _gcry_mpi_subm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m);
390 void _gcry_mpi_mul (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v);
391 void _gcry_mpi_mul_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v );
392 void _gcry_mpi_mulm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m);
393 void _gcry_mpi_mul_2exp (gcry_mpi_t w, gcry_mpi_t u, unsigned long cnt);
394 void _gcry_mpi_div (gcry_mpi_t q, gcry_mpi_t r,
395                    gcry_mpi_t dividend, gcry_mpi_t divisor, int round);
396 void _gcry_mpi_mod (gcry_mpi_t r, gcry_mpi_t dividend, gcry_mpi_t divisor);
397 void _gcry_mpi_powm (gcry_mpi_t w,
398                     const gcry_mpi_t b, const gcry_mpi_t e,
399                     const gcry_mpi_t m);
400 int _gcry_mpi_gcd (gcry_mpi_t g, gcry_mpi_t a, gcry_mpi_t b);
401 int _gcry_mpi_invm (gcry_mpi_t x, gcry_mpi_t a, gcry_mpi_t m);
402 gcry_mpi_point_t _gcry_mpi_point_new (unsigned int nbits);
403 void _gcry_mpi_point_release (gcry_mpi_point_t point);
404 void _gcry_mpi_point_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
405                          gcry_mpi_point_t point);
406 void _gcry_mpi_point_snatch_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
407                                 gcry_mpi_point_t point);
408 gcry_mpi_point_t _gcry_mpi_point_set (gcry_mpi_point_t point,
409                                      gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z);
410 gcry_mpi_point_t _gcry_mpi_point_snatch_set (gcry_mpi_point_t point,
411                                             gcry_mpi_t x, gcry_mpi_t y,
412                                             gcry_mpi_t z);
413 gpg_error_t _gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
414                              gcry_sexp_t keyparam, const char *curvename);
415 gcry_mpi_t _gcry_mpi_ec_get_mpi (const char *name, gcry_ctx_t ctx, int copy);
416 gcry_mpi_point_t _gcry_mpi_ec_get_point (const char *name,
417                                         gcry_ctx_t ctx, int copy);
418 gpg_error_t _gcry_mpi_ec_set_mpi (const char *name, gcry_mpi_t newvalue,
419                                  gcry_ctx_t ctx);
420 gpg_error_t _gcry_mpi_ec_set_point (const char *name, gcry_mpi_point_t newvalue,
421                                    gcry_ctx_t ctx);
422 int _gcry_mpi_ec_get_affine (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_point_t point,
423                              mpi_ec_t ctx);
424 void _gcry_mpi_ec_dup (gcry_mpi_point_t w, gcry_mpi_point_t u, gcry_ctx_t ctx);
425 void _gcry_mpi_ec_add (gcry_mpi_point_t w,
426                        gcry_mpi_point_t u, gcry_mpi_point_t v, mpi_ec_t ctx);
427 void _gcry_mpi_ec_mul (gcry_mpi_point_t w, gcry_mpi_t n, gcry_mpi_point_t u,
428                        mpi_ec_t ctx);
429 int _gcry_mpi_ec_curve_point (gcry_mpi_point_t w, mpi_ec_t ctx);
430 unsigned int _gcry_mpi_get_nbits (gcry_mpi_t a);
431 int _gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n);
432 void _gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n);
433 void _gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n);
434 void _gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n);
435 void _gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n);
436 void _gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n);
437 void _gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n);
438 gcry_mpi_t _gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits);
439 gcry_mpi_t _gcry_mpi_set_opaque_copy (gcry_mpi_t a,
440                                      const void *p, unsigned int nbits);
441 void *_gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits);
442 void _gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag);
443 void _gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag);
444 int _gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag);
445
446
447 /* Private function - do not use.  */
448 /* gcry_mpi_t _gcry_mpi_get_const (int no); */
449
450 /* We need our internal versions of the macros.  */
451 #ifndef GCRYPT_NO_MPI_MACROS
452 # error GCRYPT_NO_MPI_MACROS is not defined
453 #endif
454
455 #define mpi_new(n)             _gcry_mpi_new ((n))
456 #define mpi_secure_new( n )    _gcry_mpi_snew ((n))
457 #define mpi_snew(n)            _gcry_mpi_snew ((n))
458
459 #define mpi_release(a)        \
460   do                          \
461     {                         \
462       _gcry_mpi_release ((a));\
463       (a) = NULL;             \
464     }                         \
465   while (0)
466
467 #define mpi_snatch( w, u)      _gcry_mpi_snatch( (w), (u) )
468 #define mpi_set( w, u)         _gcry_mpi_set( (w), (u) )
469 #define mpi_set_ui( w, u)      _gcry_mpi_set_ui( (w), (u) )
470 #define mpi_get_ui(a,b)        _gcry_mpi_get_ui( (a), (b) )
471 #define mpi_swap(a,b)          _gcry_mpi_swap ((a),(b))
472 #define mpi_abs( w )           _gcry_mpi_abs( (w) )
473 #define mpi_neg( w, u)         _gcry_mpi_neg( (w), (u) )
474 #define mpi_cmp( u, v )        _gcry_mpi_cmp( (u), (v) )
475 #define mpi_cmp_ui( u, v )     _gcry_mpi_cmp_ui( (u), (v) )
476 #define mpi_is_neg( a )        _gcry_mpi_is_neg ((a))
477
478 #define mpi_add_ui(w,u,v)      _gcry_mpi_add_ui((w),(u),(v))
479 #define mpi_add(w,u,v)         _gcry_mpi_add ((w),(u),(v))
480 #define mpi_addm(w,u,v,m)      _gcry_mpi_addm ((w),(u),(v),(m))
481 #define mpi_sub_ui(w,u,v)      _gcry_mpi_sub_ui ((w),(u),(v))
482 #define mpi_sub(w,u,v)         _gcry_mpi_sub ((w),(u),(v))
483 #define mpi_subm(w,u,v,m)      _gcry_mpi_subm ((w),(u),(v),(m))
484 #define mpi_mul_ui(w,u,v)      _gcry_mpi_mul_ui ((w),(u),(v))
485 #define mpi_mul_2exp(w,u,v)    _gcry_mpi_mul_2exp ((w),(u),(v))
486 #define mpi_mul(w,u,v)         _gcry_mpi_mul ((w),(u),(v))
487 #define mpi_mulm(w,u,v,m)      _gcry_mpi_mulm ((w),(u),(v),(m))
488 #define mpi_powm(w,b,e,m)      _gcry_mpi_powm ( (w), (b), (e), (m) )
489 #define mpi_tdiv(q,r,a,m)      _gcry_mpi_div ( (q), (r), (a), (m), 0)
490 #define mpi_fdiv(q,r,a,m)      _gcry_mpi_div ( (q), (r), (a), (m), -1)
491 #define mpi_mod(r,a,m)         _gcry_mpi_mod ((r), (a), (m))
492 #define mpi_gcd(g,a,b)         _gcry_mpi_gcd ( (g), (a), (b) )
493 #define mpi_invm(g,a,b)        _gcry_mpi_invm ( (g), (a), (b) )
494
495 #define mpi_point_new(n)       _gcry_mpi_point_new((n))
496
497 #define mpi_point_release(p)                     \
498   do                                             \
499     {                                            \
500       _gcry_mpi_point_release ((p));             \
501       (p) = NULL;                                \
502     }                                            \
503   while (0)
504
505 #define mpi_point_get(x,y,z,p)        _gcry_mpi_point_get((x),(y),(z),(p))
506 #define mpi_point_snatch_get(x,y,z,p) _gcry_mpi_point_snatch_get((x),(y), \
507                                                                  (z),(p))
508 #define mpi_point_set(p,x,y,z)        _gcry_mpi_point_set((p),(x),(y),(z))
509 #define mpi_point_snatch_set(p,x,y,z) _gcry_mpi_point_snatch_set((p),(x), \
510                                                                  (y),(z))
511
512 #define mpi_get_nbits(a)       _gcry_mpi_get_nbits ((a))
513 #define mpi_test_bit(a,b)      _gcry_mpi_test_bit ((a),(b))
514 #define mpi_set_bit(a,b)       _gcry_mpi_set_bit ((a),(b))
515 #define mpi_set_highbit(a,b)   _gcry_mpi_set_highbit ((a),(b))
516 #define mpi_clear_bit(a,b)     _gcry_mpi_clear_bit ((a),(b))
517 #define mpi_clear_highbit(a,b) _gcry_mpi_clear_highbit ((a),(b))
518 #define mpi_rshift(a,b,c)      _gcry_mpi_rshift ((a),(b),(c))
519 #define mpi_lshift(a,b,c)      _gcry_mpi_lshift ((a),(b),(c))
520
521 #define mpi_set_opaque(a,b,c)  _gcry_mpi_set_opaque ((a), (b), (c))
522 #define mpi_get_opaque(a,b)    _gcry_mpi_get_opaque ((a), (b))
523 #define mpi_set_flag(a,f)      _gcry_mpi_set_flag ((a), (f))
524 #define mpi_set_flag(a,f)      _gcry_mpi_set_flag ((a), (f))
525 #define mpi_clear_flag(a,f)    _gcry_mpi_clear_flag ((a), (f))
526 #define mpi_get_flag(a,f)      _gcry_mpi_get_flag ((a), (f))
527
528
529 #endif /*GCRY_GCRYPT_INT_H*/