2003-06-17 Moritz Schulte <moritz@g10code.com>

	* md.c (md_open): Use _gcry_fast_random_poll instead of
	fast_random_poll.
	* cipher.c (gcry_cipher_open): Likewise.

	* random.h (fast_random_poll): Removed macro.

	* blowfish.c, md4.c, md5.c, rmd160.c, sha1.c, sha256.c, sha512.c,
	tiger.c: Use Autoconf's WORDS_BIGENDIAN instead of our own
	BIG_ENDIAN_HOST.

2003-06-16  Moritz Schulte  <moritz@g10code.com>

	* random.c (getfnc_gather_random): Do not special-case
	USE_ALL_RANDOM_MODULES, make it the default.

	* dsa.c: Replace last occurences of old type names with newer
	names (i.e. replace MPI with gcry_mpi_t).
	* elgamal.c: Likewise.
	* primegen.c: Likewise.
	* pubkey.c: Likewise.
	* rsa.c: Likewise.

19 files changed, 254 insertions, 258 deletions

diff --git a/cipher/ChangeLog b/cipher/ChangeLog
index 9cdbe5e9..b147d670 100644
--- a/cipher/ChangeLog
+++ b/cipher/ChangeLog
@@ -5,6 +5,7 @@
 	(libcipher_la_DEPENDENCIES): Set to $(GCRYPT_MODULES).
 	(libcipher_la_LIBADD): Likewise.
 	(AM_CFLAGS): Added: @GPG_ERROR_CFLAGS@.
+	(EXTRA_libcipher_la_SOURCES): Added all conditional sources.
 
 	* md.c (md_open): Use _gcry_fast_random_poll instead of
 	fast_random_poll.
diff --git a/cipher/Makefile.am b/cipher/Makefile.am
index 50179139..9b2385e2 100644
--- a/cipher/Makefile.am
+++ b/cipher/Makefile.am
@@ -37,6 +37,27 @@ random.c random.h \
 rand-internal.h \
 rmd.h
 
+EXTRA_libcipher_la_SOURCES = \
+arcfour.c \
+blowfish.c \
+cast5.c \
+crc.c \
+des.c \
+dsa.c \
+elgamal.c \
+md4.c \
+md5.c \
+rijndael.c \
+rmd160.c \
+rndegd.c \
+endunix.c \
+rndnw32.c \
+rsa.c \
+sha256.c \
+sha512.c \
+tiger.c \
+twofish.c
+
 # We need to lower the optimization for this module.
 tiger.o: $(srcdir)/tiger.c
 	`echo $(COMPILE) -c $(srcdir)/tiger.c | sed -e 's/-O[2-9s]*/-O1/g' `
diff --git a/cipher/blowfish.c b/cipher/blowfish.c
index 97cc1220..59ac9001 100644
--- a/cipher/blowfish.c
+++ b/cipher/blowfish.c
@@ -248,7 +248,7 @@ function_F( BLOWFISH_context *bc, u32 x )
 {
     u16 a, b, c, d;
 
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
     a = ((byte*)&x)[0];
     b = ((byte*)&x)[1];
     c = ((byte*)&x)[2];
@@ -264,7 +264,7 @@ function_F( BLOWFISH_context *bc, u32 x )
 }
 #endif
 
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define F(x) ((( s0[((byte*)&x)[0]] + s1[((byte*)&x)[1]])	 \
 		   ^ s2[((byte*)&x)[2]]) + s3[((byte*)&x)[3]] )
 #else
