2003-07-15 Moritz Schulte <moritz@g10code.com>
authorMoritz Schulte <mo@g10code.com>
Mon, 14 Jul 2003 22:33:41 +0000 (22:33 +0000)
committerMoritz Schulte <mo@g10code.com>
Mon, 14 Jul 2003 22:33:41 +0000 (22:33 +0000)
* gcrypt.h: Bumped version number up to 1.1.42-cvs.

2003-07-14  Moritz Schulte  <moritz@g10code.com>

* gcrypt.h (gcry_cipher_spec): New member: aliases.

* Makefile.am (noinst_PROGRAMS, testapi_SOURCES, testapai_LDADD,
benchmark_SOURCES, benchmark_LDADD): Removed.

* benchmark.c, testapi.c: Removed files.

* mpi.h: Removed disabled typedef.
* g10lib.h: Likewise.

* benchmark.c, g10lib.h, gcrypt.h, global.c, module.c, sexp.c:
Used gcry_err* wrappers for libgpg-error symbols.

2003-07-12  Moritz Schulte  <moritz@g10code.com>

* global.c: Likewise.

* gcrypt.h: New type: gcry_error_t, gcry_err_code_t and
gcry_err_source_t.
(gcry_err_make, gcry_error, gcry_err_code, gcry_err_source): New
functions.

* global.c (gcry_strerror): New function.
(gcry_strsource): New function.

* gcrypt.h: New symbol: GCRY_CIPHER_TWOFISH128.

2003-07-09  Moritz Schulte  <moritz@g10code.com>

* gcrypt.h (enum gcry_md_flags): Removed, used define instead,
since that is more common than an enumeration list when it comes
to flags that can be bitwise ORed.

src/ChangeLog
src/Makefile.am
src/g10lib.h
src/gcrypt.h
src/global.c
src/module.c
src/mpi.h
src/sexp.c

index 3057c41..5537aee 100644 (file)
@@ -1,3 +1,42 @@
+2003-07-15  Moritz Schulte  <moritz@g10code.com>
+
+       * gcrypt.h: Bumped version number up to 1.1.42-cvs.
+
+2003-07-14  Moritz Schulte  <moritz@g10code.com>
+
+       * gcrypt.h (gcry_cipher_spec): New member: aliases.
+
+       * Makefile.am (noinst_PROGRAMS, testapi_SOURCES, testapai_LDADD,
+       benchmark_SOURCES, benchmark_LDADD): Removed.
+
+       * benchmark.c, testapi.c: Removed files.
+
+       * mpi.h: Removed disabled typedef.
+       * g10lib.h: Likewise.
+
+       * benchmark.c, g10lib.h, gcrypt.h, global.c, module.c, sexp.c:
+       Used gcry_err* wrappers for libgpg-error symbols.
+
+2003-07-12  Moritz Schulte  <moritz@g10code.com>
+
+       * global.c: Likewise.
+
+       * gcrypt.h: New type: gcry_error_t, gcry_err_code_t and
+       gcry_err_source_t.
+       (gcry_err_make, gcry_error, gcry_err_code, gcry_err_source): New
+       functions.
+
+       * global.c (gcry_strerror): New function.
+       (gcry_strsource): New function.
+
+       * gcrypt.h: New symbol: GCRY_CIPHER_TWOFISH128.
+
+2003-07-09  Moritz Schulte  <moritz@g10code.com>
+
+       * gcrypt.h (enum gcry_md_flags): Removed, used define instead,
+       since that is more common than an enumeration list when it comes
+       to flags that can be bitwise ORed.
+       
 2003-07-08  Moritz Schulte  <moritz@g10code.com>
 
        * global.c: Use new types for handlers.
index ea28e53..e01ef31 100644 (file)
@@ -33,13 +33,6 @@ bin_SCRIPTS = libgcrypt-config
 m4datadir = $(datadir)/aclocal
 m4data_DATA = libgcrypt.m4
 
-noinst_PROGRAMS = testapi benchmark
-testapi_SOURCES = testapi.c
-testapi_LDADD = libgcrypt.la
-
-benchmark_SOURCES = benchmark.c
-benchmark_LDADD = libgcrypt.la
-
 include_HEADERS = gcrypt.h
 
 if HAVE_PTHREAD
index 307fee6..91520c9 100644 (file)
@@ -116,13 +116,6 @@ int _gcry_log_verbosity( int level );
 
 /*-- cipher/pubkey.c --*/
 
-#if 0
-#ifndef DID_MPI_TYPEDEF
- typedef struct gcry_mpi * MPI;
-#define DID_MPI_TYPEDEF
-#endif
-#endif
-
 #ifndef mpi_powm
 #define mpi_powm(w,b,e,m)   gcry_mpi_powm( (w), (b), (e), (m) )
 #endif
@@ -138,8 +131,6 @@ gcry_mpi_t _gcry_generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
                                           gcry_mpi_t g, gcry_mpi_t **factors );
 
 
-
-
 /* replacements of missing functions (missing-string.c)*/
 #ifndef HAVE_STPCPY
 char *stpcpy (char *a, const char *b);
@@ -148,7 +139,6 @@ char *stpcpy (char *a, const char *b);
 int strcasecmp (const char *a, const char *b) GCC_ATTR_PURE;
 #endif
 
-
 /* macros used to rename missing functions */
 #ifndef HAVE_STRTOUL
 #define strtoul(a,b,c)  ((unsigned long)strtol((a),(b),(c)))
@@ -205,7 +195,7 @@ struct gcry_module
 /* Flags for the `flags' member of gcry_module_t.  */
 #define FLAG_MODULE_DISABLED 1 << 0
 
-gpg_err_code_t _gcry_module_add (gcry_module_t *entries,
+gcry_err_code_t _gcry_module_add (gcry_module_t *entries,
                                 unsigned int id,
                                 void *spec,
                                 gcry_module_t *module);
@@ -229,14 +219,14 @@ void _gcry_module_release (gcry_module_t entry);
 void _gcry_module_use (gcry_module_t module);
 
 /* Return a list of module IDs.  */
-gpg_err_code_t _gcry_module_list (gcry_module_t modules,
+gcry_err_code_t _gcry_module_list (gcry_module_t modules,
                                  int *list, int *list_length);
 
-gpg_err_code_t _gcry_cipher_init (void);
-gpg_err_code_t _gcry_md_init (void);
-gpg_err_code_t _gcry_pk_init (void);
+gcry_err_code_t _gcry_cipher_init (void);
+gcry_err_code_t _gcry_md_init (void);
+gcry_err_code_t _gcry_pk_init (void);
 
-gpg_err_code_t _gcry_pk_module_lookup (int id, gcry_module_t *module);
+gcry_err_code_t _gcry_pk_module_lookup (int id, gcry_module_t *module);
 void _gcry_pk_module_release (gcry_module_t module);
 
 #endif /* G10LIB_H */
index acc6044..6a6ebcb 100644 (file)
@@ -42,7 +42,7 @@ extern "C" {
    autoconf (using the AM_PATH_GCRYPT macro) check that this header
    matches the installed library.  Note: Do not edit the next line as
    configure may fix the string here.  */
-#define GCRYPT_VERSION "1.1.13-cvs"
+#define GCRYPT_VERSION "1.1.42-cvs"
 
 /* Internal: We can't use the convenience macros for the multi
    precision integer functions when building this library. */
@@ -85,6 +85,51 @@ extern "C" {
 #define _GCRY_GCC_ATTR_MALLOC
 #endif
 
+/* Wrappers for the libgpg-error library.  */
+
+typedef gpg_error_t gcry_error_t;
+typedef gpg_err_code_t gcry_err_code_t;
+typedef gpg_err_source_t gcry_err_source_t;
+
+static __inline__ gcry_error_t
+gcry_err_make (gcry_err_source_t source, gcry_err_code_t code)
+{
+  return gpg_err_make (source, code);
+}
+
+/* The user can define GPG_ERR_SOURCE_DEFAULT before including this
+   file to specify a default source for gpg_error.  */
+#ifndef GCRY_ERR_SOURCE_DEFAULT
+#define GCRY_ERR_SOURCE_DEFAULT  GPG_ERR_SOURCE_USER_1
+#endif
+
+static __inline__ gcry_error_t
+gcry_error (gcry_err_code_t code)
+{
+  return gcry_err_make (GCRY_ERR_SOURCE_DEFAULT, code);
+}
+
+static __inline__ gcry_err_code_t
+gcry_err_code (gcry_error_t err)
+{
+  return gpg_err_code (err);
+}
+
+
+static __inline__ gcry_err_source_t
+gcry_err_source (gcry_error_t err)
+{
+  return gpg_err_source (err);
+}
+
+/* Return a pointer to a string containing a description of the error
+   code in the error value ERR.  */
+const char * gcry_strerror (gcry_error_t err);
+
+/* Return a pointer to a string containing a description of the error
+   source in the error value ERR.  */
+const char *gcry_strsource (gcry_error_t err);
+
 /* The data object used to hold a multi precision integer.  */
 struct gcry_mpi;
 typedef struct gcry_mpi *gcry_mpi_t;
@@ -100,12 +145,6 @@ typedef struct gcry_module *gcry_module_t;
 /* Check that the library fulfills the version requirement.  */
 const char *gcry_check_version (const char *req_version);
 
-#if 0
-/* FIXME.  */
-/* Map an error number to a string. */
-const char *gcry_strerror (gpg_error_t ec);
-#endif
-
 /* Codes for function dispatchers.  */
 
 /* Codes used with the gcry_control function. */
@@ -157,8 +196,9 @@ enum gcry_ctl_cmds
   };
 
 /* Perform various operations defined by CMD. */
-gpg_error_t gcry_control (enum gcry_ctl_cmds CMD, ...);
+gcry_error_t gcry_control (enum gcry_ctl_cmds CMD, ...);
 
+const char *gcry_strerror (gcry_error_t ec);
 
 \f
 /* S-expression management. */ 
@@ -183,27 +223,27 @@ enum gcry_sexp_format
 /* Create an new S-expression object from BUFFER of size LENGTH and
    return it in RETSEXP.  With AUTODETECT set to 0 the data in BUFFER
    is expected to be in canonized format.  */
-gpg_error_t gcry_sexp_new (gcry_sexp_t *retsexp, const void *buffer, size_t length,
+gcry_error_t gcry_sexp_new (gcry_sexp_t *retsexp, const void *buffer, size_t length,
                           int autodetect);
 
  /* Same as gcry_sexp_new but allows to pass a FREEFNC which has the
    effect to transfer ownership of BUFFER to the created object.  */
-gpg_error_t gcry_sexp_create (gcry_sexp_t *retsexp, void *buffer, size_t length,
+gcry_error_t gcry_sexp_create (gcry_sexp_t *retsexp, void *buffer, size_t length,
                              int autodetect, void (*freefnc) (void *));
 
 /* Scan BUFFER and return a new S-expression object in RETSEXP.  This
    function expects a printf like string in BUFFER.  */
-gpg_error_t gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
+gcry_error_t gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
                             const char *buffer, size_t length);
 
 /* Same as gcry_sexp_sscan but expects a string in FORMAT and can thus
    only be used for certain encodings.  */
-gpg_error_t gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
+gcry_error_t gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
                             const char *format, ...);
 
 /* Like gcry_sexp_build, but uses an array instead of variable
    function arguments.  */
-gpg_error_t gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
+gcry_error_t gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
                                   const char *format, void **arg_list);
 
 /* Release the S-expression object SEXP */
@@ -212,7 +252,7 @@ void gcry_sexp_release (gcry_sexp_t sexp);
 /* Calculate the length of an canonized S-expresion in BUFFER and
    check for a valid encoding. */
 size_t gcry_sexp_canon_len (const unsigned char *buffer, size_t length, 
-                            size_t *erroff, gpg_error_t *errcode);
+                            size_t *erroff, gcry_error_t *errcode);
 
 /* Copies the S-expression object SEXP into BUFFER using the format
    specified in MODE.  */
@@ -342,21 +382,21 @@ int gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v);
    For certain formats a length is not required and may be passed as
    NULL.  After a successful operation NBYTES received the number of
    bytes actually scanned. */
-gpg_error_t gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
+gcry_error_t gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
                    const char *buffer, size_t *nbytes);
 
 /* Convert the big integer A into the external representation
    described by FORMAT and store it in the provided BUFFER which has
    the size (*NBYTES).  NBYTES receives the actual length of the
    external representation. */