@@ -517,7 +517,7 @@ do_bf_setkey (BLOWFISH_context *c, const byte *key, unsigned keylen)
     }
 
     for(i=j=0; i < BLOWFISH_ROUNDS+2; i++ ) {
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 	((byte*)&data)[0] = key[j];
 	((byte*)&data)[1] = key[(j+1)%keylen];
 	((byte*)&data)[2] = key[(j+2)%keylen];
diff --git a/cipher/cipher.c b/cipher/cipher.c
index 36ffdbf9..aa012646 100644
--- a/cipher/cipher.c
+++ b/cipher/cipher.c
@@ -523,10 +523,10 @@ gcry_cipher_open (gcry_cipher_hd_t *handle,
   int secure = (flags & GCRY_CIPHER_SECURE);
   GcryCipherSpec *cipher = NULL;
   GcryModule *module = NULL;
+  gcry_cipher_hd_t h = NULL;
   gpg_err_code_t err = 0;
-  gcry_cipher_hd_t h;
 
-  fast_random_poll();
+  _gcry_fast_random_poll();
   
   REGISTER_DEFAULT_CIPHERS;
 
diff --git a/cipher/dsa.c b/cipher/dsa.c
index 417e9322..800313dc 100644
--- a/cipher/dsa.c
+++ b/cipher/dsa.c
@@ -30,29 +30,29 @@
 
 typedef struct
 {
-  MPI p;	    /* prime */
-  MPI q;	    /* group order */
-  MPI g;	    /* group generator */
-  MPI y;	    /* g^x mod p */
+  gcry_mpi_t p;	    /* prime */
+  gcry_mpi_t q;	    /* group order */
+  gcry_mpi_t g;	    /* group generator */
+  gcry_mpi_t y;	    /* g^x mod p */
 } DSA_public_key;
 
 
 typedef struct
 {
-  MPI p;	    /* prime */
-  MPI q;	    /* group order */
-  MPI g;	    /* group generator */
-  MPI y;	    /* g^x mod p */
-  MPI x;	    /* secret exponent */
+  gcry_mpi_t p;	    /* prime */
+  gcry_mpi_t q;	    /* group order */
+  gcry_mpi_t g;	    /* group generator */
+  gcry_mpi_t y;	    /* g^x mod p */
+  gcry_mpi_t x;	    /* secret exponent */
 } DSA_secret_key;
 
 
-static MPI gen_k (MPI q);
+static gcry_mpi_t gen_k (gcry_mpi_t q);
 static void test_keys (DSA_secret_key *sk, unsigned qbits);
 static int check_secret_key (DSA_secret_key *sk);
-static void generate (DSA_secret_key *sk, unsigned nbits, MPI **ret_factors);
-static void sign (MPI r, MPI s, MPI input, DSA_secret_key *skey);
-static int verify (MPI r, MPI s, MPI input, DSA_public_key *pkey);
+static void generate (DSA_secret_key *sk, unsigned nbits, gcry_mpi_t **ret_factors);
+static void sign (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t input, DSA_secret_key *skey);
+static int verify (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t input, DSA_public_key *pkey);
 
 static void (*progress_cb) (void *,const char *, int, int, int );
 static void *progress_cb_data;
@@ -78,10 +78,10 @@ progress (int c)
 /****************
  * Generate a random secret exponent k less than q
  */
-static MPI
-gen_k( MPI q )
+static gcry_mpi_t
+gen_k( gcry_mpi_t q )
 {
-    MPI k = mpi_alloc_secure( mpi_get_nlimbs(q) );
+    gcry_mpi_t k = mpi_alloc_secure( mpi_get_nlimbs(q) );
     unsigned int nbits = mpi_get_nbits(q);
     unsigned int nbytes = (nbits+7)/8;
     char *rndbuf = NULL;
@@ -137,9 +137,9 @@ static void
 test_keys( DSA_secret_key *sk, unsigned qbits )
 {
     DSA_public_key pk;
-    MPI test = gcry_mpi_new ( qbits  );
-    MPI out1_a = gcry_mpi_new ( qbits );
-    MPI out1_b = gcry_mpi_new ( qbits );
+    gcry_mpi_t test = gcry_mpi_new ( qbits  );
+    gcry_mpi_t out1_a = gcry_mpi_new ( qbits );
+    gcry_mpi_t out1_b = gcry_mpi_new ( qbits );
 
     pk.p = sk->p;
     pk.q = sk->q;
@@ -164,14 +164,14 @@ test_keys( DSA_secret_key *sk, unsigned qbits )
  *	    and an array with the n-1 factors of (p-1)
  */
 static void
-generate( DSA_secret_key *sk, unsigned nbits, MPI **ret_factors )
+generate( DSA_secret_key *sk, unsigned nbits, gcry_mpi_t **ret_factors )
 {
-    MPI p;    /* the prime */
-    MPI q;    /* the 160 bit prime factor */
-    MPI g;    /* the generator */
-    MPI y;    /* g^x mod p */
-    MPI x;    /* the secret exponent */
-    MPI h, e;  /* helper */
+    gcry_mpi_t p;    /* the prime */
+    gcry_mpi_t q;    /* the 160 bit prime factor */
+    gcry_mpi_t g;    /* the generator */
+    gcry_mpi_t y;    /* g^x mod p */
+    gcry_mpi_t x;    /* the secret exponent */
+    gcry_mpi_t h, e;  /* helper */
     unsigned qbits;
     byte *rndbuf;
 
@@ -260,7 +260,7 @@ static int
 check_secret_key( DSA_secret_key *sk )
 {
     int rc;
-    MPI y = mpi_alloc( mpi_get_nlimbs(sk->y) );
+    gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs(sk->y) );
 
     gcry_mpi_powm( y, sk->g, sk->x, sk->p );
     rc = !mpi_cmp( y, sk->y );
@@ -275,11 +275,11 @@ check_secret_key( DSA_secret_key *sk )
  */
 
 static void
-sign(MPI r, MPI s, MPI hash, DSA_secret_key *skey )
+sign(gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t hash, DSA_secret_key *skey )
 {
-    MPI k;
-    MPI kinv;
-    MPI tmp;
+    gcry_mpi_t k;
+    gcry_mpi_t kinv;
+    gcry_mpi_t tmp;
 
     /* select a random k with 0 < k < q */
     k = gen_k( skey->q );
@@ -308,12 +308,12 @@ sign(MPI r, MPI s, MPI hash, DSA_secret_key *skey )
  * Returns true if the signature composed from R and S is valid.
  */
 static int
-verify(MPI r, MPI s, MPI hash, DSA_public_key *pkey )
+verify(gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t hash, DSA_public_key *pkey )
 {
     int rc;
-    MPI w, u1, u2, v;
-    MPI base[3];
-    MPI exp[3];
+    gcry_mpi_t w, u1, u2, v;
+    gcry_mpi_t base[3];
+    gcry_mpi_t exp[3];
 
 
     if( !(mpi_cmp_ui( r, 0 ) > 0 && mpi_cmp( r, pkey->q ) < 0) )
@@ -358,7 +358,7 @@ verify(MPI r, MPI s, MPI hash, DSA_public_key *pkey )
 
 gpg_err_code_t
 _gcry_dsa_generate (int algo, unsigned nbits, unsigned long dummy,
-                    MPI *skey, MPI **retfactors)
+                    gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
   DSA_secret_key sk;
 
@@ -374,7 +374,7 @@ _gcry_dsa_generate (int algo, unsigned nbits, unsigned long dummy,
 
 
 gpg_err_code_t
-_gcry_dsa_check_secret_key (int algo, MPI *skey)
+_gcry_dsa_check_secret_key (int algo, gcry_mpi_t *skey)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   DSA_secret_key sk;
@@ -397,7 +397,7 @@ _gcry_dsa_check_secret_key (int algo, MPI *skey)
 
 
 gpg_err_code_t
-_gcry_dsa_sign (int algo, MPI *resarr, MPI data, MPI *skey)
+_gcry_dsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   DSA_secret_key sk;
@@ -421,8 +421,8 @@ _gcry_dsa_sign (int algo, MPI *resarr, MPI data, MPI *skey)
 }
 
 gpg_err_code_t
-_gcry_dsa_verify (int algo, MPI hash, MPI *data, MPI *pkey,
-		  int (*cmp) (void *, MPI), void *opaquev)
+_gcry_dsa_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+		  int (*cmp) (void *, gcry_mpi_t), void *opaquev)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   DSA_public_key pk;
@@ -444,7 +444,7 @@ _gcry_dsa_verify (int algo, MPI hash, MPI *data, MPI *pkey,
 
 
 unsigned int
-_gcry_dsa_get_nbits (int algo, MPI *pkey)
+_gcry_dsa_get_nbits (int algo, gcry_mpi_t *pkey)
 {
   return mpi_get_nbits (pkey[0]);
 }
diff --git a/cipher/elgamal.c b/cipher/elgamal.c
index 582533e4..6001e550 100644
--- a/cipher/elgamal.c
+++ b/cipher/elgamal.c
@@ -32,29 +32,29 @@
 
 typedef struct
 {
-  MPI p;	    /* prime */
-  MPI g;	    /* group generator */
-  MPI y;	    /* g^x mod p */
+  gcry_mpi_t p;	    /* prime */
+  gcry_mpi_t g;	    /* group generator */
+  gcry_mpi_t y;	    /* g^x mod p */
 } ELG_public_key;
 
 
 typedef struct
 {
-  MPI p;	    /* prime */
-  MPI g;	    /* group generator */
-  MPI y;	    /* g^x mod p */
-  MPI x;	    /* secret exponent */
+  gcry_mpi_t p;	    /* prime */
+  gcry_mpi_t g;	    /* group generator */
+  gcry_mpi_t y;	    /* g^x mod p */
+  gcry_mpi_t x;	    /* secret exponent */
 } ELG_secret_key;
 
 
 static void test_keys (ELG_secret_key *sk, unsigned nbits);
-static MPI gen_k (MPI p);
-static void generate (ELG_secret_key *sk, unsigned nbits, MPI **factors);
+static gcry_mpi_t gen_k (gcry_mpi_t p);
+static void generate (ELG_secret_key *sk, unsigned nbits, gcry_mpi_t **factors);
 static int  check_secret_key (ELG_secret_key *sk);
-static void do_encrypt (MPI a, MPI b, MPI input, ELG_public_key *pkey);
-static void decrypt (MPI output, MPI a, MPI b, ELG_secret_key *skey);
-static void sign (MPI a, MPI b, MPI input, ELG_secret_key *skey);
-static int  verify (MPI a, MPI b, MPI input, ELG_public_key *pkey);
+static void do_encrypt (gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_public_key *pkey);
+static void decrypt (gcry_mpi_t output, gcry_mpi_t a, gcry_mpi_t b, ELG_secret_key *skey);
+static void sign (gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_secret_key *skey);
+static int  verify (gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_public_key *pkey);
 
 
 static void (*progress_cb) (void *, const char *, int, int, int);
@@ -121,10 +121,10 @@ static void
 test_keys( ELG_secret_key *sk, unsigned nbits )
 {
     ELG_public_key pk;
-    MPI test = gcry_mpi_new ( 0 );
-    MPI out1_a = gcry_mpi_new ( nbits );
-    MPI out1_b = gcry_mpi_new ( nbits );
-    MPI out2 = gcry_mpi_new ( nbits );
+    gcry_mpi_t test = gcry_mpi_new ( 0 );
+    gcry_mpi_t out1_a = gcry_mpi_new ( nbits );
+    gcry_mpi_t out1_b = gcry_mpi_new ( nbits );
+    gcry_mpi_t out2 = gcry_mpi_new ( nbits );
 
     pk.p = sk->p;
     pk.g = sk->g;
@@ -152,12 +152,12 @@ test_keys( ELG_secret_key *sk, unsigned nbits )
  * generate a random secret exponent k from prime p, so
  * that k is relatively prime to p-1
  */
-static MPI
-gen_k( MPI p )
+static gcry_mpi_t
+gen_k( gcry_mpi_t p )
 {
-    MPI k = mpi_alloc_secure( 0 );
-    MPI temp = mpi_alloc( mpi_get_nlimbs(p) );
-    MPI p_1 = mpi_copy(p);
+    gcry_mpi_t k = mpi_alloc_secure( 0 );
+    gcry_mpi_t temp = mpi_alloc( mpi_get_nlimbs(p) );
+    gcry_mpi_t p_1 = mpi_copy(p);
     unsigned int orig_nbits = mpi_get_nbits(p);
     unsigned int nbits, nbytes;
     char *rndbuf = NULL;
@@ -229,14 +229,14 @@ gen_k( MPI p )
  *	    and an array with n-1 factors of (p-1)
  */
 static void
-generate(  ELG_secret_key *sk, unsigned int nbits, MPI **ret_factors )
+generate(  ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t **ret_factors )
 {
-    MPI p;    /* the prime */
-    MPI p_min1;
-    MPI g;
-    MPI x;    /* the secret exponent */
-    MPI y;
-    MPI temp;
+    gcry_mpi_t p;    /* the prime */
+    gcry_mpi_t p_min1;
+    gcry_mpi_t g;
+    gcry_mpi_t x;    /* the secret exponent */
+    gcry_mpi_t y;
+    gcry_mpi_t temp;
     unsigned int qbits;
     unsigned int xbits;
     byte *rndbuf;
@@ -327,7 +327,7 @@ static int
 check_secret_key( ELG_secret_key *sk )
 {
     int rc;
-    MPI y = mpi_alloc( mpi_get_nlimbs(sk->y) );
+    gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs(sk->y) );
 
     gcry_mpi_powm( y, sk->g, sk->x, sk->p );
     rc = !mpi_cmp( y, sk->y );
@@ -337,9 +337,9 @@ check_secret_key( ELG_secret_key *sk )
 
 
 static void
-do_encrypt(MPI a, MPI b, MPI input, ELG_public_key *pkey )
+do_encrypt(gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_public_key *pkey )
 {
-    MPI k;
+    gcry_mpi_t k;
 
     /* Note: maybe we should change the interface, so that it
      * is possible to check that input is < p and return an
@@ -372,9 +372,9 @@ do_encrypt(MPI a, MPI b, MPI input, ELG_public_key *pkey )
 
 
 static void
-decrypt(MPI output, MPI a, MPI b, ELG_secret_key *skey )
+decrypt(gcry_mpi_t output, gcry_mpi_t a, gcry_mpi_t b, ELG_secret_key *skey )
 {
-    MPI t1 = mpi_alloc_secure( mpi_get_nlimbs( skey->p ) );
+    gcry_mpi_t t1 = mpi_alloc_secure( mpi_get_nlimbs( skey->p ) );
 
     /* output = b/(a^x) mod p */
     gcry_mpi_powm( t1, a, skey->x, skey->p );
@@ -398,12 +398,12 @@ decrypt(MPI output, MPI a, MPI b, ELG_secret_key *skey )
  */
 
 static void
-sign(MPI a, MPI b, MPI input, ELG_secret_key *skey )
+sign(gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_secret_key *skey )
 {
-    MPI k;
-    MPI t   = mpi_alloc( mpi_get_nlimbs(a) );
-    MPI inv = mpi_alloc( mpi_get_nlimbs(a) );
-    MPI p_1 = mpi_copy(skey->p);
+    gcry_mpi_t k;
+    gcry_mpi_t t   = mpi_alloc( mpi_get_nlimbs(a) );
+    gcry_mpi_t inv = mpi_alloc( mpi_get_nlimbs(a) );
+    gcry_mpi_t p_1 = mpi_copy(skey->p);
 
    /*
     * b = (t * inv) mod (p-1)
@@ -442,13 +442,13 @@ sign(MPI a, MPI b, MPI input, ELG_secret_key *skey )
  * Returns true if the signature composed of A and B is valid.
  */
 static int
-verify(MPI a, MPI b, MPI input, ELG_public_key *pkey )
+verify(gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_public_key *pkey )
 {
     int rc;
-    MPI t1;
-    MPI t2;
-    MPI base[4];
-    MPI exp[4];
+    gcry_mpi_t t1;
+    gcry_mpi_t t2;
+    gcry_mpi_t base[4];
+    gcry_mpi_t exp[4];
 
     if( !(mpi_cmp_ui( a, 0 ) > 0 && mpi_cmp( a, pkey->p ) < 0) )
 	return 0; /* assertion	0 < a < p  failed */
@@ -500,7 +500,7 @@ verify(MPI a, MPI b, MPI input, ELG_public_key *pkey )
 
 gpg_err_code_t
 _gcry_elg_generate (int algo, unsigned nbits, unsigned long dummy,
-                    MPI *skey, MPI **retfactors)
+                    gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
   ELG_secret_key sk;
 
@@ -515,7 +515,7 @@ _gcry_elg_generate (int algo, unsigned nbits, unsigned long dummy,
 
 
 gpg_err_code_t
-_gcry_elg_check_secret_key (int algo, MPI *skey)
+_gcry_elg_check_secret_key (int algo, gcry_mpi_t *skey)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_secret_key sk;
@@ -538,7 +538,7 @@ _gcry_elg_check_secret_key (int algo, MPI *skey)
 
 
 gpg_err_code_t
-_gcry_elg_encrypt (int algo, MPI *resarr, MPI data, MPI *pkey, int flags)
+_gcry_elg_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey, int flags)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_public_key pk;
@@ -559,7 +559,7 @@ _gcry_elg_encrypt (int algo, MPI *resarr, MPI data, MPI *pkey, int flags)
 
 
 gpg_err_code_t
-_gcry_elg_decrypt (int algo, MPI *result, MPI *data, MPI *skey, int flags)
+_gcry_elg_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_secret_key sk;
@@ -581,7 +581,7 @@ _gcry_elg_decrypt (int algo, MPI *result, MPI *data, MPI *skey, int flags)
 
 
 gpg_err_code_t
-_gcry_elg_sign (int algo, MPI *resarr, MPI data, MPI *skey)
+_gcry_elg_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_secret_key sk;
@@ -604,8 +604,8 @@ _gcry_elg_sign (int algo, MPI *resarr, MPI data, MPI *skey)
 }
 
 gpg_err_code_t
-_gcry_elg_verify (int algo, MPI hash, MPI *data, MPI *pkey,
-		  int (*cmp) (void *, MPI), void *opaquev)
+_gcry_elg_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+		  int (*cmp) (void *, gcry_mpi_t), void *opaquev)
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   ELG_public_key pk;
@@ -627,7 +627,7 @@ _gcry_elg_verify (int algo, MPI hash, MPI *data, MPI *pkey,
 
 
 unsigned int
-_gcry_elg_get_nbits (int algo, MPI *pkey)
+_gcry_elg_get_nbits (int algo, gcry_mpi_t *pkey)
 {
   return mpi_get_nbits (pkey[0]);
 }
diff --git a/cipher/md.c b/cipher/md.c
index 78f4b4ef..4ee87542 100644
--- a/cipher/md.c
+++ b/cipher/md.c
@@ -86,7 +86,7 @@ static struct
 #if USE_SHA256
     { &digest_spec_sha256, 0 },
 #endif
-#if USE_SHA256
+#if USE_SHA512
     { &digest_spec_sha512, 0 },
     { &digest_spec_sha384, 0 },
 #endif
@@ -441,7 +441,7 @@ md_open (gcry_md_hd_t *h, int algo, int secure, int hmac)
   if (! err)
     {
       /* FIXME: should we really do that? */
-      fast_random_poll ();
+      _gcry_fast_random_poll ();
 
       if (algo)
 	{
diff --git a/cipher/md4.c b/cipher/md4.c
index db992aad..bf4f104e 100644
--- a/cipher/md4.c
+++ b/cipher/md4.c
@@ -98,7 +98,7 @@ transform( MD4_CONTEXT *ctx, byte *data )
     register u32 C = ctx->C;
     register u32 D = ctx->D;
 
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
     { int i;
       byte *p2, *p1;
       for(i=0, p1=data, p2=(byte*)in; i < 16; i++, p2 += 4 ) {
@@ -278,7 +278,7 @@ md4_final( void *context )
     _gcry_burn_stack (80+6*sizeof(void*));
 
     p = hd->buf;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define X(a) do { *p++ = hd->a      ; *p++ = hd->a >> 8;      \
 		      *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
 #else /* little endian */
diff --git a/cipher/md5.c b/cipher/md5.c
index 73915fdc..ca7cfe26 100644
--- a/cipher/md5.c
+++ b/cipher/md5.c
@@ -89,7 +89,7 @@ transform( MD5_CONTEXT *ctx, byte *data )
     register u32 D = ctx->D;
     u32 *cwp = correct_words;
 
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
     { int i;
       byte *p2, *p1;
       for(i=0, p1=data, p2=(byte*)correct_words; i < 16; i++, p2 += 4 ) {
@@ -303,7 +303,7 @@ md5_final( void *context)
     _gcry_burn_stack (80+6*sizeof(void*));
 
     p = hd->buf;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define X(a) do { *p++ = hd->a      ; *p++ = hd->a >> 8;      \
 		      *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
 #else /* little endian */
diff --git a/cipher/primegen.c b/cipher/primegen.c
index eb6e1e42..34361e3e 100644
--- a/cipher/primegen.c
+++ b/cipher/primegen.c
@@ -32,10 +32,10 @@
 #include "mpi.h"
 #include "cipher.h"
 
-static MPI gen_prime (unsigned int nbits, int secret, int randomlevel, 
-                      int (*extra_check)(void *, MPI), void *extra_check_arg);
-static int check_prime( MPI prime, MPI val_2 );
-static int is_prime( MPI n, int steps, int *count );
+static gcry_mpi_t gen_prime (unsigned int nbits, int secret, int randomlevel, 
+                      int (*extra_check)(void *, gcry_mpi_t), void *extra_check_arg);
+static int check_prime( gcry_mpi_t prime, gcry_mpi_t val_2 );
+static int is_prime( gcry_mpi_t n, int steps, int *count );
 static void m_out_of_n( char *array, int m, int n );
 
 static void (*progress_cb) (void *,const char*,int,int, int );
@@ -146,24 +146,24 @@ progress( int c )
 /****************
  * Generate a prime number (stored in secure memory)
  */
-MPI
+gcry_mpi_t
 _gcry_generate_secret_prime (unsigned int nbits,
-                             int (*extra_check)(void*, MPI),
+                             int (*extra_check)(void*, gcry_mpi_t),
                              void *extra_check_arg)
 {
-    MPI prime;
+    gcry_mpi_t prime;
 
     prime = gen_prime( nbits, 1, 2, extra_check, extra_check_arg);
     progress('\n');
     return prime;
 }
 
-MPI
+gcry_mpi_t
 _gcry_generate_public_prime( unsigned int nbits,
-                             int (*extra_check)(void*, MPI),
+                             int (*extra_check)(void*, gcry_mpi_t),
                              void *extra_check_arg)
 {
-    MPI prime;
+    gcry_mpi_t prime;
 
     prime = gen_prime( nbits, 0, 2, extra_check, extra_check_arg );
     progress('\n');
@@ -180,24 +180,24 @@ _gcry_generate_public_prime( unsigned int nbits,
  * mode 0: Standard
  *	1: Make sure that at least one factor is of size qbits.
  */
-MPI
+gcry_mpi_t
 _gcry_generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
-		    MPI g, MPI **ret_factors )
+		    gcry_mpi_t g, gcry_mpi_t **ret_factors )
 {
     int n;  /* number of factors */
     int m;  /* number of primes in pool */
     unsigned fbits; /* length of prime factors */
-    MPI *factors; /* current factors */
-    MPI *pool;	/* pool of primes */
-    MPI q;	/* first prime factor (variable)*/
-    MPI prime;	/* prime test value */
-    MPI q_factor; /* used for mode 1 */
+    gcry_mpi_t *factors; /* current factors */
+    gcry_mpi_t *pool;	/* pool of primes */
+    gcry_mpi_t q;	/* first prime factor (variable)*/
+    gcry_mpi_t prime;	/* prime test value */
+    gcry_mpi_t q_factor; /* used for mode 1 */
     byte *perms = NULL;
     int i, j;
     int count1, count2;
     unsigned nprime;
     unsigned req_qbits = qbits; /* the requested q bits size */
-    MPI val_2  = mpi_alloc_set_ui( 2 );
+    gcry_mpi_t val_2  = mpi_alloc_set_ui( 2 );
 
     /* find number of needed prime factors */
     for(n=1; (pbits - qbits - 1) / n  >= qbits; n++ )
@@ -330,9 +330,9 @@ _gcry_generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
     }
 
     if( g ) { /* create a generator (start with 3)*/
-	MPI tmp   = mpi_alloc( mpi_get_nlimbs(prime) );
-	MPI b	  = mpi_alloc( mpi_get_nlimbs(prime) );
-	MPI pmin1 = mpi_alloc( mpi_get_nlimbs(prime) );
+	gcry_mpi_t tmp   = mpi_alloc( mpi_get_nlimbs(prime) );
+	gcry_mpi_t b	  = mpi_alloc( mpi_get_nlimbs(prime) );
+	gcry_mpi_t pmin1 = mpi_alloc( mpi_get_nlimbs(prime) );
 
 	if( mode == 1 )
 	    BUG(); /* not yet implemented */
@@ -382,11 +382,11 @@ _gcry_generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
 
 
 
-static MPI
+static gcry_mpi_t
 gen_prime (unsigned int nbits, int secret, int randomlevel, 
-           int (*extra_check)(void *, MPI), void *extra_check_arg)
+           int (*extra_check)(void *, gcry_mpi_t), void *extra_check_arg)
 {
-  MPI prime, ptest, pminus1, val_2, val_3, result;
+  gcry_mpi_t prime, ptest, pminus1, val_2, val_3, result;
   int i;
   unsigned x, step;
   unsigned count1, count2;
@@ -396,7 +396,7 @@ gen_prime (unsigned int nbits, int secret, int randomlevel,
     log_debug("generate a prime of %u bits ", nbits );
 
   mods = gcry_xmalloc( no_of_small_prime_numbers * sizeof *mods );
-  /* make nbits fit into MPI implementation */
+  /* make nbits fit into gcry_mpi_t implementation */
   val_2  = mpi_alloc_set_ui( 2 );
   val_3 = mpi_alloc_set_ui( 3);
   prime  = secret? gcry_mpi_snew ( nbits ): gcry_mpi_new ( nbits );
@@ -487,7 +487,7 @@ gen_prime (unsigned int nbits, int secret, int randomlevel,
  * Returns: true if this may be a prime
  */
 static int
-check_prime( MPI prime, MPI val_2 )
+check_prime( gcry_mpi_t prime, gcry_mpi_t val_2 )
 {
     int i;
     unsigned x;
@@ -501,8 +501,8 @@ check_prime( MPI prime, MPI val_2 )
 
     /* a quick fermat test */
     {
-	MPI result = mpi_alloc_like( prime );
-	MPI pminus1 = mpi_alloc_like( prime );
+	gcry_mpi_t result = mpi_alloc_like( prime );
+	gcry_mpi_t pminus1 = mpi_alloc_like( prime );
 	mpi_sub_ui( pminus1, prime, 1);
 	gcry_mpi_powm( result, val_2, pminus1, prime );
 	mpi_free( pminus1 );
@@ -526,14 +526,14 @@ check_prime( MPI prime, MPI val_2 )
  * Return true if n is probably a prime
  */
 static int
-is_prime( MPI n, int steps, int *count )
+is_prime( gcry_mpi_t n, int steps, int *count )
 {
-    MPI x = mpi_alloc( mpi_get_nlimbs( n ) );
-    MPI y = mpi_alloc( mpi_get_nlimbs( n ) );
-    MPI z = mpi_alloc( mpi_get_nlimbs( n ) );
-    MPI nminus1 = mpi_alloc( mpi_get_nlimbs( n ) );
-    MPI a2 = mpi_alloc_set_ui( 2 );
-    MPI q;
+    gcry_mpi_t x = mpi_alloc( mpi_get_nlimbs( n ) );
+    gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs( n ) );
+    gcry_mpi_t z = mpi_alloc( mpi_get_nlimbs( n ) );
+    gcry_mpi_t nminus1 = mpi_alloc( mpi_get_nlimbs( n ) );
+    gcry_mpi_t a2 = mpi_alloc_set_ui( 2 );
+    gcry_mpi_t q;
     unsigned i, j, k;
     int rc = 0;
     unsigned nbits = mpi_get_nbits( n );
diff --git a/cipher/pubkey.c b/cipher/pubkey.c
index 3584c61e..ca3cb238 100644
--- a/cipher/pubkey.c
+++ b/cipher/pubkey.c
@@ -30,10 +30,10 @@
 #include "cipher.h"
 #include "ath.h"
 
-static gpg_err_code_t pubkey_decrypt (int algo, MPI *result, MPI *data, MPI *skey, int flags);
-static gpg_err_code_t pubkey_sign (int algo, MPI *resarr, MPI hash, MPI *skey);
-static gpg_err_code_t pubkey_verify (int algo, MPI hash, MPI *data, MPI *pkey,
-				     int (*cmp) (void *, MPI), void *opaque);
+static gpg_err_code_t pubkey_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags);
+static gpg_err_code_t pubkey_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t hash, gcry_mpi_t *skey);
+static gpg_err_code_t pubkey_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+				     int (*cmp) (void *, gcry_mpi_t), void *opaque);
 
 /* This is the list of the default public-key ciphers included in
    libgcrypt.  */
@@ -83,50 +83,50 @@ static int default_pubkeys_registered;
 
 static gpg_err_code_t
 dummy_generate (int id, unsigned int nbits, unsigned long dummy,
-                MPI *skey, MPI **retfactors)
+                gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
   log_bug ("no generate() for %d\n", id);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_check_secret_key (int id, MPI *skey)
+dummy_check_secret_key (int id, gcry_mpi_t *skey)
 {
   log_bug ("no check_secret_key() for %d\n", id);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_encrypt (int id, MPI *resarr, MPI data, MPI *pkey, int flags)
+dummy_encrypt (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey, int flags)
 {
   log_bug ("no encrypt() for %d\n", id);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_decrypt (int id, MPI *result, MPI *data, MPI *skey, int flags)
+dummy_decrypt (int id, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey, int flags)
 {
   log_bug ("no decrypt() for %d\n", id);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_sign (int id, MPI *resarr, MPI data, MPI *skey)
+dummy_sign (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   log_bug ("no sign() for %d\n", id);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static gpg_err_code_t
-dummy_verify (int id, MPI hash, MPI *data, MPI *pkey,
-	      int (*cmp) (void *, MPI), void *opaquev)
+dummy_verify (int id, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+	      int (*cmp) (void *, gcry_mpi_t), void *opaquev)
 {
   log_bug ("no verify() for %d\n", id);
   return GPG_ERR_PUBKEY_ALGO;
 }
 
 static unsigned
-dummy_get_nbits (int id, MPI *pkey)
+dummy_get_nbits (int id, gcry_mpi_t *pkey)
 {
   log_bug ("no get_nbits() for %d\n", id);
   return 0;
@@ -264,7 +264,7 @@ gcry_pubkey_unregister (GcryModule *module)
 }
 
 static void
-release_mpi_array (MPI *array)
+release_mpi_array (gcry_mpi_t *array)
 {
   for (; *array; array++)
     {
@@ -468,7 +468,7 @@ pubkey_get_nenc (int id)
 
 static gpg_err_code_t
 pubkey_generate (int id, unsigned int nbits, unsigned long use_e,
-                 MPI *skey, MPI **retfactors)
+                 gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
   gpg_err_code_t err = GPG_ERR_PUBKEY_ALGO;
   GcryModule *pubkey;
@@ -489,7 +489,7 @@ pubkey_generate (int id, unsigned int nbits, unsigned long use_e,
 }
 
 static gpg_err_code_t
-pubkey_check_secret_key (int id, MPI *skey)
+pubkey_check_secret_key (int id, gcry_mpi_t *skey)
 {
   gpg_err_code_t err = GPG_ERR_PUBKEY_ALGO;
   GcryModule *pubkey;
@@ -510,13 +510,13 @@ pubkey_check_secret_key (int id, MPI *skey)
 
 
 /****************
- * This is the interface to the public key encryption.
- * Encrypt DATA with PKEY and put it into RESARR which
- * should be an array of MPIs of size PUBKEY_MAX_NENC (or less if the
- * algorithm allows this - check with pubkey_get_nenc() )
+ * This is the interface to the public key encryption.  Encrypt DATA
+ * with PKEY and put it into RESARR which should be an array of MPIs
+ * of size PUBKEY_MAX_NENC (or less if the algorithm allows this -
+ * check with pubkey_get_nenc() )
  */
 static gpg_err_code_t
-pubkey_encrypt (int id, MPI *resarr, MPI data, MPI *pkey,
+pubkey_encrypt (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
 		int flags)
 {
   GcryPubkeySpec *pubkey;
@@ -563,7 +563,7 @@ pubkey_encrypt (int id, MPI *resarr, MPI data, MPI *pkey,
  * newly allocated mpi or NULL in case of an error.
  */
 static gpg_err_code_t
-pubkey_decrypt (int id, MPI *result, MPI *data, MPI *skey,
+pubkey_decrypt (int id, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
 		int flags)
 {
   GcryPubkeySpec *pubkey;
@@ -610,7 +610,7 @@ pubkey_decrypt (int id, MPI *result, MPI *data, MPI *skey,
  * algorithm allows this - check with pubkey_get_nsig() )
  */
 static gpg_err_code_t
-pubkey_sign (int id, MPI *resarr, MPI data, MPI *skey)
+pubkey_sign (int id, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   GcryPubkeySpec *pubkey;
   GcryModule *module;
@@ -652,8 +652,8 @@ pubkey_sign (int id, MPI *resarr, MPI data, MPI *skey)
  * Return 0 if the signature is good
  */
 static gpg_err_code_t
-pubkey_verify (int id, MPI hash, MPI *data, MPI *pkey,
-	       int (*cmp)(void *, MPI), void *opaquev)
+pubkey_verify (int id, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+	       int (*cmp)(void *, gcry_mpi_t), void *opaquev)
 {
   GcryPubkeySpec *pubkey;
   GcryModule *module;
@@ -753,7 +753,7 @@ sexp_elements_extract (gcry_sexp_t key_sexp, const char *element_names,
  * The <mpi> are expected to be in GCRYMPI_FMT_USG
  */
 static gpg_err_code_t
-sexp_to_key (gcry_sexp_t sexp, int want_private, MPI **retarray,
+sexp_to_key (gcry_sexp_t sexp, int want_private, gcry_mpi_t **retarray,
              GcryModule **retalgo)
 {
     gcry_sexp_t list, l2;
@@ -830,7 +830,7 @@ sexp_to_key (gcry_sexp_t sexp, int want_private, MPI **retarray,
 }
 
 static gpg_err_code_t
-sexp_to_sig (gcry_sexp_t sexp, MPI **retarray,
+sexp_to_sig (gcry_sexp_t sexp, gcry_mpi_t **retarray,
 	     GcryModule **retalgo)
 {
     gcry_sexp_t list, l2;
@@ -922,7 +922,7 @@ sexp_to_sig (gcry_sexp_t sexp, MPI **retarray,
  * RET_MODERN is set to true when at least an empty flags list has been found.
  */
 static gpg_err_code_t
-sexp_to_enc (gcry_sexp_t sexp, MPI **retarray, GcryModule **retalgo,
+sexp_to_enc (gcry_sexp_t sexp, gcry_mpi_t **retarray, GcryModule **retalgo,
              int *ret_modern, int *ret_want_pkcs1, int *flags)
 {
   gcry_sexp_t list = NULL, l2 = NULL;
@@ -1326,7 +1326,7 @@ sexp_data_to_mpi (gcry_sexp_t input, unsigned int nbits, gcry_mpi_t *ret_mpi,
 gpg_error_t
 gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
 {
-  MPI *pkey = NULL, data = NULL, *ciph = NULL;
+  gcry_mpi_t *pkey = NULL, data = NULL, *ciph = NULL;
   const char *algo_name, *algo_elems;
   int flags;
   gpg_err_code_t rc;
@@ -1450,7 +1450,7 @@ gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
 gpg_error_t
 gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
 {
-  MPI *skey = NULL, *data = NULL, plain = NULL;
+  gcry_mpi_t *skey = NULL, *data = NULL, plain = NULL;
   int modern, want_pkcs1, flags;
   gpg_err_code_t rc;
   GcryModule *module_enc = NULL, *module_key = NULL;
@@ -1548,7 +1548,7 @@ gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
 gpg_error_t
 gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
 {
-  MPI *skey = NULL, hash = NULL, *result = NULL;
+  gcry_mpi_t *skey = NULL, hash = NULL, *result = NULL;
   GcryPubkeySpec *pubkey = NULL;
   GcryModule *module = NULL;
   const char *key_algo_name, *algo_name, *algo_elems;
@@ -1650,7 +1650,7 @@ gpg_error_t
 gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
 {
   GcryModule *module_key = NULL, *module_sig = NULL;
-  MPI *pkey = NULL, hash = NULL, *sig = NULL;
+  gcry_mpi_t *pkey = NULL, hash = NULL, *sig = NULL;
   gpg_err_code_t rc;
 
   REGISTER_DEFAULT_PUBKEYS;
@@ -1710,7 +1710,7 @@ gpg_error_t
 gcry_pk_testkey (gcry_sexp_t s_key)
 {
   GcryModule *module = NULL;
-  MPI *key = NULL;
+  gcry_mpi_t *key = NULL;
   gpg_err_code_t rc;
   
   REGISTER_DEFAULT_PUBKEYS;
@@ -1990,7 +1990,7 @@ gcry_pk_get_nbits (gcry_sexp_t key)
 {
   GcryModule *module = NULL;
   GcryPubkeySpec *pubkey;
-  MPI *keyarr = NULL;
+  gcry_mpi_t *keyarr = NULL;
   unsigned int nbits = 0;
   gpg_err_code_t rc;
 
diff --git a/cipher/random.c b/cipher/random.c
index f1be289b..2105036c 100644
--- a/cipher/random.c
+++ b/cipher/random.c
@@ -741,29 +741,21 @@ static int (*
 getfnc_gather_random (void))(void (*)(const void*, size_t, int), int,
 			     size_t, int)
 {
-#if USE_RNDLINUX
   int rndlinux_gather_random (void (*add) (const void *, size_t, int),
 			      int requester, size_t length, int level);
-#endif
-#if USE_RNDUNIX
   int rndunix_gather_random (void (*add) (const void *, size_t, int),
 			     int requester, size_t length, int level);
-#endif
-#if USE_RNDEGD
   int rndegd_gather_random (void (*add) (const void *, size_t, int),
 			    int requester, size_t length, int level);
   int rndegd_connect_socket (int nofail);
-#endif
-#if USE_RNDW32
   int rndw32_gather_random (void (*add) (const void *, size_t, int),
 			    int requester, size_t length, int level);
-#endif
 
-#ifdef USE_ALL_RANDOM_MODULES
   static int (*fnc)(void (*)(const void*, size_t, int), int, size_t, int);
   
   if (fnc)
     return fnc;
+
 #if USE_RNDLINUX
   if ( !access (NAME_OF_DEV_RANDOM, R_OK)
        && !access (NAME_OF_DEV_RANDOM, R_OK))
@@ -772,6 +764,7 @@ getfnc_gather_random (void))(void (*)(const void*, size_t, int), int,
       return fnc;
     }
 #endif
+
 #if USE_RNDEGD
   if ( rndegd_connect_socket (1) != -1 )
     {
@@ -779,6 +772,7 @@ getfnc_gather_random (void))(void (*)(const void*, size_t, int), int,
       return fnc;
     }
 #endif
+
 #if USE_RNDUNIX
   fnc = rndunix_gather_random;
   return fnc;
@@ -786,23 +780,6 @@ getfnc_gather_random (void))(void (*)(const void*, size_t, int), int,
 
   log_fatal (_("no entropy gathering module detected\n"));
 
-#else
-#if USE_RNDLINUX
-  return rndlinux_gather_random;
-#endif
-#if USE_RNDUNIX
-  return rndunix_gather_random;
-#endif
-#if USE_RNDEGD
-  return rndegd_gather_random;
-#endif
-#if USE_RNDW32
-  return rndw32_gather_random;
-#endif
-#if USE_RNDRISCOS
-  return rndriscos_gather_random;
-#endif
-#endif
   return NULL;
 }
 
diff --git a/cipher/random.h b/cipher/random.h
index 0c7d9e0f..3536dc01 100644
--- a/cipher/random.h
+++ b/cipher/random.h
@@ -22,9 +22,6 @@
 
 #include "types.h"
 
-/*-- random.c --*/
-#define fast_random_poll() _gcry_fast_random_poll ()
-
 void _gcry_random_initialize (void);
 void _gcry_register_random_progress (void (*cb)(void *,const char*,int,int,int),
                                      void *cb_data );
diff --git a/cipher/rmd160.c b/cipher/rmd160.c
index ccf630de..a0b11fc6 100644
--- a/cipher/rmd160.c
+++ b/cipher/rmd160.c
@@ -164,7 +164,7 @@ transform( RMD160_CONTEXT *hd, byte *data )
 {
   register u32 a,b,c,d,e;
   u32 aa,bb,cc,dd,ee,t;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
   u32 x[16];
   { int i;
   byte *p2, *p1;
@@ -501,7 +501,7 @@ rmd160_final( void *context )
     _gcry_burn_stack (108+5*sizeof(void*));
 
     p = hd->buf;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define X(a) do { *p++ = hd->h##a	   ; *p++ = hd->h##a >> 8;	\
 		      *p++ = hd->h##a >> 16; *p++ = hd->h##a >> 24; } while(0)
 #else /* little endian */
diff --git a/cipher/rsa.c b/cipher/rsa.c
index b317f749..ad266588 100644
--- a/cipher/rsa.c
+++ b/cipher/rsa.c
@@ -35,19 +35,19 @@
 
 typedef struct
 {
-  MPI n;	    /* modulus */
-  MPI e;	    /* exponent */
+  gcry_mpi_t n;	    /* modulus */
+  gcry_mpi_t e;	    /* exponent */
 } RSA_public_key;
 
 
 typedef struct
 {
-  MPI n;	    /* public modulus */
-  MPI e;	    /* public exponent */
-  MPI d;	    /* exponent */
-  MPI p;	    /* prime  p. */
-  MPI q;	    /* prime  q. */
-  MPI u;	    /* inverse of p mod q. */
+  gcry_mpi_t n;	    /* public modulus */
+  gcry_mpi_t e;	    /* public exponent */
+  gcry_mpi_t d;	    /* exponent */
+  gcry_mpi_t p;	    /* prime  p. */
+  gcry_mpi_t q;	    /* prime  q. */
+  gcry_mpi_t u;	    /* inverse of p mod q. */
 } RSA_secret_key;
 
 
@@ -55,17 +55,17 @@ static void test_keys (RSA_secret_key *sk, unsigned nbits);
 static void generate (RSA_secret_key *sk,
                       unsigned int nbits, unsigned long use_e);
 static int  check_secret_key (RSA_secret_key *sk);
-static void public (MPI output, MPI input, RSA_public_key *skey);
-static void secret (MPI output, MPI input, RSA_secret_key *skey);
+static void public (gcry_mpi_t output, gcry_mpi_t input, RSA_public_key *skey);
+static void secret (gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey);
 
 
 static void
 test_keys( RSA_secret_key *sk, unsigned nbits )
 {
     RSA_public_key pk;
-    MPI test = gcry_mpi_new ( nbits );
-    MPI out1 = gcry_mpi_new ( nbits );
-    MPI out2 = gcry_mpi_new ( nbits );
+    gcry_mpi_t test = gcry_mpi_new ( nbits );
+    gcry_mpi_t out1 = gcry_mpi_new ( nbits );
+    gcry_mpi_t out2 = gcry_mpi_new ( nbits );
 
     pk.n = sk->n;
     pk.e = sk->e;
@@ -88,10 +88,10 @@ test_keys( RSA_secret_key *sk, unsigned nbits )
 /* Callback used by the prime generation to test whether the exponent
    is suitable. Returns 0 if the test has been passed. */
 static int
-check_exponent (void *arg, MPI a)
+check_exponent (void *arg, gcry_mpi_t a)
 {
-  MPI e = arg;
-  MPI tmp;
+  gcry_mpi_t e = arg;
+  gcry_mpi_t tmp;
   int result;
   
   mpi_sub_ui (a, a, 1);
@@ -113,15 +113,15 @@ check_exponent (void *arg, MPI a)
 static void
 generate (RSA_secret_key *sk, unsigned int nbits, unsigned long use_e)
 {
-    MPI p, q; /* the two primes */
-    MPI d;    /* the private key */
-    MPI u;
-    MPI t1, t2;
-    MPI n;    /* the public key */
-    MPI e;    /* the exponent */
-    MPI phi;  /* helper: (p-1)(q-1) */
-    MPI g;
-    MPI f;
+    gcry_mpi_t p, q; /* the two primes */
+    gcry_mpi_t d;    /* the private key */
+    gcry_mpi_t u;
+    gcry_mpi_t t1, t2;
+    gcry_mpi_t n;    /* the public key */
+    gcry_mpi_t e;    /* the exponent */
+    gcry_mpi_t phi;  /* helper: (p-1)(q-1) */
+    gcry_mpi_t g;
+    gcry_mpi_t f;
 
     /* make sure that nbits is even so that we generate p, q of equal size */
     if ( (nbits&1) )
@@ -239,7 +239,7 @@ static int
 check_secret_key( RSA_secret_key *sk )
 {
     int rc;
-    MPI temp = mpi_alloc( mpi_get_nlimbs(sk->p)*2 );
+    gcry_mpi_t temp = mpi_alloc( mpi_get_nlimbs(sk->p)*2 );
 
     mpi_mul(temp, sk->p, sk->q );
     rc = mpi_cmp( temp, sk->n );
@@ -257,10 +257,10 @@ check_secret_key( RSA_secret_key *sk )
  * Where c is OUTPUT, m is INPUT and e,n are elements of PKEY.
  */
 static void
-public(MPI output, MPI input, RSA_public_key *pkey )
+public(gcry_mpi_t output, gcry_mpi_t input, RSA_public_key *pkey )
 {
     if( output == input ) { /* powm doesn't like output and input the same */
-	MPI x = mpi_alloc( mpi_get_nlimbs(input)*2 );
+	gcry_mpi_t x = mpi_alloc( mpi_get_nlimbs(input)*2 );
 	mpi_powm( x, input, pkey->e, pkey->n );
 	mpi_set(output, x);
 	mpi_free(x);
@@ -273,10 +273,10 @@ public(MPI output, MPI input, RSA_public_key *pkey )
 static void
 stronger_key_check ( RSA_secret_key *skey )
 {
-  MPI t = mpi_alloc_secure ( 0 );
-  MPI t1 = mpi_alloc_secure ( 0 );
-  MPI t2 = mpi_alloc_secure ( 0 );
-  MPI phi = mpi_alloc_secure ( 0 );
+  gcry_mpi_t t = mpi_alloc_secure ( 0 );
+  gcry_mpi_t t1 = mpi_alloc_secure ( 0 );
+  gcry_mpi_t t2 = mpi_alloc_secure ( 0 );
+  gcry_mpi_t phi = mpi_alloc_secure ( 0 );
 
   /* check that n == p * q */
   mpi_mul( t, skey->p, skey->q);
@@ -349,14 +349,14 @@ stronger_key_check ( RSA_secret_key *skey )
  * Where m is OUTPUT, c is INPUT and d,n,p,q,u are elements of SKEY.
  */
 static void
-secret(MPI output, MPI input, RSA_secret_key *skey )
+secret(gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey )
 {
 #if 0
     mpi_powm( output, input, skey->d, skey->n );
 #else
-    MPI m1   = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
-    MPI m2   = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
-    MPI h    = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
+    gcry_mpi_t m1   = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
+    gcry_mpi_t m2   = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
+    gcry_mpi_t h    = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
 
     /* m1 = c ^ (d mod (p-1)) mod p */
     mpi_sub_ui( h, skey->p, 1  );
@@ -390,7 +390,7 @@ secret(MPI output, MPI input, RSA_secret_key *skey )
 
 gpg_err_code_t
 _gcry_rsa_generate (int algo, unsigned int nbits, unsigned long use_e,
-                    MPI *skey, MPI **retfactors)
+                    gcry_mpi_t *skey, gcry_mpi_t **retfactors)
 {
   RSA_secret_key sk;
 
@@ -410,7 +410,7 @@ _gcry_rsa_generate (int algo, unsigned int nbits, unsigned long use_e,
 
 
 gpg_err_code_t
-_gcry_rsa_check_secret_key( int algo, MPI *skey )
+_gcry_rsa_check_secret_key( int algo, gcry_mpi_t *skey )
 {
   gpg_err_code_t err = GPG_ERR_NO_ERROR;
   RSA_secret_key sk;
@@ -430,7 +430,7 @@ _gcry_rsa_check_secret_key( int algo, MPI *skey )
 
 
 gpg_err_code_t
-_gcry_rsa_encrypt (int algo, MPI *resarr, MPI data, MPI *pkey,
+_gcry_rsa_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
 		   int flags)
 {
   RSA_public_key pk;
@@ -445,7 +445,7 @@ _gcry_rsa_encrypt (int algo, MPI *resarr, MPI data, MPI *pkey,
 
 /* Perform RSA blinding.  */
 gcry_mpi_t
-_gcry_rsa_blind (MPI x, MPI r, MPI e, MPI n)
+_gcry_rsa_blind (gcry_mpi_t x, gcry_mpi_t r, gcry_mpi_t e, gcry_mpi_t n)
 {
   /* A helper.  */
   gcry_mpi_t a;
@@ -469,7 +469,7 @@ _gcry_rsa_blind (MPI x, MPI r, MPI e, MPI n)
 
 /* Undo RSA blinding.  */
 gcry_mpi_t
-_gcry_rsa_unblind (MPI x, MPI ri, MPI n)
+_gcry_rsa_unblind (gcry_mpi_t x, gcry_mpi_t ri, gcry_mpi_t n)
 {
   gcry_mpi_t y;
 
@@ -485,7 +485,7 @@ _gcry_rsa_unblind (MPI x, MPI ri, MPI n)
 }
 
 gpg_err_code_t
-_gcry_rsa_decrypt (int algo, MPI *result, MPI *data, MPI *skey,
+_gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
 		   int flags)
 {
   RSA_secret_key sk;
@@ -560,7 +560,7 @@ _gcry_rsa_decrypt (int algo, MPI *result, MPI *data, MPI *skey,
 }
 
 gpg_err_code_t
-_gcry_rsa_sign (int algo, MPI *resarr, MPI data, MPI *skey)
+_gcry_rsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
 {
   RSA_secret_key sk;
   
@@ -577,12 +577,12 @@ _gcry_rsa_sign (int algo, MPI *resarr, MPI data, MPI *skey)
 }
 
 gpg_err_code_t
-_gcry_rsa_verify (int algo, MPI hash, MPI *data, MPI *pkey,
-		  int (*cmp) (void *opaque, MPI tmp),
+_gcry_rsa_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
+		  int (*cmp) (void *opaque, gcry_mpi_t tmp),
 		  void *opaquev)
 {
   RSA_public_key pk;
-  MPI result;
+  gcry_mpi_t result;
   gpg_err_code_t rc;
 
   pk.n = pkey[0];
@@ -598,7 +598,7 @@ _gcry_rsa_verify (int algo, MPI hash, MPI *data, MPI *pkey,
 
 
 unsigned int
-_gcry_rsa_get_nbits (int algo, MPI *pkey)
+_gcry_rsa_get_nbits (int algo, gcry_mpi_t *pkey)
 {
   return mpi_get_nbits (pkey[0]);
 }
diff --git a/cipher/sha1.c b/cipher/sha1.c
index bc284c42..64f56fb7 100644
--- a/cipher/sha1.c
+++ b/cipher/sha1.c
@@ -77,7 +77,7 @@ transform( SHA1_CONTEXT *hd, byte *data )
     d = hd->h3;
     e = hd->h4;
 
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
     memcpy( x, data, 64 );
 #else
     { int i;
@@ -293,7 +293,7 @@ sha1_final(void *context)
     _gcry_burn_stack (88+4*sizeof(void*));
 
     p = hd->buf;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
 #else /* little endian */
 #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;	 \
diff --git a/cipher/sha256.c b/cipher/sha256.c
index 260ecd76..a33c36ae 100644
--- a/cipher/sha256.c
+++ b/cipher/sha256.c
@@ -129,7 +129,7 @@ transform (SHA256_CONTEXT *hd, byte *data)
   g = hd->h6;
   h = hd->h7;
   
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
   memcpy (x, data, 64);
 #else
   { 
@@ -264,7 +264,7 @@ sha256_final(void *context)
   _gcry_burn_stack (74*4+32);
 
   p = hd->buf;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
 #else /* little endian */
 #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;	 \
diff --git a/cipher/sha512.c b/cipher/sha512.c
index c731eae1..767e92ba 100644
--- a/cipher/sha512.c
+++ b/cipher/sha512.c
@@ -163,7 +163,7 @@ transform (SHA512_CONTEXT *hd, byte *data)
   g = hd->h6;
   h = hd->h7;
 
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
   memcpy (w, data, 128);
 #else
   {
@@ -332,7 +332,7 @@ sha512_final (void *context)
   _gcry_burn_stack (768);
 
   p = hd->buf;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define X(a) do { *(u64*)p = hd->h##a ; p += 8; } while (0)
 #else /* little endian */
 #define X(a) do { *p++ = hd->h##a >> 56; *p++ = hd->h##a >> 48;	      \
diff --git a/cipher/tiger.c b/cipher/tiger.c
index f8e6f938..5b0ef9a2 100644
--- a/cipher/tiger.c
+++ b/cipher/tiger.c
@@ -670,7 +670,7 @@ transform( TIGER_CONTEXT *hd, byte *data )
 {
     u64 a,b,c,aa,bb,cc;
     u64 x[8];
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define MKWORD(d,n) \
 		(  ((u64)(d)[8*(n)+7]) << 56 | ((u64)(d)[8*(n)+6]) << 48  \
 		 | ((u64)(d)[8*(n)+5]) << 40 | ((u64)(d)[8*(n)+4]) << 32  \
@@ -800,7 +800,7 @@ tiger_final( void *context )
     _gcry_burn_stack (21*8+11*sizeof(void*));
 
     p = hd->buf;
-#ifdef BIG_ENDIAN_HOST
+#ifdef WORDS_BIGENDIAN
 #define X(a) do { *(u64*)p = hd->a ; p += 8; } while(0)
 #else /* little endian */
 #define X(a) do { *p++ = hd->a >> 56; *p++ = hd->a >> 48; \