-gpg_error_t gcry_mpi_print (enum gcry_mpi_format format,
+gcry_error_t gcry_mpi_print (enum gcry_mpi_format format,
                            char *buffer, size_t *nbytes, const gcry_mpi_t a);
 
 /* Convert the big integer A int the external representation desribed
    by FORMAT and store it in a newly allocated buffer which address
    will be put into BUFFER.  NBYTES receives the actual lengths of the
    external representation. */
-gpg_error_t gcry_mpi_aprint (enum gcry_mpi_format format,
+gcry_error_t gcry_mpi_aprint (enum gcry_mpi_format format,
                             void **buffer, size_t *nbytes, const gcry_mpi_t a);
 
 /* W = U + V.  */
@@ -534,9 +574,11 @@ enum gcry_cipher_algos
     /* other cipher numbers are above 300 for OpenPGP reasons. */
     GCRY_CIPHER_ARCFOUR     = 301,  /* fully compatible with RSA's RC4 (tm). */
     GCRY_CIPHER_DES         = 302,  /* Yes, this is single key 56 bit DES. */
-    GCRY_CIPHER_SERPENT128  = 303,
-    GCRY_CIPHER_SERPENT192  = 304,
-    GCRY_CIPHER_SERPENT256  = 305,
+    GCRY_CIPHER_TWOFISH128  = 303,
+    GCRY_CIPHER_SERPENT128  = 304,
+    GCRY_CIPHER_SERPENT192  = 305,
+    GCRY_CIPHER_SERPENT256  = 306,
+    
   };
 
 /* The Rijndael algorithm is basically AES, so provide some macros. */
@@ -571,22 +613,22 @@ enum gcry_cipher_flags
 
 /* Create a handle for algorithm ALGO to be used in MODE.  FLAGS may
    be given as an bitwise OR of the gcry_cipher_flags values. */
-gpg_error_t gcry_cipher_open (gcry_cipher_hd_t *handle,
+gcry_error_t gcry_cipher_open (gcry_cipher_hd_t *handle,
                              int algo, int mode, unsigned int flags);
 
 /* Close the cioher handle H and release all resource. */
 void gcry_cipher_close (gcry_cipher_hd_t h);
 
 /* Perform various operations on the cipher object H. */
-gpg_error_t gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer,
+gcry_error_t gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer,
                             size_t buflen);
 
 /* Retrieve various information about the cipher object H. */
-gpg_error_t gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer,
+gcry_error_t gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer,
                              size_t *nbytes);
 
 /* Retrieve various information about the cipher algorithm ALGO. */
-gpg_error_t gcry_cipher_algo_info (int algo, int what, void *buffer,
+gcry_error_t gcry_cipher_algo_info (int algo, int what, void *buffer,
                                   size_t *nbytes);
 
 /* Map the cipher algorithm id ALGO to a string representation of that
@@ -607,12 +649,12 @@ int gcry_cipher_mode_from_oid (const char *string) _GCRY_GCC_ATTR_PURE;
    into the buffer OUT which has an allocated length of OUTSIZE.  For
    most algorithms it is possible to pass NULL for in and 0 for INLEN
    and do a in-place decryption of the data provided in OUT.  */
-gpg_error_t gcry_cipher_encrypt (gcry_cipher_hd_t h,
+gcry_error_t gcry_cipher_encrypt (gcry_cipher_hd_t h,
                                 unsigned char *out, size_t outsize,
                                 const unsigned char *in, size_t inlen);
 
 /* The counterpart to gcry_cipher_encrypt.  */
-gpg_error_t gcry_cipher_decrypt (gcry_cipher_hd_t h,
+gcry_error_t gcry_cipher_decrypt (gcry_cipher_hd_t h,
                                 unsigned char *out, size_t outsize,
                                 const unsigned char *in, size_t inlen);
 
@@ -659,10 +701,10 @@ size_t gcry_cipher_get_algo_blklen (int algo);
    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
    according size.  In case there are less cipher modules than
    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
-gpg_error_t gcry_cipher_list (int *list, int *list_length);
+gcry_error_t gcry_cipher_list (int *list, int *list_length);
 
 /* Type for the cipher_setkey function.  */
-typedef gpg_err_code_t (*gcry_cipher_setkey_t) (void *c,
+typedef gcry_err_code_t (*gcry_cipher_setkey_t) (void *c,
                                                const unsigned char *key,
                                                unsigned keylen);
 
@@ -692,6 +734,7 @@ typedef void (*gcry_cipher_stdecrypt_t) (void *c,
 typedef struct gcry_cipher_spec
 {
   const char *name;
+  const char **aliases;
   size_t blocksize;
   size_t keylen;
   size_t contextsize;
@@ -705,7 +748,7 @@ typedef struct gcry_cipher_spec
 /* Register a new cipher module whose specification can be found in
    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
    and a pointer representhing this module is stored in MODULE.  */
-gpg_error_t gcry_cipher_register (gcry_cipher_spec_t *cipher,
+gcry_error_t gcry_cipher_register (gcry_cipher_spec_t *cipher,
                                  unsigned int *algorithm_id,
                                  gcry_module_t *module);
 
@@ -737,32 +780,32 @@ enum gcry_pk_algos
 
 /* Encrypt the DATA using the public key PKEY and store the result as
    a newly created S-expression at RESULT. */
-gpg_error_t gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey);
+gcry_error_t gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey);
 
 /* Decrypt the DATA using the private key SKEY and store the result as
    a newly created S-expression at RESULT. */
-gpg_error_t gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
+gcry_error_t gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
 
 /* Sign the DATA using the private key SKEY and store the result as
    a newly created S-expression at RESULT. */
-gpg_error_t gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
+gcry_error_t gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey);
 
 /* Check the signature SIGVAL on DATA using the public key PKEY. */
-gpg_error_t gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey);
+gcry_error_t gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey);
 
 /* Check that KEY (either private or public) is sane. */
-gpg_error_t gcry_pk_testkey (gcry_sexp_t key);
+gcry_error_t gcry_pk_testkey (gcry_sexp_t key);
 
 /* Generate a new key pair according to the parameters given in
    S_PARMS.  The new key pair is returned in as an S-expression in
    R_KEY. */
-gpg_error_t gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms);
+gcry_error_t gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms);
 
 /* Catch all function for miscellaneous operations. */
-gpg_error_t gcry_pk_ctl (int cmd, void *buffer, size_t buflen);
+gcry_error_t gcry_pk_ctl (int cmd, void *buffer, size_t buflen);
 
 /* Retrieve information about the public key algorithm ALGO. */
-gpg_error_t gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes);
+gcry_error_t gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes);
 
 /* Map the public key algorithm id ALGO to a string representation of the
    algorithm name.  For unknown algorithms this functions returns an
@@ -791,41 +834,41 @@ unsigned char *gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array);
    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
    according size.  In case there are less pubkey modules than
    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
-gpg_error_t gcry_pk_list (int *list, int *list_length);
+gcry_error_t gcry_pk_list (int *list, int *list_length);
 
 /* Type for the pk_generate function.  */
-typedef gpg_err_code_t (*gcry_pk_generate_t) (int algo,
+typedef gcry_err_code_t (*gcry_pk_generate_t) (int algo,
                                              unsigned int nbits,
                                              unsigned long use_e,
                                              gcry_mpi_t *skey,
                                              gcry_mpi_t **retfactors);
 
 /* Type for the pk_check_secret_key function.  */
-typedef gpg_err_code_t (*gcry_pk_check_secret_key_t) (int algo,
+typedef gcry_err_code_t (*gcry_pk_check_secret_key_t) (int algo,
                                                      gcry_mpi_t *skey);
 
 /* Type for the pk_encrypt function.  */
-typedef gpg_err_code_t (*gcry_pk_encrypt_t) (int algo,
+typedef gcry_err_code_t (*gcry_pk_encrypt_t) (int algo,
                                             gcry_mpi_t *resarr,
                                             gcry_mpi_t data,
                                             gcry_mpi_t *pkey,
                                             int flags);
 
 /* Type for the pk_decrypt function.  */
-typedef gpg_err_code_t (*gcry_pk_decrypt_t) (int algo,
+typedef gcry_err_code_t (*gcry_pk_decrypt_t) (int algo,
                                             gcry_mpi_t *result,
                                             gcry_mpi_t *data,
                                             gcry_mpi_t *skey,
                                             int flags);
 
 /* Type for the pk_sign function.  */
-typedef gpg_err_code_t (*gcry_pk_sign_t) (int algo,
+typedef gcry_err_code_t (*gcry_pk_sign_t) (int algo,
                                          gcry_mpi_t *resarr,
                                          gcry_mpi_t data,
                                          gcry_mpi_t *skey);
 
 /* Type for the pk_verify function.  */
-typedef gpg_err_code_t (*gcry_pk_verify_t) (int algo,
+typedef gcry_err_code_t (*gcry_pk_verify_t) (int algo,
                                            gcry_mpi_t hash,
                                            gcry_mpi_t *data,
                                            gcry_mpi_t *pkey,
@@ -858,7 +901,7 @@ typedef struct gcry_pk_spec
 /* Register a new pubkey module whose specification can be found in
    PUBKEY.  On success, a new algorithm ID is stored in ALGORITHM_ID
    and a pointer representhing this module is stored in MODULE.  */
-gpg_error_t gcry_pk_register (gcry_pk_spec_t *pubkey,
+gcry_error_t gcry_pk_register (gcry_pk_spec_t *pubkey,
                              unsigned int *algorithm_id,
                              gcry_module_t *module);
 
@@ -912,19 +955,19 @@ typedef struct gcry_ac_key_spec_rsa
 } gcry_ac_key_spec_rsa_t;
 
 /* Returns a new, empty data set in DATA.  */
-gpg_error_t gcry_ac_data_new (gcry_ac_data_t *data);
+gcry_error_t gcry_ac_data_new (gcry_ac_data_t *data);
 
 /* Destroy the data set DATA.  */
 void gcry_ac_data_destroy (gcry_ac_data_t data);
 
 /* Add the value MPI to DATA with the label NAME.  If there is already
    a value with that label, replace it, otherwise add it.  */
-gpg_error_t gcry_ac_data_set (gcry_ac_data_t data,
+gcry_error_t gcry_ac_data_set (gcry_ac_data_t data,
                              const char *name,
                              gcry_mpi_t mpi);
 
 /* Create a copy of the data set DATA and store it in DATA_CP.  */
-gpg_error_t gcry_ac_data_copy (gcry_ac_data_t *data_cp,
+gcry_error_t gcry_ac_data_copy (gcry_ac_data_t *data_cp,
                               gcry_ac_data_t data);
 
 /* Return the number of named MPI values inside of the data set
@@ -933,19 +976,19 @@ unsigned int gcry_ac_data_length (gcry_ac_data_t data);
 
 /* Store the value labelled with NAME found in DATA in MPI or NULL if
    a value with that label was not found.  */
-gpg_error_t gcry_ac_data_get_name (gcry_ac_data_t data, const char *name,
+gcry_error_t gcry_ac_data_get_name (gcry_ac_data_t data, const char *name,
                                   gcry_mpi_t *mpi);
 
 /* Return the MPI value with index INDEX contained in the data set
    DATA.  */
-gpg_error_t gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int index,
+gcry_error_t gcry_ac_data_get_index (gcry_ac_data_t data, unsigned int index,
                                    const char **name, gcry_mpi_t *mpi);
 
 /* Destroy any values contained in the data set DATA.  */
 void gcry_ac_data_clear (gcry_ac_data_t data);
 
 /* Create a new ac handle.  */
-gpg_error_t gcry_ac_open (gcry_ac_handle_t *handle,
+gcry_error_t gcry_ac_open (gcry_ac_handle_t *handle,
                          gcry_ac_id_t algorithm,
                          unsigned int flags);
 
@@ -953,13 +996,13 @@ gpg_error_t gcry_ac_open (gcry_ac_handle_t *handle,
 void gcry_ac_close (gcry_ac_handle_t handle);
 
 /* Initialize a key from a given data set.  */
-gpg_error_t gcry_ac_key_init (gcry_ac_key_t *key,
+gcry_error_t gcry_ac_key_init (gcry_ac_key_t *key,
                              gcry_ac_handle_t handle,
                              gcry_ac_key_type_t type,
                              gcry_ac_data_t data);
 
 /* Generate a new key pair.  */
-gpg_error_t gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
+gcry_error_t gcry_ac_key_pair_generate (gcry_ac_handle_t handle,
                                       gcry_ac_key_pair_t *key_pair,
                                       unsigned int nbits,
                                       void *spec);
@@ -969,14 +1012,14 @@ gcry_ac_key_t gcry_ac_key_pair_extract (gcry_ac_key_pair_t key_pair,
                                        gcry_ac_key_type_t which);
 
 /* Verify that the key KEY is sane.  */
-gpg_error_t gcry_ac_key_test (gcry_ac_key_t key);
+gcry_error_t gcry_ac_key_test (gcry_ac_key_t key);
 
 /* Return the number of bits of the key KEY in NBITS.  */
-gpg_error_t gcry_ac_key_get_nbits (gcry_ac_key_t key,
+gcry_error_t gcry_ac_key_get_nbits (gcry_ac_key_t key,
                                   unsigned int *nbits);
 
 /* Write the 20 byte long key grip of the key KEY to KEY_GRIP.  */
-gpg_error_t gcry_ac_key_get_grip (gcry_ac_key_t key,
+gcry_error_t gcry_ac_key_get_grip (gcry_ac_key_t key,
                                  unsigned char *key_grip);
 
 /* Destroy a key.  */
@@ -988,7 +1031,7 @@ void gcry_ac_key_pair_destroy (gcry_ac_key_pair_t key_pair);
 /* Encrypt the plain text MPI value DATA_PLAIN with the key KEY under
    the control of the flags FLAGS and store the resulting data set
    into DATA_ENCRYPTED.  */
-gpg_error_t gcry_ac_data_encrypt (gcry_ac_handle_t handle,
+gcry_error_t gcry_ac_data_encrypt (gcry_ac_handle_t handle,
                                  unsigned int flags,
                                  gcry_ac_key_t key,
                                  gcry_mpi_t data_plain,
@@ -997,7 +1040,7 @@ gpg_error_t gcry_ac_data_encrypt (gcry_ac_handle_t handle,
 /* Decrypt the decrypted data contained in the data set DATA_ENCRYPTED
    with the key KEY under the control of the flags FLAGS and store the
    resulting plain text MPI value in DATA_PLAIN.  */
-gpg_error_t gcry_ac_data_decrypt (gcry_ac_handle_t handle,
+gcry_error_t gcry_ac_data_decrypt (gcry_ac_handle_t handle,
                                  unsigned int flags,
                                  gcry_ac_key_t key,
                                  gcry_mpi_t *data_plain,
@@ -1005,7 +1048,7 @@ gpg_error_t gcry_ac_data_decrypt (gcry_ac_handle_t handle,
 
 /* Sign the data contained in DATA with the key KEY and store the
    resulting signature in the data set DATA_SIGNATURE.  */
-gpg_error_t gcry_ac_data_sign (gcry_ac_handle_t handle,
+gcry_error_t gcry_ac_data_sign (gcry_ac_handle_t handle,
                               gcry_ac_key_t key,
                               gcry_mpi_t data,
                               gcry_ac_data_t *data_signature);
@@ -1013,19 +1056,19 @@ gpg_error_t gcry_ac_data_sign (gcry_ac_handle_t handle,
 /* Verify that the signature contained in the data set DATA_SIGNATURE
    is indeed the result of signing the data contained in DATA with the
    secret key belonging to the public key KEY.  */
-gpg_error_t gcry_ac_data_verify (gcry_ac_handle_t handle,
+gcry_error_t gcry_ac_data_verify (gcry_ac_handle_t handle,
                                 gcry_ac_key_t key,
                                 gcry_mpi_t data,
                                 gcry_ac_data_t data_signature);
 
 /* Store the textual representation of the algorithm whose id is given
    in ALGORITHM in NAME.  */
-gpg_error_t gcry_ac_id_to_name (gcry_ac_id_t algorithm,
+gcry_error_t gcry_ac_id_to_name (gcry_ac_id_t algorithm,
                                const char **name);
 
 /* Store the numeric ID of the algorithm whose textual representation
    is contained in NAME in ALGORITHM.  */
-gpg_error_t gcry_ac_name_to_id (const char *name,
+gcry_error_t gcry_ac_name_to_id (const char *name,
                                gcry_ac_id_t *algorithm);
 
 \f
@@ -1057,48 +1100,53 @@ enum gcry_md_algos
   };
 
 /* Flags used with the open function. */
-enum gcry_md_flags
-  {
-    GCRY_MD_FLAG_SECURE = 1,  /* Allocate all buffers in "secure" memory */
-    GCRY_MD_FLAG_HMAC  = 2   /* Make an HMAC out of this algorithm. */
-  };
 
+/* Allocate all buffers in "secure" memory.  */
+#define GCRY_MD_FLAG_SECURE 1 << 0
+/* Make an HMAC out of this algorithm.  */
+#define GCRY_MD_FLAG_HMAC   1 << 1
 
-/* This object is used to hold a handle to an message digest object.  */
+/* Forward declaration.  */
 struct gcry_md_context;
-struct gcry_md_handle 
-  { /* This structure is private - only to be used by the gcry_md_  macros. */
-    struct gcry_md_context *ctx;
-    int  bufpos;
-    int  bufsize;
-    unsigned char buf[1];
-  };
-typedef struct gcry_md_handle *gcry_md_hd_t;
 
+/* This object is used to hold a handle to a message digest object.
+   This structure is private - only to be used by the public gcry_md_*
+   macros.  */
+typedef struct gcry_md_handle 
+{
+  /* Actual context.  */
+  struct gcry_md_context *ctx;
+  
+  /* Buffer management.  */
+  int  bufpos;
+  int  bufsize;
+  unsigned char buf[1];
+} *gcry_md_hd_t;
+
+/* Compatibility types, do not use them.  */
 typedef struct gcry_md_handle *GCRY_MD_HD _GCRY_GCC_ATTR_DEPRECATED;
 typedef struct gcry_md_handle *GcryMDHd _GCRY_GCC_ATTR_DEPRECATED;
 
-
 /* Create a message digest object for algorithm ALGO.  FLAGS may be
    given as an bitwise OR of the gcry_md_flags values.  ALGO may be
    given as 0 if the algorithms to be used are later set using
-   gcry_md_enable. */
-gpg_error_t gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags);
+   gcry_md_enable.  */
+gcry_error_t gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags);
 
-/* Release the message digest object HD. */
+/* Release the message digest object HD.  */
 void gcry_md_close (gcry_md_hd_t hd);
 
-/* Add the message digest algorithm ALGO to the digest object HD. */
-gpg_error_t gcry_md_enable( gcry_md_hd_t hd, int algo );
+/* Add the message digest algorithm ALGO to the digest object HD.  */
+gcry_error_t gcry_md_enable (gcry_md_hd_t hd, int algo);
 
-/* Create a new digest object as an exact copy of the object HD. */
-gpg_error_t gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd);
+/* Create a new digest object as an exact copy of the object HD.  */
+gcry_error_t gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd);
 
-/* Reset the digest object HD to its initial state. */
+/* Reset the digest object HD to its initial state.  */
 void gcry_md_reset (gcry_md_hd_t hd);
 
 /* Perform various operations on the digets object HD. */
-gpg_error_t gcry_md_ctl (gcry_md_hd_t hd, int cmd, unsigned char *buffer,
+gcry_error_t gcry_md_ctl (gcry_md_hd_t hd, int cmd, unsigned char *buffer,
                         size_t buflen);
 
 /* Pass LENGTH bytes of data in BUFFER to the digest object HD so that
@@ -1134,11 +1182,11 @@ int gcry_md_is_enabled (gcry_md_hd_t a, int algo);
 int gcry_md_is_secure (gcry_md_hd_t a);
 
 /* Retrieve various information about the object H.  */
-gpg_error_t gcry_md_info (gcry_md_hd_t h, int what, void *buffer,
+gcry_error_t gcry_md_info (gcry_md_hd_t h, int what, void *buffer,
                          size_t *nbytes);
 
 /* Retrieve various information about the algorithm ALGO.  */
-gpg_error_t gcry_md_algo_info (int algo, int what, void *buffer,
+gcry_error_t gcry_md_algo_info (int algo, int what, void *buffer,
                               size_t *nbytes);
 
 /* Map the digest algorithm id ALGO to a string representation of the
@@ -1152,7 +1200,7 @@ int gcry_md_map_name (const char* name) _GCRY_GCC_ATTR_PURE;
 
 /* For use with the HMAC feature, the set MAC key to the KEY of
    KEYLEN. */
-gpg_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
+gcry_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
 
 /* Update the hash(s) of H with the character C.  This is a buffered
    version of the gcry_md_write function. */
@@ -1197,7 +1245,7 @@ gpg_error_t gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen);
    of according size.  In case there are less message digest modules
    than *LIST_LENGTH, *LIST_LENGTH is updated to the correct
    number.  */
-gpg_error_t gcry_md_list (int *list, int *list_length);
+gcry_error_t gcry_md_list (int *list, int *list_length);
 
 /* Type for the md_init function.  */
 typedef void (*gcry_md_init_t) (void *c);
@@ -1228,7 +1276,7 @@ typedef struct gcry_md_spec
 /* Register a new digest module whose specification can be found in
    DIGEST.  On success, a new algorithm ID is stored in ALGORITHM_ID
    and a pointer representhing this module is stored in MODULE.  */
-gpg_error_t gcry_md_register (gcry_md_spec_t *digest,
+gcry_error_t gcry_md_register (gcry_md_spec_t *digest,
                              unsigned int *algorithm_id,
                              gcry_module_t *module);
 
@@ -1264,7 +1312,7 @@ void gcry_randomize (unsigned char *buffer, size_t length,
 /* Add the external random from BUFFER with LENGTH bytes into the
    pool. QUALITY should either be -1 for unknown or in the range of 0
    to 100 */
-gpg_error_t gcry_random_add_bytes (const void *buffer, size_t length,
+gcry_error_t gcry_random_add_bytes (const void *buffer, size_t length,
                                   int quality);
 
 /* Return NBYTES of allocated random using a random numbers of quality
index f55c5db..de178da 100644 (file)
  */
 static unsigned int debug_flags;
 
-static void *(*alloc_func)(size_t n) = NULL;
-static void *(*alloc_secure_func)(size_t n) = NULL;
-static int   (*is_secure_func)(const void*) = NULL;
-static void *(*realloc_func)(void *p, size_t n) = NULL;
-static void (*free_func)(void*) = NULL;
-static int (*outofcore_handler)( void*, size_t, unsigned int ) = NULL;
+static gcry_handler_alloc_t alloc_func;
+static gcry_handler_alloc_t alloc_secure_func;
+static gcry_handler_secure_check_t is_secure_func;
+static gcry_handler_realloc_t realloc_func;
+static gcry_handler_free_t free_func;
+static gcry_handler_no_mem_t outofcore_handler;
+
 static void *outofcore_handler_value = NULL;
 static int no_secure_memory = 0;
 static int any_init_done;
@@ -57,7 +58,7 @@ static int any_init_done;
 static void
 global_init (void)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
 
   if (any_init_done)
     return;
@@ -148,10 +149,10 @@ gcry_check_version( const char *req_version )
     return NULL;
 }
 
-gpg_error_t
+gcry_error_t
 gcry_control (enum gcry_ctl_cmds cmd, ...)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   static int init_finished = 0;
   va_list arg_ptr;
   
@@ -273,31 +274,41 @@ gcry_control (enum gcry_ctl_cmds cmd, ...)
     }
 
   va_end(arg_ptr);
-  return gpg_error (err);
+  return gcry_error (err);
+}
+
+/* Return a pointer to a string containing a description of the error
+   code in the error value ERR.  */
+const char *
+gcry_strerror (gcry_error_t err)
+{
+  return gpg_strerror (err);
 }
 
+/* Return a pointer to a string containing a description of the error
+   source in the error value ERR.  */
 const char *
-gcry_strerror (gpg_error_t ec)
+gcry_strsource (gcry_error_t err)
 {
-  return gpg_strerror (ec);
+  return gpg_strsource (err);
 }
 
 /****************
  * NOTE: All 5 functions should be set.  */
 void
-gcry_set_allocation_handler( void *(*new_alloc_func)(size_t n),
-                            void *(*new_alloc_secure_func)(size_t n),
-                            int (*new_is_secure_func)(const void*),
-                            void *(*new_realloc_func)(void *p, size_t n),
-                            void (*new_free_func)(void*) )
+gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
+                            gcry_handler_alloc_t new_alloc_secure_func,
+                            gcry_handler_secure_check_t new_is_secure_func,
+                            gcry_handler_realloc_t new_realloc_func,
+                            gcry_handler_free_t new_free_func)
 {
-    global_init ();
+  global_init ();
 
-    alloc_func       = new_alloc_func;
-    alloc_secure_func = new_alloc_secure_func;
-    is_secure_func    = new_is_secure_func;
-    realloc_func      = new_realloc_func;
-    free_func        = new_free_func;
+  alloc_func = new_alloc_func;
+  alloc_secure_func = new_alloc_secure_func;
+  is_secure_func = new_is_secure_func;
+  realloc_func = new_realloc_func;
+  free_func = new_free_func;
 }
 
 
index fe97af5..b122cd8 100644 (file)
 /* Internal function.  Generate a new, unique module ID for a module
    that should be inserted into the module chain starting at
    MODULES.  */
-static gpg_err_code_t
+static gcry_err_code_t
 _gcry_module_id_new (gcry_module_t modules, unsigned int *id_new)
 {
   /* FIXME, what should be the ID of the first module registered by
      the user?  */
   unsigned int id_min = 600, id_max = (unsigned int) -1, mod_id;
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_module_t module;
 
   /* Search for unused ID.  */
@@ -60,11 +60,11 @@ _gcry_module_id_new (gcry_module_t modules, unsigned int *id_new)
 
 /* Add a module specification to the list ENTRIES.  The new module has
    it's use-counter set to one.  */
-gpg_err_code_t
+gcry_err_code_t
 _gcry_module_add (gcry_module_t *entries, unsigned int mod_id,
                  void *spec, gcry_module_t *module)
 {
-  gpg_err_code_t err = 0;
+  gcry_err_code_t err = 0;
   gcry_module_t entry;
 
   if (! mod_id)
@@ -169,11 +169,11 @@ _gcry_module_use (gcry_module_t module)
    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
    according size.  In case there are less cipher modules than
    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
-gpg_err_code_t
+gcry_err_code_t
 _gcry_module_list (gcry_module_t modules,
                   int *list, int *list_length)
 {
-  gpg_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t err = GPG_ERR_NO_ERROR;
   gcry_module_t module;
   int length, i;
 
index a179ce8..9e0037e 100644 (file)
--- a/src/mpi.h
+++ b/src/mpi.h
@@ -70,13 +70,6 @@ struct gcry_mpi {
     mpi_limb_t *d;  /* array with the limbs */
 };
 
-#if 0
-#ifndef DID_MPI_TYPEDEF
-  typedef struct gcry_mpi *MPI;
-#define DID_MPI_TYPEDEF
-#endif
-#endif
-
 #define MPI_NULL NULL
 
 #define mpi_get_nlimbs(a)     ((a)->nlimbs)
index ca5c6ea..149c20f 100644 (file)
@@ -53,7 +53,7 @@ struct gcry_sexp
 
 #define TOKEN_SPECIALS  "-./_:*+="
 
-static gpg_error_t
+static gcry_error_t
 sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
            const char *buffer, size_t length, int argflag,
            va_list arg_ptr, void **arg_list);
@@ -187,19 +187,19 @@ normalize ( gcry_sexp_t list )
   
    This function returns 0 and and the pointer to the new object in
    RETSEXP or an error code in which case RETSEXP is set to NULL.  */
-gpg_error_t
+gcry_error_t
 gcry_sexp_create (gcry_sexp_t *retsexp, void *buffer, size_t length,
                   int autodetect, void (*freefnc)(void*) )
 {
-  gpg_error_t errcode;
+  gcry_error_t errcode;
   gcry_sexp_t se;
   volatile va_list dummy_arg_ptr;
 
   if (!retsexp)
-    return gpg_error (GPG_ERR_INV_ARG);
+    return gcry_error (GPG_ERR_INV_ARG);
   *retsexp = NULL;
   if (autodetect < 0 || autodetect > 1 || !buffer)
-    return gpg_error (GPG_ERR_INV_ARG);
+    return gcry_error (GPG_ERR_INV_ARG);
 
   if (!length && !autodetect)
     { /* What a brave caller to assume that there is really a canonical
@@ -227,11 +227,11 @@ gcry_sexp_create (gcry_sexp_t *retsexp, void *buffer, size_t length,
          GCRYSEXP object and use the BUFFER directly */
       freefnc (buffer);
     }
-  return gpg_error (GPG_ERR_NO_ERROR);
+  return gcry_error (GPG_ERR_NO_ERROR);
 }
 
 /* Same as gcry_sexp_create but don't transfer ownership */
-gpg_error_t
+gcry_error_t
 gcry_sexp_new (gcry_sexp_t *retsexp, const void *buffer, size_t length,
                int autodetect)
 {
@@ -833,7 +833,7 @@ unquote_string (const unsigned char *string, size_t length, unsigned char *buf)
  * common operation gcry_sexp_cdr_mpi() will always return a secure MPI
  * regardless whether it is needed or not.
  */
-static gpg_error_t
+static gcry_error_t
 sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
            const char *buffer, size_t length, int argflag,
            va_list arg_ptr, void **arg_list)
@@ -915,7 +915,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                && p[2] >= '0' && p[2] <= '7') ) {
            *erroff = p - buffer;
            /* Invalid octal value.  */
-           return gpg_error (GPG_ERR_SEXP_BAD_QUOTATION);
+           return gcry_error (GPG_ERR_SEXP_BAD_QUOTATION);
          }
          p += 2; n -= 2;
          quoted_esc = 0;
@@ -924,7 +924,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
          if( !(n > 2 && isxdigit(p[1]) && isxdigit(p[2]) ) ) {
            *erroff = p - buffer;
            /* Invalid hex value.  */
-           return gpg_error (GPG_ERR_SEXP_BAD_QUOTATION);
+           return gcry_error (GPG_ERR_SEXP_BAD_QUOTATION);
          }
          p += 2; n -= 2;
          quoted_esc = 0;
@@ -944,7 +944,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
        default:
          *erroff = p - buffer;
          /* Invalid quoted string escape.  */
-         return gpg_error (GPG_ERR_SEXP_BAD_QUOTATION);
+         return gcry_error (GPG_ERR_SEXP_BAD_QUOTATION);
        }
       }
       else if( *p == '\\' )
@@ -972,7 +972,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       else if( *p == '#' ) {
        if( (hexcount & 1) ) {
          *erroff = p - buffer;
-         return gpg_error (GPG_ERR_SEXP_ODD_HEX_NUMBERS);
+         return gcry_error (GPG_ERR_SEXP_ODD_HEX_NUMBERS);
        }
 
        datalen = hexcount/2;
@@ -989,7 +989,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       }
       else if( !isspace( *p ) ) {
        *erroff = p - buffer;
-       return gpg_error (GPG_ERR_SEXP_BAD_HEX_CHAR);
+       return gcry_error (GPG_ERR_SEXP_BAD_HEX_CHAR);
       }
     }
     else if( base64 ) {
@@ -1005,7 +1005,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
        if( datalen > n-1 ) {
          *erroff = p - buffer;
          /* Buffer too short.  */
-         return gpg_error (GPG_ERR_SEXP_STRING_TOO_LONG);
+         return gcry_error (GPG_ERR_SEXP_STRING_TOO_LONG);
        }
        /* make a new list entry */
        MAKE_SPACE (datalen);
@@ -1032,7 +1032,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       }
       else {
        *erroff = p - buffer;
-       return gpg_error (GPG_ERR_SEXP_INV_LEN_SPEC);
+       return gcry_error (GPG_ERR_SEXP_INV_LEN_SPEC);
       }
     }
     else if ( percent ) {
@@ -1097,7 +1097,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       else {
        *erroff = p - buffer;
        /* Invalid format specifier.  */
-       return gpg_error (GPG_ERR_SEXP_INV_LEN_SPEC);
+       return gcry_error (GPG_ERR_SEXP_INV_LEN_SPEC);
       }
       percent = NULL;
     }
@@ -1105,7 +1105,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       if( disphint ) {
        *erroff = p - buffer;
        /* Open display hint.  */
-       return gpg_error (GPG_ERR_SEXP_UNMATCHED_DH);
+       return gcry_error (GPG_ERR_SEXP_UNMATCHED_DH);
       }
       MAKE_SPACE (0);
       *c.pos++ = ST_OPEN;
@@ -1114,7 +1114,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       if( disphint ) {
        *erroff = p - buffer;
        /* Open display hint.  */
-       return gpg_error (GPG_ERR_SEXP_UNMATCHED_DH);
+       return gcry_error (GPG_ERR_SEXP_UNMATCHED_DH);
       }
       MAKE_SPACE (0);
       *c.pos++ = ST_CLOSE;
@@ -1133,7 +1133,7 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       if( disphint ) {
        *erroff = p - buffer;
        /* Open display hint.  */
-       return gpg_error (GPG_ERR_SEXP_NESTED_DH);
+       return gcry_error (GPG_ERR_SEXP_NESTED_DH);
       }
       disphint = p;
     }
@@ -1141,14 +1141,14 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
       if( !disphint ) {
        *erroff = p - buffer;
        /* Open display hint.  */
-       return gpg_error (GPG_ERR_SEXP_UNMATCHED_DH);
+       return gcry_error (GPG_ERR_SEXP_UNMATCHED_DH);
       }
       disphint = NULL;
     }
     else if( isdigit(*p) ) {
       if( *p == '0' ) { /* a length may not begin with zero */
        *erroff = p - buffer;
-       return gpg_error (GPG_ERR_SEXP_ZERO_PREFIX);
+       return gcry_error (GPG_ERR_SEXP_ZERO_PREFIX);
       }
       digptr = p;
     }
@@ -1164,18 +1164,18 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
        * it.  Great.
        */
       *erroff = p - buffer;
-      return gpg_error (GPG_ERR_SEXP_UNEXPECTED_PUNC);
+      return gcry_error (GPG_ERR_SEXP_UNEXPECTED_PUNC);
     }
     else if( strchr( "&\\", *p ) ) { /*reserved punctuation*/
       *erroff = p - buffer;
-      return gpg_error (GPG_ERR_SEXP_UNEXPECTED_PUNC);
+      return gcry_error (GPG_ERR_SEXP_UNEXPECTED_PUNC);
     }
     else if( argflag && *p == '%' ) {
       percent = p;
     }
     else { /* bad or unavailable*/
       *erroff = p - buffer;
-      return gpg_error (GPG_ERR_SEXP_BAD_CHARACTER);
+      return gcry_error (GPG_ERR_SEXP_BAD_CHARACTER);
     }
 
   }
@@ -1183,15 +1183,15 @@ ABCDEFGHIJKLMNOPQRSTUVWXYZ\
   *c.pos++ = ST_STOP;
 
   *retsexp = normalize ( c.sexp );
-  return gpg_error (GPG_ERR_NO_ERROR);
+  return gcry_error (GPG_ERR_NO_ERROR);
 #undef MAKE_SPACE
 #undef STORE_LEN
 }
 
-gpg_error_t
+gcry_error_t
 gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff, const char *format, ...)
 {
-  gpg_error_t rc;
+  gcry_error_t rc;
   va_list arg_ptr;
   
   va_start (arg_ptr, format);
@@ -1204,7 +1204,7 @@ gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff, const char *format, ...)
 
 /* Like gcry_sexp_build, but uses an array instead of variable
    function arguments.  */
-gpg_error_t
+gcry_error_t
 gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
                       const char *format, void **arg_list)
 {
@@ -1214,7 +1214,7 @@ gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
      suppress the compiler warning */
   volatile va_list dummy_arg_ptr;
   
-  gpg_error_t rc;
+  gcry_error_t rc;
 
   rc = sexp_sscan (retsexp, erroff, format, strlen(format), 1,
                   dummy_arg_ptr, arg_list);
@@ -1222,7 +1222,7 @@ gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
   return rc;
 }
 
-gpg_error_t
+gcry_error_t
 gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
                 const char *buffer, size_t length)
 {
@@ -1512,13 +1512,13 @@ gcry_sexp_sprint( const gcry_sexp_t list, int mode,
    NULL.  */
 size_t
 gcry_sexp_canon_len (const unsigned char *buffer, size_t length, 
-                     size_t *erroff, gpg_error_t *errcode)
+                     size_t *erroff, gcry_error_t *errcode)
 {
   const unsigned char *p;
   const char *disphint=NULL;
   unsigned int datalen = 0;
   size_t dummy_erroff;
-  gpg_error_t dummy_errcode;
+  gcry_error_t dummy_errcode;
   size_t count = 0;
   int level = 0;
 
@@ -1527,13 +1527,13 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
   if (!errcode)
     errcode = &dummy_errcode;
 
-  *errcode = gpg_error (GPG_ERR_NO_ERROR);
+  *errcode = gcry_error (GPG_ERR_NO_ERROR);
   *erroff = 0;
   if (!buffer)
     return 0;
   if (*buffer != '(')
     {
-      *errcode = gpg_error (GPG_ERR_SEXP_NOT_CANONICAL);
+      *errcode = gcry_error (GPG_ERR_SEXP_NOT_CANONICAL);
       return 0;
     }
 
@@ -1542,7 +1542,7 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
       if (length && count >= length)
         {
           *erroff = count;
-          *errcode = gpg_error (GPG_ERR_SEXP_STRING_TOO_LONG);
+          *errcode = gcry_error (GPG_ERR_SEXP_STRING_TOO_LONG);
           return 0;
         }
       
@@ -1553,7 +1553,7 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
               if (length && (count+datalen) >= length)
                 {
                   *erroff = count;
-                  *errcode = gpg_error (GPG_ERR_SEXP_STRING_TOO_LONG);
+                  *errcode = gcry_error (GPG_ERR_SEXP_STRING_TOO_LONG);
                   return 0;
                 }
               count += datalen;
@@ -1565,7 +1565,7 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
           else 
             {
               *erroff = count;
-              *errcode = gpg_error (GPG_ERR_SEXP_INV_LEN_SPEC);
+              *errcode = gcry_error (GPG_ERR_SEXP_INV_LEN_SPEC);
               return 0;
            }
        }
@@ -1574,7 +1574,7 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
           if (disphint)
             {
               *erroff = count;
-              *errcode = gpg_error (GPG_ERR_SEXP_UNMATCHED_DH);
+              *errcode = gcry_error (GPG_ERR_SEXP_UNMATCHED_DH);
               return 0;
            }
           level++;
@@ -1584,13 +1584,13 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
           if (!level)
             {
               *erroff = count;
-              *errcode = gpg_error (GPG_ERR_SEXP_UNMATCHED_PAREN);
+              *errcode = gcry_error (GPG_ERR_SEXP_UNMATCHED_PAREN);
               return 0;
            }
           if (disphint)
             {
               *erroff = count;
-              *errcode = gpg_error (GPG_ERR_SEXP_UNMATCHED_DH);
+              *errcode = gcry_error (GPG_ERR_SEXP_UNMATCHED_DH);
               return 0;
            }
           if (!--level)
@@ -1601,7 +1601,7 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
           if (disphint) 
             {
               *erroff = count;
-              *errcode = gpg_error (GPG_ERR_SEXP_NESTED_DH);
+              *errcode = gcry_error (GPG_ERR_SEXP_NESTED_DH);
               return 0;
             }
           disphint = p;
@@ -1611,7 +1611,7 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
           if( !disphint ) 
             {
               *erroff = count;
-              *errcode = gpg_error (GPG_ERR_SEXP_UNMATCHED_DH);
+              *errcode = gcry_error (GPG_ERR_SEXP_UNMATCHED_DH);
               return 0;
            }
           disphint = NULL;
@@ -1621,7 +1621,7 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
           if (*p == '0')
             { 
               *erroff = count;
-              *errcode = gpg_error (GPG_ERR_SEXP_ZERO_PREFIX);
+              *errcode = gcry_error (GPG_ERR_SEXP_ZERO_PREFIX);
               return 0;
            }
           datalen = atoi_1 (p);
@@ -1629,13 +1629,13 @@ gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
       else if (*p == '&' || *p == '\\')
         {
           *erroff = count;
-          *errcode = gpg_error (GPG_ERR_SEXP_UNEXPECTED_PUNC);
+          *errcode = gcry_error (GPG_ERR_SEXP_UNEXPECTED_PUNC);
           return 0;
        }
       else
         { 
           *erroff = count;
-          *errcode = gpg_error (GPG_ERR_SEXP_BAD_CHARACTER);
+          *errcode = gcry_error (GPG_ERR_SEXP_BAD_CHARACTER);
           return 0;
        }
     }