From 6b691a5c85ddc4e407e32781841fee5c029506cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ulf=20M=C3=B6ller?= <ulf@openssl.org>
Date: Mon, 19 Apr 1999 21:31:43 +0000
Subject: Change functions to ANSI C.

---
 crypto/asn1/a_bitstr.c | 19 ++++-----------
 crypto/asn1/a_bmp.c    | 10 +++-----
 crypto/asn1/a_bool.c   |  9 ++-----
 crypto/asn1/a_bytes.c  | 25 +++++--------------
 crypto/asn1/a_d2i_fp.c | 14 ++++-------
 crypto/asn1/a_digest.c |  8 ++-----
 crypto/asn1/a_dup.c    |  5 +---
 crypto/asn1/a_enum.c   | 25 ++++++-------------
 crypto/asn1/a_gentm.c  | 22 ++++++-----------
 crypto/asn1/a_hdr.c    | 15 ++++--------
 crypto/asn1/a_i2d_fp.c | 10 ++------
 crypto/asn1/a_int.c    | 25 ++++++-------------
 crypto/asn1/a_meth.c   |  4 ++--
 crypto/asn1/a_object.c | 37 ++++++++--------------------
 crypto/asn1/a_octet.c  | 10 +++-----
 crypto/asn1/a_print.c  | 62 ++++++++++++++++-------------------------------
 crypto/asn1/a_set.c    | 21 ++++------------
 crypto/asn1/a_sign.c   | 11 +++------
 crypto/asn1/a_time.c   | 13 +++-------
 crypto/asn1/a_type.c   | 25 ++++++-------------
 crypto/asn1/a_utctm.c  | 21 +++++-----------
 crypto/asn1/a_utf8.c   | 10 +++-----
 crypto/asn1/a_verify.c |  8 ++-----
 crypto/asn1/a_vis.c    | 10 +++-----
 crypto/asn1/asn1_err.c |  2 +-
 crypto/asn1/asn1_lib.c | 65 +++++++++++++-------------------------------------
 crypto/asn1/asn1_par.c | 23 ++++--------------
 crypto/asn1/asn_pack.c | 23 +++++-------------
 crypto/asn1/d2i_dhp.c  |  5 +---
 crypto/asn1/d2i_dsap.c |  5 +---
 crypto/asn1/d2i_pr.c   |  7 ++----
 crypto/asn1/d2i_pu.c   |  7 ++----
 crypto/asn1/d2i_r_pr.c |  7 ++----
 crypto/asn1/d2i_r_pu.c |  5 +---
 crypto/asn1/d2i_s_pr.c |  5 +---
 crypto/asn1/d2i_s_pu.c |  5 +---
 crypto/asn1/evp_asn1.c | 27 +++++++--------------
 crypto/asn1/f_enum.c   | 10 ++------
 crypto/asn1/f_int.c    | 10 ++------
 crypto/asn1/f_string.c | 11 ++-------
 crypto/asn1/i2d_dhp.c  |  4 +---
 crypto/asn1/i2d_dsap.c |  4 +---
 crypto/asn1/i2d_pr.c   |  4 +---
 crypto/asn1/i2d_pu.c   |  4 +---
 crypto/asn1/i2d_r_pr.c |  4 +---
 crypto/asn1/i2d_r_pu.c |  4 +---
 crypto/asn1/i2d_s_pr.c |  4 +---
 crypto/asn1/i2d_s_pu.c |  4 +---
 crypto/asn1/n_pkey.c   | 33 +++++++------------------
 crypto/asn1/nsseq.c    | 15 ++++--------
 crypto/asn1/p5_pbe.c   | 21 +++++-----------
 crypto/asn1/p5_pbev2.c | 29 +++++++---------------
 crypto/asn1/p7_dgst.c  | 15 ++++--------
 crypto/asn1/p7_enc.c   | 15 ++++--------
 crypto/asn1/p7_enc_c.c | 15 ++++--------
 crypto/asn1/p7_evp.c   | 15 ++++--------
 crypto/asn1/p7_i_s.c   | 15 ++++--------
 crypto/asn1/p7_lib.c   | 17 ++++---------
 crypto/asn1/p7_recip.c | 15 ++++--------
 crypto/asn1/p7_s_e.c   | 15 ++++--------
 crypto/asn1/p7_signd.c | 15 ++++--------
 crypto/asn1/p7_signi.c | 15 ++++--------
 crypto/asn1/p8_pkey.c  | 15 ++++--------
 crypto/asn1/pkcs8.c    | 14 ++++-------
 crypto/asn1/t_crl.c    | 12 +++-------
 crypto/asn1/t_pkey.c   | 44 ++++++++--------------------------
 crypto/asn1/t_req.c    |  8 ++-----
 crypto/asn1/t_x509.c   | 29 ++++++----------------
 crypto/asn1/x_algor.c  | 14 ++++-------
 crypto/asn1/x_attrib.c | 20 +++++-----------
 crypto/asn1/x_cinf.c   | 14 ++++-------
 crypto/asn1/x_crl.c    | 50 +++++++++++++-------------------------
 crypto/asn1/x_exten.c  | 15 ++++--------
 crypto/asn1/x_info.c   |  5 ++--
 crypto/asn1/x_name.c   | 36 +++++++++-------------------
 crypto/asn1/x_pkey.c   | 14 ++++-------
 crypto/asn1/x_pubkey.c | 22 ++++++-----------
 crypto/asn1/x_req.c    | 29 +++++++---------------
 crypto/asn1/x_sig.c    | 14 ++++-------
 crypto/asn1/x_spki.c   | 30 ++++++++---------------
 crypto/asn1/x_val.c    | 14 ++++-------
 crypto/asn1/x_x509.c   | 16 ++++---------
 82 files changed, 382 insertions(+), 951 deletions(-)

(limited to 'crypto/asn1')

diff --git a/crypto/asn1/a_bitstr.c b/crypto/asn1/a_bitstr.c
index 275de43eb6..cd4d835003 100644
--- a/crypto/asn1/a_bitstr.c
+++ b/crypto/asn1/a_bitstr.c
@@ -64,9 +64,7 @@
  * ASN1err(ASN1_F_D2I_ASN1_BIT_STRING,ASN1_R_EXPECTING_A_BIT_STRING);
  */
 
-int i2d_ASN1_BIT_STRING(a,pp)
-ASN1_BIT_STRING *a;
-unsigned char **pp;
+int i2d_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp)
 	{
 	int ret,j,r,bits,len;
 	unsigned char *p,*d;
@@ -116,10 +114,8 @@ unsigned char **pp;
 	return(r);
 	}
 
-ASN1_BIT_STRING *d2i_ASN1_BIT_STRING(a, pp, length)
-ASN1_BIT_STRING **a;
-unsigned char **pp;
-long length;
+ASN1_BIT_STRING *d2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, unsigned char **pp,
+	     long length)
 	{
 	ASN1_BIT_STRING *ret=NULL;
 	unsigned char *p,*s;
@@ -187,10 +183,7 @@ err:
 
 /* These next 2 functions from Goetz Babin-Ebell <babinebell@trustcenter.de>
  */
-int ASN1_BIT_STRING_set_bit(a,n,value)
-ASN1_BIT_STRING *a;
-int n;
-int value;
+int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value)
 	{
 	int w,v,iv;
 	unsigned char *c;
@@ -220,9 +213,7 @@ int value;
 	return(1);
 	}
 
-int ASN1_BIT_STRING_get_bit(a,n)
-ASN1_BIT_STRING *a;
-int n;
+int ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n)
 	{
 	int w,v;
 
diff --git a/crypto/asn1/a_bmp.c b/crypto/asn1/a_bmp.c
index 32a4fc2158..2cb322ab43 100644
--- a/crypto/asn1/a_bmp.c
+++ b/crypto/asn1/a_bmp.c
@@ -63,18 +63,14 @@
 /* ASN1err(ASN1_F_D2I_ASN1_BMPSTRING,ASN1_R_EXPECTING_AN_INTEGER);
  */
 
-int i2d_ASN1_BMPSTRING(a, pp)
-ASN1_BMPSTRING *a;
-unsigned char **pp;
+int i2d_ASN1_BMPSTRING(ASN1_BMPSTRING *a, unsigned char **pp)
 	{
 	return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
 		V_ASN1_BMPSTRING,V_ASN1_UNIVERSAL));
 	}
 
-ASN1_BMPSTRING *d2i_ASN1_BMPSTRING(a, pp, length)
-ASN1_BMPSTRING **a;
-unsigned char **pp;
-long length;
+ASN1_BMPSTRING *d2i_ASN1_BMPSTRING(ASN1_BMPSTRING **a, unsigned char **pp,
+	     long length)
 	{
 	ASN1_BMPSTRING *ret=NULL;
 
diff --git a/crypto/asn1/a_bool.c b/crypto/asn1/a_bool.c
index 41a95aa278..fc55a92f48 100644
--- a/crypto/asn1/a_bool.c
+++ b/crypto/asn1/a_bool.c
@@ -64,9 +64,7 @@
  * ASN1err(ASN1_F_D2I_ASN1_BOOLEAN,ASN1_R_BOOLEAN_IS_WRONG_LENGTH);
  */
 
-int i2d_ASN1_BOOLEAN(a,pp)
-int a;
-unsigned char **pp;
+int i2d_ASN1_BOOLEAN(int a, unsigned char **pp)
 	{
 	int r;
 	unsigned char *p;
@@ -81,10 +79,7 @@ unsigned char **pp;
 	return(r);
 	}
 
-int d2i_ASN1_BOOLEAN(a, pp, length)
-int *a;
-unsigned char **pp;
-long length;
+int d2i_ASN1_BOOLEAN(int *a, unsigned char **pp, long length)
 	{
 	int ret= -1;
 	unsigned char *p;
diff --git a/crypto/asn1/a_bytes.c b/crypto/asn1/a_bytes.c
index 9828a55b33..fdfe9ea8ef 100644
--- a/crypto/asn1/a_bytes.c
+++ b/crypto/asn1/a_bytes.c
@@ -83,11 +83,8 @@ static int asn1_collate_primative();
 
 /* type is a 'bitmap' of acceptable string types.
  */
-ASN1_STRING *d2i_ASN1_type_bytes(a, pp, length, type)
-ASN1_STRING **a;
-unsigned char **pp;
-long length;
-int type;
+ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a, unsigned char **pp,
+	     long length, int type)
 	{
 	ASN1_STRING *ret=NULL;
 	unsigned char *p,*s;
@@ -150,11 +147,7 @@ err:
 	return(NULL);
 	}
 
-int i2d_ASN1_bytes(a, pp, tag, xclass)
-ASN1_STRING *a;
-unsigned char **pp;
-int tag;
-int xclass;
+int i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass)
 	{
 	int ret,r,constructed;
 	unsigned char *p;
@@ -180,12 +173,8 @@ int xclass;
 	return(r);
 	}
 
-ASN1_STRING *d2i_ASN1_bytes(a, pp, length, Ptag, Pclass)
-ASN1_STRING **a;
-unsigned char **pp;
-long length;
-int Ptag;
-int Pclass;
+ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, unsigned char **pp, long length,
+	     int Ptag, int Pclass)
 	{
 	ASN1_STRING *ret=NULL;
 	unsigned char *p,*s;
@@ -277,9 +266,7 @@ err:
  * them into the one struture that is then returned */
 /* There have been a few bug fixes for this function from
  * Paul Keogh <paul.keogh@sse.ie>, many thanks to him */
-static int asn1_collate_primative(a,c)
-ASN1_STRING *a;
-ASN1_CTX *c;
+static int asn1_collate_primative(ASN1_STRING *a, ASN1_CTX *c)
 	{
 	ASN1_STRING *os=NULL;
 	BUF_MEM b;
diff --git a/crypto/asn1/a_d2i_fp.c b/crypto/asn1/a_d2i_fp.c
index d952836a91..465986eb63 100644
--- a/crypto/asn1/a_d2i_fp.c
+++ b/crypto/asn1/a_d2i_fp.c
@@ -64,11 +64,8 @@
 #define HEADER_SIZE   8
 
 #ifndef NO_FP_API
-char *ASN1_d2i_fp(xnew,d2i,in,x)
-char *(*xnew)();
-char *(*d2i)();
-FILE *in;
-unsigned char **x;
+char *ASN1_d2i_fp(char *(*xnew)(), char *(*d2i)(), FILE *in,
+	     unsigned char **x)
         {
         BIO *b;
         char *ret;
@@ -85,11 +82,8 @@ unsigned char **x;
         }
 #endif
 
-char *ASN1_d2i_bio(xnew,d2i,in,x)
-char *(*xnew)();
-char *(*d2i)();
-BIO *in;
-unsigned char **x;
+char *ASN1_d2i_bio(char *(*xnew)(), char *(*d2i)(), BIO *in,
+	     unsigned char **x)
 	{
 	BUF_MEM *b;
 	unsigned char *p;
diff --git a/crypto/asn1/a_digest.c b/crypto/asn1/a_digest.c
index 8ddb65b0dc..20cde71f03 100644
--- a/crypto/asn1/a_digest.c
+++ b/crypto/asn1/a_digest.c
@@ -66,12 +66,8 @@
 #include "x509.h"
 #include "buffer.h"
 
-int ASN1_digest(i2d,type,data,md,len)
-int (*i2d)();
-EVP_MD *type;
-char *data;
-unsigned char *md;
-unsigned int *len;
+int ASN1_digest(int (*i2d)(), EVP_MD *type, char *data, unsigned char *md,
+	     unsigned int *len)
 	{
 	EVP_MD_CTX ctx;
 	int i;
diff --git a/crypto/asn1/a_dup.c b/crypto/asn1/a_dup.c
index 961b4cb069..cf5748296c 100644
--- a/crypto/asn1/a_dup.c
+++ b/crypto/asn1/a_dup.c
@@ -62,10 +62,7 @@
 
 #define READ_CHUNK   2048
 
-char *ASN1_dup(i2d,d2i,x)
-int (*i2d)();
-char *(*d2i)();
-char *x;
+char *ASN1_dup(int (*i2d)(), char *(*d2i)(), char *x)
 	{
 	unsigned char *b,*p;
 	long i;
diff --git a/crypto/asn1/a_enum.c b/crypto/asn1/a_enum.c
index c369317473..0f8ad843c0 100644
--- a/crypto/asn1/a_enum.c
+++ b/crypto/asn1/a_enum.c
@@ -65,9 +65,7 @@
 /* ASN1err(ASN1_F_D2I_ASN1_ENUMERATED,ASN1_R_EXPECTING_AN_ENUMERATED);
  */
 
-int i2d_ASN1_ENUMERATED(a,pp)
-ASN1_ENUMERATED *a;
-unsigned char **pp;
+int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **pp)
 	{
 	int pad=0,ret,r,i,t;
 	unsigned char *p,*pt,*n,pb=0;
@@ -118,10 +116,8 @@ unsigned char **pp;
 	return(r);
 	}
 
-ASN1_ENUMERATED *d2i_ASN1_ENUMERATED(a, pp, length)
-ASN1_ENUMERATED **a;
-unsigned char **pp;
-long length;
+ASN1_ENUMERATED *d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, unsigned char **pp,
+	     long length)
 	{
 	ASN1_ENUMERATED *ret=NULL;
 	unsigned char *p,*to,*s;
@@ -196,9 +192,7 @@ err:
 	return(NULL);
 	}
 
-int ASN1_ENUMERATED_set(a,v)
-ASN1_ENUMERATED *a;
-long v;
+int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
 	{
 	int i,j,k;
 	unsigned char buf[sizeof(long)+1];
@@ -238,8 +232,7 @@ long v;
 	return(1);
 	}
 
-long ASN1_ENUMERATED_get(a)
-ASN1_ENUMERATED *a;
+long ASN1_ENUMERATED_get(ASN1_ENUMERATED *a)
 	{
 	int neg=0,i;
 	long r=0;
@@ -268,9 +261,7 @@ ASN1_ENUMERATED *a;
 	return(r);
 	}
 
-ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(bn,ai)
-BIGNUM *bn;
-ASN1_ENUMERATED *ai;
+ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(BIGNUM *bn, ASN1_ENUMERATED *ai)
 	{
 	ASN1_ENUMERATED *ret;
 	int len,j;
@@ -295,9 +286,7 @@ err:
 	return(NULL);
 	}
 
-BIGNUM *ASN1_ENUMERATED_to_BN(ai,bn)
-ASN1_ENUMERATED *ai;
-BIGNUM *bn;
+BIGNUM *ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED *ai, BIGNUM *bn)
 	{
 	BIGNUM *ret;
 
diff --git a/crypto/asn1/a_gentm.c b/crypto/asn1/a_gentm.c
index 3d37e9de71..7992739cad 100644
--- a/crypto/asn1/a_gentm.c
+++ b/crypto/asn1/a_gentm.c
@@ -67,19 +67,15 @@
  * ASN1err(ASN1_F_D2I_ASN1_GENERALIZEDTIME,ASN1_R_EXPECTING_A_GENERALIZEDTIME);
  */
 
-int i2d_ASN1_GENERALIZEDTIME(a,pp)
-ASN1_GENERALIZEDTIME *a;
-unsigned char **pp;
+int i2d_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME *a, unsigned char **pp)
 	{
 	return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
 		V_ASN1_GENERALIZEDTIME,V_ASN1_UNIVERSAL));
 	}
 
 
-ASN1_GENERALIZEDTIME *d2i_ASN1_GENERALIZEDTIME(a, pp, length)
-ASN1_GENERALIZEDTIME **a;
-unsigned char **pp;
-long length;
+ASN1_GENERALIZEDTIME *d2i_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME **a,
+	     unsigned char **pp, long length)
 	{
 	ASN1_GENERALIZEDTIME *ret=NULL;
 
@@ -103,8 +99,7 @@ err:
 	return(NULL);
 	}
 
-int ASN1_GENERALIZEDTIME_check(d)
-ASN1_GENERALIZEDTIME *d;
+int ASN1_GENERALIZEDTIME_check(ASN1_GENERALIZEDTIME *d)
 	{
 	static int min[9]={ 0, 0, 1, 1, 0, 0, 0, 0, 0};
 	static int max[9]={99, 99,12,31,23,59,59,12,59};
@@ -157,9 +152,7 @@ err:
 	return(0);
 	}
 
-int ASN1_GENERALIZEDTIME_set_string(s,str)
-ASN1_GENERALIZEDTIME *s;
-char *str;
+int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, char *str)
 	{
 	ASN1_GENERALIZEDTIME t;
 
@@ -179,9 +172,8 @@ char *str;
 		return(0);
 	}
 
-ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(s, t)
-ASN1_GENERALIZEDTIME *s;
-time_t t;
+ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
+	     time_t t)
 	{
 	char *p;
 	struct tm *ts;
diff --git a/crypto/asn1/a_hdr.c b/crypto/asn1/a_hdr.c
index e9de2838d0..d1bf08af4b 100644
--- a/crypto/asn1/a_hdr.c
+++ b/crypto/asn1/a_hdr.c
@@ -68,9 +68,7 @@
  * ASN1err(ASN1_F_ASN1_HEADER_NEW,ERR_R_BAD_GET_ASN1_OBJECT_CALL);
  */
 
-int i2d_ASN1_HEADER(a,pp)
-ASN1_HEADER *a;
-unsigned char **pp;
+int i2d_ASN1_HEADER(ASN1_HEADER *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -85,10 +83,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-ASN1_HEADER *d2i_ASN1_HEADER(a,pp,length)
-ASN1_HEADER **a;
-unsigned char **pp;
-long length;
+ASN1_HEADER *d2i_ASN1_HEADER(ASN1_HEADER **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,ASN1_HEADER *,ASN1_HEADER_new);
 
@@ -107,7 +103,7 @@ long length;
         M_ASN1_D2I_Finish(a,ASN1_HEADER_free,ASN1_F_D2I_ASN1_HEADER);
 	}
 
-ASN1_HEADER *ASN1_HEADER_new()
+ASN1_HEADER *ASN1_HEADER_new(void)
 	{
 	ASN1_HEADER *ret=NULL;
 	ASN1_CTX c;
@@ -120,8 +116,7 @@ ASN1_HEADER *ASN1_HEADER_new()
         M_ASN1_New_Error(ASN1_F_ASN1_HEADER_NEW);
 	}
 
-void ASN1_HEADER_free(a)
-ASN1_HEADER *a;
+void ASN1_HEADER_free(ASN1_HEADER *a)
 	{
 	if (a == NULL) return;
 	ASN1_OCTET_STRING_free(a->header);
diff --git a/crypto/asn1/a_i2d_fp.c b/crypto/asn1/a_i2d_fp.c
index 66c3df68d5..f010ec1272 100644
--- a/crypto/asn1/a_i2d_fp.c
+++ b/crypto/asn1/a_i2d_fp.c
@@ -62,10 +62,7 @@
 #include "asn1_mac.h"
 
 #ifndef NO_FP_API
-int ASN1_i2d_fp(i2d,out,x)
-int (*i2d)();
-FILE *out;
-unsigned char *x;
+int ASN1_i2d_fp(int (*i2d)(), FILE *out, unsigned char *x)
         {
         BIO *b;
         int ret;
@@ -82,10 +79,7 @@ unsigned char *x;
         }
 #endif
 
-int ASN1_i2d_bio(i2d,out,x)
-int (*i2d)();
-BIO *out;
-unsigned char *x;
+int ASN1_i2d_bio(int (*i2d)(), BIO *out, unsigned char *x)
 	{
 	char *b;
 	unsigned char *p;
diff --git a/crypto/asn1/a_int.c b/crypto/asn1/a_int.c
index e847efee85..acfc855261 100644
--- a/crypto/asn1/a_int.c
+++ b/crypto/asn1/a_int.c
@@ -63,9 +63,7 @@
 /* ASN1err(ASN1_F_D2I_ASN1_INTEGER,ASN1_R_EXPECTING_AN_INTEGER);
  */
 
-int i2d_ASN1_INTEGER(a,pp)
-ASN1_INTEGER *a;
-unsigned char **pp;
+int i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp)
 	{
 	int pad=0,ret,r,i,t;
 	unsigned char *p,*pt,*n,pb=0;
@@ -116,10 +114,8 @@ unsigned char **pp;
 	return(r);
 	}
 
-ASN1_INTEGER *d2i_ASN1_INTEGER(a, pp, length)
-ASN1_INTEGER **a;
-unsigned char **pp;
-long length;
+ASN1_INTEGER *d2i_ASN1_INTEGER(ASN1_INTEGER **a, unsigned char **pp,
+	     long length)
 	{
 	ASN1_INTEGER *ret=NULL;
 	unsigned char *p,*to,*s;
@@ -194,9 +190,7 @@ err:
 	return(NULL);
 	}
 
-int ASN1_INTEGER_set(a,v)
-ASN1_INTEGER *a;
-long v;
+int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
 	{
 	int i,j,k;
 	unsigned char buf[sizeof(long)+1];
@@ -236,8 +230,7 @@ long v;
 	return(1);
 	}
 
-long ASN1_INTEGER_get(a)
-ASN1_INTEGER *a;
+long ASN1_INTEGER_get(ASN1_INTEGER *a)
 	{
 	int neg=0,i;
 	long r=0;
@@ -266,9 +259,7 @@ ASN1_INTEGER *a;
 	return(r);
 	}
 
-ASN1_INTEGER *BN_to_ASN1_INTEGER(bn,ai)
-BIGNUM *bn;
-ASN1_INTEGER *ai;
+ASN1_INTEGER *BN_to_ASN1_INTEGER(BIGNUM *bn, ASN1_INTEGER *ai)
 	{
 	ASN1_INTEGER *ret;
 	int len,j;
@@ -293,9 +284,7 @@ err:
 	return(NULL);
 	}
 
-BIGNUM *ASN1_INTEGER_to_BN(ai,bn)
-ASN1_INTEGER *ai;
-BIGNUM *bn;
+BIGNUM *ASN1_INTEGER_to_BN(ASN1_INTEGER *ai, BIGNUM *bn)
 	{
 	BIGNUM *ret;
 
diff --git a/crypto/asn1/a_meth.c b/crypto/asn1/a_meth.c
index 513625c305..961085578e 100644
--- a/crypto/asn1/a_meth.c
+++ b/crypto/asn1/a_meth.c
@@ -73,12 +73,12 @@ static  ASN1_METHOD bit_string_meth={
 	(char *(*)())	ASN1_STRING_new,
 	(void (*)())	ASN1_STRING_free};
 
-ASN1_METHOD *ASN1_IA5STRING_asn1_meth()
+ASN1_METHOD *ASN1_IA5STRING_asn1_meth(void)
 	{
 	return(&ia5string_meth);
 	}
 
-ASN1_METHOD *ASN1_BIT_STRING_asn1_meth()
+ASN1_METHOD *ASN1_BIT_STRING_asn1_meth(void)
 	{
 	return(&bit_string_meth);
 	}
diff --git a/crypto/asn1/a_object.c b/crypto/asn1/a_object.c
index 9eff09509c..ef77bb0d2d 100644
--- a/crypto/asn1/a_object.c
+++ b/crypto/asn1/a_object.c
@@ -67,9 +67,7 @@
  * ASN1err(ASN1_F_I2T_ASN1_OBJECT,ASN1_R_BAD_OBJECT_HEADER);
  */
 
-int i2d_ASN1_OBJECT(a, pp)
-ASN1_OBJECT *a;
-unsigned char **pp;
+int i2d_ASN1_OBJECT(ASN1_OBJECT *a, unsigned char **pp)
 	{
 	unsigned char *p;
 
@@ -87,11 +85,7 @@ unsigned char **pp;
 	return(a->length);
 	}
 
-int a2d_ASN1_OBJECT(out,olen,buf,num)
-unsigned char *out;
-int olen;
-const char *buf;
-int num;
+int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
 	{
 	int i,first,len=0,c;
 	char tmp[24];
@@ -181,10 +175,7 @@ err:
 	return(0);
 	}
 
-int i2t_ASN1_OBJECT(buf,buf_len,a)
-char *buf;
-int buf_len;
-ASN1_OBJECT *a;
+int i2t_ASN1_OBJECT(char *buf, int buf_len, ASN1_OBJECT *a)
 	{
 	int i,idx=0,n=0,len,nid;
 	unsigned long l;
@@ -257,9 +248,7 @@ ASN1_OBJECT *a;
 	return(n);
 	}
 
-int i2a_ASN1_OBJECT(bp,a)
-BIO *bp;
-ASN1_OBJECT *a;
+int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
 	{
 	char buf[80];
 	int i;
@@ -272,10 +261,8 @@ ASN1_OBJECT *a;
 	return(i);
 	}
 
-ASN1_OBJECT *d2i_ASN1_OBJECT(a, pp, length)
-ASN1_OBJECT **a;
-unsigned char **pp;
-long length; 
+ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, unsigned char **pp,
+	     long length)
 	{
 	ASN1_OBJECT *ret=NULL;
 	unsigned char *p;
@@ -331,7 +318,7 @@ err:
 	return(NULL);
 	}
 
-ASN1_OBJECT *ASN1_OBJECT_new()
+ASN1_OBJECT *ASN1_OBJECT_new(void)
 	{
 	ASN1_OBJECT *ret;
 
@@ -350,8 +337,7 @@ ASN1_OBJECT *ASN1_OBJECT_new()
 	return(ret);
 	}
 
-void ASN1_OBJECT_free(a)
-ASN1_OBJECT *a;
+void ASN1_OBJECT_free(ASN1_OBJECT *a)
 	{
 	if (a == NULL) return;
 	if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS)
@@ -372,11 +358,8 @@ ASN1_OBJECT *a;
 		Free(a);
 	}
 
-ASN1_OBJECT *ASN1_OBJECT_create(nid,data,len,sn,ln)
-int nid;
-unsigned char *data;
-int len;
-char *sn,*ln;
+ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
+	     char *sn, char *ln)
 	{
 	ASN1_OBJECT o;
 
diff --git a/crypto/asn1/a_octet.c b/crypto/asn1/a_octet.c
index 5954c7bee0..2509175185 100644
--- a/crypto/asn1/a_octet.c
+++ b/crypto/asn1/a_octet.c
@@ -63,18 +63,14 @@
 /* ASN1err(ASN1_F_D2I_ASN1_OCTET_STRING,ASN1_R_EXPECTING_AN_OCTET_STRING);
  */
 
-int i2d_ASN1_OCTET_STRING(a, pp)
-ASN1_OCTET_STRING *a;
-unsigned char **pp;
+int i2d_ASN1_OCTET_STRING(ASN1_OCTET_STRING *a, unsigned char **pp)
 	{
 	return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
 		V_ASN1_OCTET_STRING,V_ASN1_UNIVERSAL));
 	}
 
-ASN1_OCTET_STRING *d2i_ASN1_OCTET_STRING(a, pp, length)
-ASN1_OCTET_STRING **a;
-unsigned char **pp;
-long length;
+ASN1_OCTET_STRING *d2i_ASN1_OCTET_STRING(ASN1_OCTET_STRING **a,
+	     unsigned char **pp, long length)
 	{
 	ASN1_OCTET_STRING *ret=NULL;
 
diff --git a/crypto/asn1/a_print.c b/crypto/asn1/a_print.c
index 9fa75616ae..babb571c5b 100644
--- a/crypto/asn1/a_print.c
+++ b/crypto/asn1/a_print.c
@@ -64,43 +64,30 @@
  * ASN1err(ASN1_F_D2I_ASN1_PRINT_TYPE,ASN1_R_TAG_VALUE_TOO_HIGH);
  */
 
-int i2d_ASN1_IA5STRING(a,pp)
-ASN1_IA5STRING *a;
-unsigned char **pp;
+int i2d_ASN1_IA5STRING(ASN1_IA5STRING *a, unsigned char **pp)
 	{ return(M_i2d_ASN1_IA5STRING(a,pp)); }
 
-ASN1_IA5STRING *d2i_ASN1_IA5STRING(a,pp,l)
-ASN1_IA5STRING **a;
-unsigned char **pp;
-long l;
+ASN1_IA5STRING *d2i_ASN1_IA5STRING(ASN1_IA5STRING **a, unsigned char **pp,
+	     long l)
 	{ return(M_d2i_ASN1_IA5STRING(a,pp,l)); }
 
-ASN1_T61STRING *d2i_ASN1_T61STRING(a,pp,l)
-ASN1_T61STRING **a;
-unsigned char **pp;
-long l;
+ASN1_T61STRING *d2i_ASN1_T61STRING(ASN1_T61STRING **a, unsigned char **pp,
+	     long l)
 	{ return(M_d2i_ASN1_T61STRING(a,pp,l)); }
 
-ASN1_PRINTABLESTRING *d2i_ASN1_PRINTABLESTRING(a,pp,l)
-ASN1_PRINTABLESTRING **a;
-unsigned char **pp;
-long l;
-	{ return(M_d2i_ASN1_PRINTABLESTRING(a,pp,l)); }
+ASN1_PRINTABLESTRING *d2i_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING **a,
+	     unsigned char **pp, long l)
+	{ return(M_d2i_ASN1_PRINTABLESTRING(a,pp,
+	     l)); }
 
-int i2d_ASN1_PRINTABLE(a,pp)
-ASN1_STRING *a;
-unsigned char **pp;
+int i2d_ASN1_PRINTABLE(ASN1_STRING *a, unsigned char **pp)
 	{ return(M_i2d_ASN1_PRINTABLE(a,pp)); }
 
-ASN1_STRING *d2i_ASN1_PRINTABLE(a,pp,l)
-ASN1_STRING **a;
-unsigned char **pp;
-long l;
+ASN1_STRING *d2i_ASN1_PRINTABLE(ASN1_STRING **a, unsigned char **pp,
+	     long l)
 	{ return(M_d2i_ASN1_PRINTABLE(a,pp,l)); }
 
-int ASN1_PRINTABLE_type(s,len)
-unsigned char *s;
-int len;
+int ASN1_PRINTABLE_type(unsigned char *s, int len)
 	{
 	int c;
 	int ia5=0;
@@ -131,8 +118,7 @@ int len;
 	return(V_ASN1_PRINTABLESTRING);
 	}
 
-int ASN1_UNIVERSALSTRING_to_string(s)
-ASN1_UNIVERSALSTRING *s;
+int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s)
 	{
 	int i;
 	unsigned char *p;
@@ -160,24 +146,16 @@ ASN1_UNIVERSALSTRING *s;
 	}
 
 
-int i2d_DIRECTORYSTRING(a,pp)
-ASN1_STRING *a;
-unsigned char **pp;
+int i2d_DIRECTORYSTRING(ASN1_STRING *a, unsigned char **pp)
 	{ return(M_i2d_DIRECTORYSTRING(a,pp)); }
 
-ASN1_STRING *d2i_DIRECTORYSTRING(a,pp,l)
-ASN1_STRING **a;
-unsigned char **pp;
-long l;
+ASN1_STRING *d2i_DIRECTORYSTRING(ASN1_STRING **a, unsigned char **pp,
+	     long l)
 	{ return(M_d2i_DIRECTORYSTRING(a,pp,l)); }
 
-int i2d_DISPLAYTEXT(a,pp)
-ASN1_STRING *a;
-unsigned char **pp;
+int i2d_DISPLAYTEXT(ASN1_STRING *a, unsigned char **pp)
 	{ return(M_i2d_DISPLAYTEXT(a,pp)); }
 
-ASN1_STRING *d2i_DISPLAYTEXT(a,pp,l)
-ASN1_STRING **a;
-unsigned char **pp;
-long l;
+ASN1_STRING *d2i_DISPLAYTEXT(ASN1_STRING **a, unsigned char **pp,
+	     long l)
 	{ return(M_d2i_DISPLAYTEXT(a,pp,l)); }
diff --git a/crypto/asn1/a_set.c b/crypto/asn1/a_set.c
index 34000ecf7d..406c68face 100644
--- a/crypto/asn1/a_set.c
+++ b/crypto/asn1/a_set.c
@@ -84,14 +84,9 @@ static int SetBlobCmp(const void *elem1, const void *elem2 )
     return b1->cbData-b2->cbData;
     }
 
-int i2d_ASN1_SET(a,pp,func,ex_tag,ex_class,is_set)
-STACK *a;
-unsigned char **pp;
-int (*func)();
-int ex_tag;
-int ex_class;
-int is_set;	/* if TRUE, then sort the contents (i.e. it isn't a SEQUENCE) */
-
+/* int is_set:  if TRUE, then sort the contents (i.e. it isn't a SEQUENCE)    */
+int i2d_ASN1_SET(STACK *a, unsigned char **pp, int (*func)(), int ex_tag,
+	     int ex_class, int is_set)
 	{
 	int ret=0,r;
 	int i;
@@ -158,14 +153,8 @@ SetBlob
         return(r);
         }
 
-STACK *d2i_ASN1_SET(a,pp,length,func,free_func,ex_tag,ex_class)
-STACK **a;
-unsigned char **pp;
-long length;
-char *(*func)();
-void (*free_func)();
-int ex_tag;
-int ex_class;
+STACK *d2i_ASN1_SET(STACK **a, unsigned char **pp, long length,
+	     char *(*func)(), void (*free_func)(), int ex_tag, int ex_class)
 	{
 	ASN1_CTX c;
 	STACK *ret=NULL;
diff --git a/crypto/asn1/a_sign.c b/crypto/asn1/a_sign.c
index d3ae78b7b4..7ce246c7cf 100644
--- a/crypto/asn1/a_sign.c
+++ b/crypto/asn1/a_sign.c
@@ -68,14 +68,9 @@
 #include "objects.h"
 #include "buffer.h"
 
-int ASN1_sign(i2d,algor1,algor2,signature,data,pkey,type)
-int (*i2d)();
-X509_ALGOR *algor1;
-X509_ALGOR *algor2;
-ASN1_BIT_STRING *signature;
-char *data;
-EVP_PKEY *pkey;
-const EVP_MD *type;
+int ASN1_sign(int (*i2d)(), X509_ALGOR *algor1, X509_ALGOR *algor2,
+	     ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey,
+	     const EVP_MD *type)
 	{
 	EVP_MD_CTX ctx;
 	unsigned char *p,*buf_in=NULL,*buf_out=NULL;
diff --git a/crypto/asn1/a_time.c b/crypto/asn1/a_time.c
index 953ed6088d..495f0814a3 100644
--- a/crypto/asn1/a_time.c
+++ b/crypto/asn1/a_time.c
@@ -66,9 +66,7 @@
 #include "cryptlib.h"
 #include "asn1.h"
 
-int i2d_ASN1_TIME(a,pp)
-ASN1_TIME *a;
-unsigned char **pp;
+int i2d_ASN1_TIME(ASN1_TIME *a, unsigned char **pp)
 	{
 	if(a->type == V_ASN1_UTCTIME || a->type == V_ASN1_GENERALIZEDTIME)
 				return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
@@ -78,10 +76,7 @@ unsigned char **pp;
 	}
 
 
-ASN1_TIME *d2i_ASN1_TIME(a, pp, length)
-ASN1_TIME **a;
-unsigned char **pp;
-long length;
+ASN1_TIME *d2i_ASN1_TIME(ASN1_TIME **a, unsigned char **pp, long length)
 	{
 	unsigned char tag;
 	tag = **pp & ~V_ASN1_CONSTRUCTED;
@@ -94,9 +89,7 @@ long length;
 	}
 
 
-ASN1_TIME *ASN1_TIME_set(s, t)
-ASN1_TIME *s;
-time_t t;
+ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t)
 	{
 	struct tm *ts;
 #if defined(THREADS) && !defined(WIN32)
diff --git a/crypto/asn1/a_type.c b/crypto/asn1/a_type.c
index 2f8a16174e..5ccd5de00e 100644
--- a/crypto/asn1/a_type.c
+++ b/crypto/asn1/a_type.c
@@ -70,9 +70,7 @@ static void ASN1_TYPE_component_free(ASN1_TYPE *a);
 static void ASN1_TYPE_component_free();
 #endif
 
-int i2d_ASN1_TYPE(a,pp)
-ASN1_TYPE *a;
-unsigned char **pp;
+int i2d_ASN1_TYPE(ASN1_TYPE *a, unsigned char **pp)
 	{
 	int r=0;
 
@@ -150,10 +148,7 @@ unsigned char **pp;
 	return(r);
 	}
 
-ASN1_TYPE *d2i_ASN1_TYPE(a,pp,length)
-ASN1_TYPE **a;
-unsigned char **pp;
-long length;
+ASN1_TYPE *d2i_ASN1_TYPE(ASN1_TYPE **a, unsigned char **pp, long length)
 	{
 	ASN1_TYPE *ret=NULL;
 	unsigned char *q,*p,*max;
@@ -280,7 +275,7 @@ err:
 	return(NULL);
 	}
 
-ASN1_TYPE *ASN1_TYPE_new()
+ASN1_TYPE *ASN1_TYPE_new(void)
 	{
 	ASN1_TYPE *ret=NULL;
 	ASN1_CTX c;
@@ -292,16 +287,14 @@ ASN1_TYPE *ASN1_TYPE_new()
 	M_ASN1_New_Error(ASN1_F_ASN1_TYPE_NEW);
 	}
 
-void ASN1_TYPE_free(a)
-ASN1_TYPE *a;
+void ASN1_TYPE_free(ASN1_TYPE *a)
 	{
 	if (a == NULL) return;
 	ASN1_TYPE_component_free(a);
 	Free((char *)(char *)a);
 	}
 
-int ASN1_TYPE_get(a)
-ASN1_TYPE *a;
+int ASN1_TYPE_get(ASN1_TYPE *a)
 	{
 	if (a->value.ptr != NULL)
 		return(a->type);
@@ -309,10 +302,7 @@ ASN1_TYPE *a;
 		return(0);
 	}
 
-void ASN1_TYPE_set(a,type,value)
-ASN1_TYPE *a;
-int type;
-char *value;
+void ASN1_TYPE_set(ASN1_TYPE *a, int type, char *value)
 	{
 	if (a->value.ptr != NULL)
 		ASN1_TYPE_component_free(a);
@@ -320,8 +310,7 @@ char *value;
 	a->value.ptr=value;
 	}
 
-static void ASN1_TYPE_component_free(a)
-ASN1_TYPE *a;
+static void ASN1_TYPE_component_free(ASN1_TYPE *a)
 	{
 	if (a == NULL) return;
 
diff --git a/crypto/asn1/a_utctm.c b/crypto/asn1/a_utctm.c
index ddd1a4016b..291c0fda69 100644
--- a/crypto/asn1/a_utctm.c
+++ b/crypto/asn1/a_utctm.c
@@ -65,19 +65,15 @@
  * ASN1err(ASN1_F_D2I_ASN1_UTCTIME,ASN1_R_EXPECTING_A_UTCTIME);
  */
 
-int i2d_ASN1_UTCTIME(a,pp)
-ASN1_UTCTIME *a;
-unsigned char **pp;
+int i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **pp)
 	{
 	return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
 		V_ASN1_UTCTIME,V_ASN1_UNIVERSAL));
 	}
 
 
-ASN1_UTCTIME *d2i_ASN1_UTCTIME(a, pp, length)
-ASN1_UTCTIME **a;
-unsigned char **pp;
-long length;
+ASN1_UTCTIME *d2i_ASN1_UTCTIME(ASN1_UTCTIME **a, unsigned char **pp,
+	     long length)
 	{
 	ASN1_UTCTIME *ret=NULL;
 
@@ -101,8 +97,7 @@ err:
 	return(NULL);
 	}
 
-int ASN1_UTCTIME_check(d)
-ASN1_UTCTIME *d;
+int ASN1_UTCTIME_check(ASN1_UTCTIME *d)
 	{
 	static int min[8]={ 0, 1, 1, 0, 0, 0, 0, 0};
 	static int max[8]={99,12,31,23,59,59,12,59};
@@ -152,9 +147,7 @@ err:
 	return(0);
 	}
 
-int ASN1_UTCTIME_set_string(s,str)
-ASN1_UTCTIME *s;
-char *str;
+int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, char *str)
 	{
 	ASN1_UTCTIME t;
 
@@ -174,9 +167,7 @@ char *str;
 		return(0);
 	}
 
-ASN1_UTCTIME *ASN1_UTCTIME_set(s, t)
-ASN1_UTCTIME *s;
-time_t t;
+ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t)
 	{
 	char *p;
 	struct tm *ts;
diff --git a/crypto/asn1/a_utf8.c b/crypto/asn1/a_utf8.c
index 2657abae41..2babbe712d 100644
--- a/crypto/asn1/a_utf8.c
+++ b/crypto/asn1/a_utf8.c
@@ -63,18 +63,14 @@
 /* ASN1err(ASN1_F_D2I_ASN1_UTF8STRING,ERR_R_MALLOC_FAILURE);
  */
 
-int i2d_ASN1_UTF8STRING(a, pp)
-ASN1_UTF8STRING *a;
-unsigned char **pp;
+int i2d_ASN1_UTF8STRING(ASN1_UTF8STRING *a, unsigned char **pp)
 	{
 	return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
 		V_ASN1_UTF8STRING,V_ASN1_UNIVERSAL));
 	}
 
-ASN1_UTF8STRING *d2i_ASN1_UTF8STRING(a, pp, length)
-ASN1_UTF8STRING **a;
-unsigned char **pp;
-long length;
+ASN1_UTF8STRING *d2i_ASN1_UTF8STRING(ASN1_UTF8STRING **a, unsigned char **pp,
+	     long length)
 	{
 	ASN1_UTF8STRING *ret=NULL;
 
diff --git a/crypto/asn1/a_verify.c b/crypto/asn1/a_verify.c
index dc5db9288b..fc2711058b 100644
--- a/crypto/asn1/a_verify.c
+++ b/crypto/asn1/a_verify.c
@@ -68,12 +68,8 @@
 #include "buffer.h"
 #include "evp.h"
 
-int ASN1_verify(i2d,a,signature,data,pkey)
-int (*i2d)();
-X509_ALGOR *a;
-ASN1_BIT_STRING *signature;
-char *data;
-EVP_PKEY *pkey;
+int ASN1_verify(int (*i2d)(), X509_ALGOR *a, ASN1_BIT_STRING *signature,
+	     char *data, EVP_PKEY *pkey)
 	{
 	EVP_MD_CTX ctx;
 	const EVP_MD *type;
diff --git a/crypto/asn1/a_vis.c b/crypto/asn1/a_vis.c
index 288be17049..2e5a709016 100644
--- a/crypto/asn1/a_vis.c
+++ b/crypto/asn1/a_vis.c
@@ -63,18 +63,14 @@
 /* ASN1err(ASN1_F_D2I_ASN1_VISIBLESTRING,ERR_R_MALLOC_FAILURE);
  */
 
-int i2d_ASN1_VISIBLESTRING(a, pp)
-ASN1_VISIBLESTRING *a;
-unsigned char **pp;
+int i2d_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING *a, unsigned char **pp)
 	{
 	return(i2d_ASN1_bytes((ASN1_STRING *)a,pp,
 		V_ASN1_VISIBLESTRING,V_ASN1_UNIVERSAL));
 	}
 
-ASN1_VISIBLESTRING *d2i_ASN1_VISIBLESTRING(a, pp, length)
-ASN1_VISIBLESTRING **a;
-unsigned char **pp;
-long length;
+ASN1_VISIBLESTRING *d2i_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING **a,
+	     unsigned char **pp, long length)
 	{
 	ASN1_VISIBLESTRING *ret=NULL;
 
diff --git a/crypto/asn1/asn1_err.c b/crypto/asn1/asn1_err.c
index c5a898f02d..7d8217036b 100644
--- a/crypto/asn1/asn1_err.c
+++ b/crypto/asn1/asn1_err.c
@@ -306,7 +306,7 @@ static ERR_STRING_DATA ASN1_str_reasons[]=
 
 #endif
 
-void ERR_load_ASN1_strings()
+void ERR_load_ASN1_strings(void)
 	{
 	static int init=1;
 
diff --git a/crypto/asn1/asn1_lib.c b/crypto/asn1/asn1_lib.c
index a18c7e7075..8c5d2d80ed 100644
--- a/crypto/asn1/asn1_lib.c
+++ b/crypto/asn1/asn1_lib.c
@@ -71,9 +71,7 @@ static void asn1_put_length();
 
 const char *ASN1_version="ASN.1" OPENSSL_VERSION_PTEXT;
 
-int ASN1_check_infinite_end(p,len)
-unsigned char **p;
-long len;
+int ASN1_check_infinite_end(unsigned char **p, long len)
 	{
 	/* If there is 0 or 1 byte left, the length check should pick
 	 * things up */
@@ -88,12 +86,8 @@ long len;
 	}
 
 
-int ASN1_get_object(pp, plength, ptag, pclass, omax)
-unsigned char **pp;
-long *plength;
-int *ptag;
-int *pclass;
-long omax;
+int ASN1_get_object(unsigned char **pp, long *plength, int *ptag, int *pclass,
+	     long omax)
 	{
 	int i,ret;
 	long l;
@@ -152,11 +146,7 @@ err:
 	return(0x80);
 	}
 
-static int asn1_get_length(pp,inf,rl,max)
-unsigned char **pp;
-int *inf;
-long *rl;
-int max;
+static int asn1_get_length(unsigned char **pp, int *inf, long *rl, int max)
 	{
 	unsigned char *p= *pp;
 	long ret=0;
@@ -193,12 +183,8 @@ int max;
 
 /* class 0 is constructed
  * constructed == 2 for indefinitle length constructed */
-void ASN1_put_object(pp,constructed,length,tag,xclass)
-unsigned char **pp;
-int constructed;
-int length;
-int tag;
-int xclass;
+void ASN1_put_object(unsigned char **pp, int constructed, int length, int tag,
+	     int xclass)
 	{
 	unsigned char *p= *pp;
 	int i;
@@ -224,9 +210,7 @@ int xclass;
 	*pp=p;
 	}
 
-static void asn1_put_length(pp, length)
-unsigned char **pp;
-int length;
+static void asn1_put_length(unsigned char **pp, int length)
 	{
 	unsigned char *p= *pp;
 	int i,l;
@@ -249,10 +233,7 @@ int length;
 	*pp=p;
 	}
 
-int ASN1_object_size(constructed, length, tag)
-int constructed;
-int length;
-int tag;
+int ASN1_object_size(int constructed, int length, int tag)
 	{
 	int ret;
 
@@ -280,8 +261,7 @@ int tag;
 	return(ret);
 	}
 
-int asn1_Finish(c)
-ASN1_CTX *c;
+int asn1_Finish(ASN1_CTX *c)
 	{
 	if ((c->inf == (1|V_ASN1_CONSTRUCTED)) && (!c->eos))
 		{
@@ -300,9 +280,7 @@ ASN1_CTX *c;
 	return(1);
 	}
 
-int asn1_GetSequence(c,length)
-ASN1_CTX *c;
-long *length;
+int asn1_GetSequence(ASN1_CTX *c, long *length)
 	{
 	unsigned char *q;
 
@@ -331,8 +309,7 @@ long *length;
 	return(1);
 	}
 
-ASN1_STRING *ASN1_STRING_dup(str)
-ASN1_STRING *str;
+ASN1_STRING *ASN1_STRING_dup(ASN1_STRING *str)
 	{
 	ASN1_STRING *ret;
 
@@ -347,10 +324,7 @@ ASN1_STRING *str;
 	return(ret);
 	}
 
-int ASN1_STRING_set(str,data,len)
-ASN1_STRING *str;
-unsigned char *data;
-int len;
+int ASN1_STRING_set(ASN1_STRING *str, unsigned char *data, int len)
 	{
 	char *c;
 
@@ -385,14 +359,13 @@ int len;
 	return(1);
 	}
 
-ASN1_STRING *ASN1_STRING_new()
+ASN1_STRING *ASN1_STRING_new(void)
 	{
 	return(ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
 	}
 
 
-ASN1_STRING *ASN1_STRING_type_new(type)
-int type;
+ASN1_STRING *ASN1_STRING_type_new(int type)
 	{
 	ASN1_STRING *ret;
 
@@ -409,16 +382,14 @@ int type;
 	return(ret);
 	}
 
-void ASN1_STRING_free(a)
-ASN1_STRING *a;
+void ASN1_STRING_free(ASN1_STRING *a)
 	{
 	if (a == NULL) return;
 	if (a->data != NULL) Free((char *)a->data);
 	Free((char *)a);
 	}
 
-int ASN1_STRING_cmp(a,b)
-ASN1_STRING *a,*b;
+int ASN1_STRING_cmp(ASN1_STRING *a, ASN1_STRING *b)
 	{
 	int i;
 
@@ -435,9 +406,7 @@ ASN1_STRING *a,*b;
 		return(i);
 	}
 
-void asn1_add_error(address,offset)
-unsigned char *address;
-int offset;
+void asn1_add_error(unsigned char *address, int offset)
 	{
 	char buf1[16],buf2[16];
 
diff --git a/crypto/asn1/asn1_par.c b/crypto/asn1/asn1_par.c
index d62be7dbe2..ab5521a7b3 100644
--- a/crypto/asn1/asn1_par.c
+++ b/crypto/asn1/asn1_par.c
@@ -72,12 +72,8 @@ static int asn1_print_info();
 static int asn1_parse2();
 #endif
 
-static int asn1_print_info(bp, tag, xclass, constructed,indent)
-BIO *bp;
-int tag;
-int xclass;
-int constructed;
-int indent;
+static int asn1_print_info(BIO *bp, int tag, int xclass, int constructed,
+	     int indent)
 	{
 	static const char fmt[]="%-18s";
 	static const char fmt2[]="%2d %-15s";
@@ -165,22 +161,13 @@ err:
 	return(0);
 	}
 
-int ASN1_parse(bp, pp, len, indent)
-BIO *bp;
-unsigned char *pp;
-long len;
-int indent;
+int ASN1_parse(BIO *bp, unsigned char *pp, long len, int indent)
 	{
 	return(asn1_parse2(bp,&pp,len,0,0,indent));
 	}
 
-static int asn1_parse2(bp, pp, length, offset, depth, indent)
-BIO *bp;
-unsigned char **pp;
-long length;
-int offset;
-int depth;
-int indent;
+static int asn1_parse2(BIO *bp, unsigned char **pp, long length, int offset,
+	     int depth, int indent)
 	{
 	unsigned char *p,*ep,*tot,*op,*opp;
 	long len;
diff --git a/crypto/asn1/asn_pack.c b/crypto/asn1/asn_pack.c
index 6e0dd95622..c094d64e1c 100644
--- a/crypto/asn1/asn_pack.c
+++ b/crypto/asn1/asn_pack.c
@@ -64,11 +64,8 @@
 
 /* Turn an ASN1 encoded SEQUENCE OF into a STACK of structures */
 
-STACK *ASN1_seq_unpack(buf, len, d2i, free_func)
-unsigned char *buf;
-int len;
-char *(*d2i)();
-void (*free_func)();
+STACK *ASN1_seq_unpack(unsigned char *buf, int len, char *(*d2i)(),
+	     void (*free_func)())
 {
     STACK *sk;
     unsigned char *pbuf;
@@ -83,11 +80,8 @@ void (*free_func)();
  * Malloc'ed buffer
  */
 
-unsigned char *ASN1_seq_pack(safes, i2d, buf, len)
-STACK *safes;
-int (*i2d)();
-unsigned char **buf;
-int *len;
+unsigned char *ASN1_seq_pack(STACK *safes, int (*i2d)(), unsigned char **buf,
+	     int *len)
 {
 	int safelen;
 	unsigned char *safe, *p;
@@ -110,9 +104,7 @@ int *len;
 
 /* Extract an ASN1 object from an ASN1_STRING */
 
-char *ASN1_unpack_string (oct, d2i)
-ASN1_STRING *oct;
-char *(*d2i)();
+char *ASN1_unpack_string (ASN1_STRING *oct, char *(*d2i)())
 {
 	unsigned char *p;
 	char *ret;
@@ -125,10 +117,7 @@ char *(*d2i)();
 
 /* Pack an ASN1 object into an ASN1_STRING */
 
-ASN1_STRING *ASN1_pack_string (obj, i2d, oct)
-char *obj;
-int (*i2d)();
-ASN1_STRING **oct;
+ASN1_STRING *ASN1_pack_string (char *obj, int (*i2d)(), ASN1_STRING **oct)
 {
 	unsigned char *p;
 	ASN1_STRING *octmp;
diff --git a/crypto/asn1/d2i_dhp.c b/crypto/asn1/d2i_dhp.c
index f2236fc2e2..4fea5af8e3 100644
--- a/crypto/asn1/d2i_dhp.c
+++ b/crypto/asn1/d2i_dhp.c
@@ -68,10 +68,7 @@
  * ASN1err(ASN1_F_I2D_DHPARAMS,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-DH *d2i_DHparams(a,pp,length)
-DH **a;
-unsigned char **pp;
-long length;
+DH *d2i_DHparams(DH **a, unsigned char **pp, long length)
 	{
 	int i=ERR_R_NESTED_ASN1_ERROR;
 	ASN1_INTEGER *bs=NULL;
diff --git a/crypto/asn1/d2i_dsap.c b/crypto/asn1/d2i_dsap.c
index fc2961b3a4..2f3b6b6a57 100644
--- a/crypto/asn1/d2i_dsap.c
+++ b/crypto/asn1/d2i_dsap.c
@@ -68,10 +68,7 @@
  * ASN1err(ASN1_F_I2D_DSAPARAMS,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-DSA *d2i_DSAparams(a,pp,length)
-DSA **a;
-unsigned char **pp;
-long length;
+DSA *d2i_DSAparams(DSA **a, unsigned char **pp, long length)
 	{
 	int i=ERR_R_NESTED_ASN1_ERROR;
 	ASN1_INTEGER *bs=NULL;
diff --git a/crypto/asn1/d2i_pr.c b/crypto/asn1/d2i_pr.c
index 677403564b..0fee334e77 100644
--- a/crypto/asn1/d2i_pr.c
+++ b/crypto/asn1/d2i_pr.c
@@ -63,11 +63,8 @@
 #include "objects.h"
 #include "x509.h"
 
-EVP_PKEY *d2i_PrivateKey(type,a,pp,length)
-int type;
-EVP_PKEY **a;
-unsigned char **pp;
-long length;
+EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, unsigned char **pp,
+	     long length)
 	{
 	EVP_PKEY *ret;
 
diff --git a/crypto/asn1/d2i_pu.c b/crypto/asn1/d2i_pu.c
index eb572acb0f..d89c6e287c 100644
--- a/crypto/asn1/d2i_pu.c
+++ b/crypto/asn1/d2i_pu.c
@@ -63,11 +63,8 @@
 #include "objects.h"
 #include "x509.h"
 
-EVP_PKEY *d2i_PublicKey(type,a,pp,length)
-int type;
-EVP_PKEY **a;
-unsigned char **pp;
-long length;
+EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, unsigned char **pp,
+	     long length)
 	{
 	EVP_PKEY *ret;
 
diff --git a/crypto/asn1/d2i_r_pr.c b/crypto/asn1/d2i_r_pr.c
index a276a1d4c5..3a4267bf97 100644
--- a/crypto/asn1/d2i_r_pr.c
+++ b/crypto/asn1/d2i_r_pr.c
@@ -75,15 +75,12 @@ static ASN1_METHOD method={
         (char *(*)())RSA_new,
         (void (*)()) RSA_free};
 
-ASN1_METHOD *RSAPrivateKey_asn1_meth()
+ASN1_METHOD *RSAPrivateKey_asn1_meth(void)
 	{
 	return(&method);
 	}
 
-RSA *d2i_RSAPrivateKey(a,pp,length)
-RSA **a;
-unsigned char **pp;
-long length;
+RSA *d2i_RSAPrivateKey(RSA **a, unsigned char **pp, long length)
 	{
 	int i=ASN1_R_PARSING;
 	ASN1_INTEGER *bs=NULL;
diff --git a/crypto/asn1/d2i_r_pu.c b/crypto/asn1/d2i_r_pu.c
index a4e2c22f36..5a98e55930 100644
--- a/crypto/asn1/d2i_r_pu.c
+++ b/crypto/asn1/d2i_r_pu.c
@@ -68,10 +68,7 @@
  * ASN1err(ASN1_F_I2D_RSAPUBLICKEY,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-RSA *d2i_RSAPublicKey(a,pp,length)
-RSA **a;
-unsigned char **pp;
-long length;
+RSA *d2i_RSAPublicKey(RSA **a, unsigned char **pp, long length)
 	{
 	int i=ASN1_R_PARSING;
 	ASN1_INTEGER *bs=NULL;
diff --git a/crypto/asn1/d2i_s_pr.c b/crypto/asn1/d2i_s_pr.c
index 8499702c9c..b318b1e3b5 100644
--- a/crypto/asn1/d2i_s_pr.c
+++ b/crypto/asn1/d2i_s_pr.c
@@ -71,10 +71,7 @@
  * ASN1err(ASN1_F_I2D_DSAPRIVATEKEY,ASN1_R_PARSING);
  */
 
-DSA *d2i_DSAPrivateKey(a,pp,length)
-DSA **a;
-unsigned char **pp;
-long length;
+DSA *d2i_DSAPrivateKey(DSA **a, unsigned char **pp, long length)
 	{
 	int i=ASN1_R_PARSING;
 	ASN1_INTEGER *bs=NULL;
diff --git a/crypto/asn1/d2i_s_pu.c b/crypto/asn1/d2i_s_pu.c
index ecf6407eab..c7b7ad0a43 100644
--- a/crypto/asn1/d2i_s_pu.c
+++ b/crypto/asn1/d2i_s_pu.c
@@ -70,10 +70,7 @@
  * ASN1err(ASN1_F_I2D_DSAPUBLICKEY,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-DSA *d2i_DSAPublicKey(a,pp,length)
-DSA **a;
-unsigned char **pp;
-long length;
+DSA *d2i_DSAPublicKey(DSA **a, unsigned char **pp, long length)
 	{
 	int i=ASN1_R_PARSING;
 	ASN1_INTEGER *bs=NULL;
diff --git a/crypto/asn1/evp_asn1.c b/crypto/asn1/evp_asn1.c
index 4153d1b57f..8197fcd8f7 100644
--- a/crypto/asn1/evp_asn1.c
+++ b/crypto/asn1/evp_asn1.c
@@ -61,10 +61,7 @@
 #include "asn1.h"
 #include "asn1_mac.h"
 
-int ASN1_TYPE_set_octetstring(a,data,len)
-ASN1_TYPE *a;
-unsigned char *data;
-int len;
+int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len)
 	{
 	ASN1_STRING *os;
 
@@ -74,10 +71,9 @@ int len;
 	return(1);
 	}
 
-int ASN1_TYPE_get_octetstring(a,data,max_len)
-ASN1_TYPE *a;
-unsigned char *data;
-int max_len; /* for returned value */
+/* int max_len:  for returned value    */
+int ASN1_TYPE_get_octetstring(ASN1_TYPE *a, unsigned char *data,
+	     int max_len)
 	{
 	int ret,num;
 	unsigned char *p;
@@ -97,11 +93,8 @@ int max_len; /* for returned value */
 	return(ret);
 	}
 
-int ASN1_TYPE_set_int_octetstring(a,num,data,len)
-ASN1_TYPE *a;
-long num;
-unsigned char *data;
-int len;
+int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, unsigned char *data,
+	     int len)
 	{
 	int n,size;
 	ASN1_OCTET_STRING os,*osp;
@@ -137,11 +130,9 @@ int len;
 
 /* we return the actual length..., num may be missing, in which
  * case, set it to zero */
-int ASN1_TYPE_get_int_octetstring(a,num,data,max_len)
-ASN1_TYPE *a;
-long *num;
-unsigned char *data;
-int max_len; /* for returned value */
+/* int max_len:  for returned value    */
+int ASN1_TYPE_get_int_octetstring(ASN1_TYPE *a, long *num, unsigned char *data,
+	     int max_len)
 	{
 	int ret= -1,n;
 	ASN1_INTEGER *ai=NULL;
diff --git a/crypto/asn1/f_enum.c b/crypto/asn1/f_enum.c
index 515f1dc42d..392e6b0184 100644
--- a/crypto/asn1/f_enum.c
+++ b/crypto/asn1/f_enum.c
@@ -63,9 +63,7 @@
 
 /* Based on a_int.c: equivalent ENUMERATED functions */
 
-int i2a_ASN1_ENUMERATED(bp, a)
-BIO *bp;
-ASN1_ENUMERATED *a;
+int i2a_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *a)
 	{
 	int i,n=0;
 	static const char *h="0123456789ABCDEF";
@@ -98,11 +96,7 @@ err:
 	return(-1);
 	}
 
-int a2i_ASN1_ENUMERATED(bp,bs,buf,size)
-BIO *bp;
-ASN1_ENUMERATED *bs;
-char *buf;
-int size;
+int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size)
 	{
 	int ret=0;
 	int i,j,k,m,n,again,bufsize;
diff --git a/crypto/asn1/f_int.c b/crypto/asn1/f_int.c
index a877e0cd52..85ec6cec66 100644
--- a/crypto/asn1/f_int.c
+++ b/crypto/asn1/f_int.c
@@ -61,9 +61,7 @@
 #include "buffer.h"
 #include "x509.h"
 
-int i2a_ASN1_INTEGER(bp, a)
-BIO *bp;
-ASN1_INTEGER *a;
+int i2a_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *a)
 	{
 	int i,n=0;
 	static const char *h="0123456789ABCDEF";
@@ -96,11 +94,7 @@ err:
 	return(-1);
 	}
 
-int a2i_ASN1_INTEGER(bp,bs,buf,size)
-BIO *bp;
-ASN1_INTEGER *bs;
-char *buf;
-int size;
+int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size)
 	{
 	int ret=0;
 	int i,j,k,m,n,again,bufsize;
diff --git a/crypto/asn1/f_string.c b/crypto/asn1/f_string.c
index e7ca97f9eb..ab7a7b1f6b 100644
--- a/crypto/asn1/f_string.c
+++ b/crypto/asn1/f_string.c
@@ -61,10 +61,7 @@
 #include "buffer.h"
 #include "x509.h"
 
-int i2a_ASN1_STRING(bp, a, type)
-BIO *bp;
-ASN1_STRING *a;
-int type;
+int i2a_ASN1_STRING(BIO *bp, ASN1_STRING *a, int type)
 	{
 	int i,n=0;
 	static const char *h="0123456789ABCDEF";
@@ -97,11 +94,7 @@ err:
 	return(-1);
 	}
 
-int a2i_ASN1_STRING(bp,bs,buf,size)
-BIO *bp;
-ASN1_STRING *bs;
-char *buf;
-int size;
+int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size)
 	{
 	int ret=0;
 	int i,j,k,m,n,again,bufsize;
diff --git a/crypto/asn1/i2d_dhp.c b/crypto/asn1/i2d_dhp.c
index a1afa46c86..690ba1ab8f 100644
--- a/crypto/asn1/i2d_dhp.c
+++ b/crypto/asn1/i2d_dhp.c
@@ -67,9 +67,7 @@
  * ASN1err(ASN1_F_X509_DHPARAMS_NEW,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_DHparams(a,pp)
-DH *a;
-unsigned char **pp;
+int i2d_DHparams(DH *a, unsigned char **pp)
 	{
 	BIGNUM *num[3];
 	ASN1_INTEGER bs;
diff --git a/crypto/asn1/i2d_dsap.c b/crypto/asn1/i2d_dsap.c
index 0b7d5543f3..402ed199dc 100644
--- a/crypto/asn1/i2d_dsap.c
+++ b/crypto/asn1/i2d_dsap.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_DSAPARAMS,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_DSAparams(a,pp)
-DSA *a;
-unsigned char **pp;
+int i2d_DSAparams(DSA *a, unsigned char **pp)
 	{
 	BIGNUM *num[3];
 	ASN1_INTEGER bs;
diff --git a/crypto/asn1/i2d_pr.c b/crypto/asn1/i2d_pr.c
index b6b821d73c..f173c9a5c1 100644
--- a/crypto/asn1/i2d_pr.c
+++ b/crypto/asn1/i2d_pr.c
@@ -62,9 +62,7 @@
 #include "evp.h"
 #include "objects.h"
 
-int i2d_PrivateKey(a,pp)
-EVP_PKEY *a;
-unsigned char **pp;
+int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp)
 	{
 #ifndef NO_RSA
 	if (a->type == EVP_PKEY_RSA)
diff --git a/crypto/asn1/i2d_pu.c b/crypto/asn1/i2d_pu.c
index 1b854252b7..8139175e18 100644
--- a/crypto/asn1/i2d_pu.c
+++ b/crypto/asn1/i2d_pu.c
@@ -62,9 +62,7 @@
 #include "evp.h"
 #include "objects.h"
 
-int i2d_PublicKey(a,pp)
-EVP_PKEY *a;
-unsigned char **pp;
+int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp)
 	{
 	switch (a->type)
 		{
diff --git a/crypto/asn1/i2d_r_pr.c b/crypto/asn1/i2d_r_pr.c
index 78312dbf2f..cfd1fc74f5 100644
--- a/crypto/asn1/i2d_r_pr.c
+++ b/crypto/asn1/i2d_r_pr.c
@@ -68,9 +68,7 @@
  * ASN1err(ASN1_F_I2D_RSAPRIVATEKEY,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-int i2d_RSAPrivateKey(a,pp)
-RSA *a;
-unsigned char **pp;
+int i2d_RSAPrivateKey(RSA *a, unsigned char **pp)
 	{
 	BIGNUM *num[9];
 	unsigned char data[1];
diff --git a/crypto/asn1/i2d_r_pu.c b/crypto/asn1/i2d_r_pu.c
index 4bcebaa1ba..4f0a022317 100644
--- a/crypto/asn1/i2d_r_pu.c
+++ b/crypto/asn1/i2d_r_pu.c
@@ -68,9 +68,7 @@
  * ASN1err(ASN1_F_I2D_RSAPUBLICKEY,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-int i2d_RSAPublicKey(a,pp)
-RSA *a;
-unsigned char **pp;
+int i2d_RSAPublicKey(RSA *a, unsigned char **pp)
 	{
 	BIGNUM *num[2];
 	ASN1_INTEGER bs;
diff --git a/crypto/asn1/i2d_s_pr.c b/crypto/asn1/i2d_s_pr.c
index 6e95305548..7374f7e9b5 100644
--- a/crypto/asn1/i2d_s_pr.c
+++ b/crypto/asn1/i2d_s_pr.c
@@ -67,9 +67,7 @@
  * ASN1err(ASN1_F_I2D_DSAPRIVATEKEY,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-int i2d_DSAPrivateKey(a,pp)
-DSA *a;
-unsigned char **pp;
+int i2d_DSAPrivateKey(DSA *a, unsigned char **pp)
 	{
 	BIGNUM *num[6];
 	unsigned char data[1];
diff --git a/crypto/asn1/i2d_s_pu.c b/crypto/asn1/i2d_s_pu.c
index 5cf2877069..bfa40f3e62 100644
--- a/crypto/asn1/i2d_s_pu.c
+++ b/crypto/asn1/i2d_s_pu.c
@@ -67,9 +67,7 @@
  * ASN1err(ASN1_F_I2D_DSAPUBLICKEY,ASN1_R_UNKNOWN_ATTRIBUTE_TYPE);
  */
 
-int i2d_DSAPublicKey(a,pp)
-DSA *a;
-unsigned char **pp;
+int i2d_DSAPublicKey(DSA *a, unsigned char **pp)
 	{
 	BIGNUM *num[4];
 	ASN1_INTEGER bs;
diff --git a/crypto/asn1/n_pkey.c b/crypto/asn1/n_pkey.c
index d9bf417738..edab9feeab 100644
--- a/crypto/asn1/n_pkey.c
+++ b/crypto/asn1/n_pkey.c
@@ -92,10 +92,7 @@ static NETSCAPE_PKEY *NETSCAPE_PKEY_new();
 static void NETSCAPE_PKEY_free();
 #endif
 
-int i2d_Netscape_RSA(a,pp,cb)
-RSA *a;
-unsigned char **pp;
-int (*cb)();
+int i2d_Netscape_RSA(RSA *a, unsigned char **pp, int (*cb)())
 	{
 	int i,j,l[6];
 	NETSCAPE_PKEY *pkey;
@@ -204,11 +201,7 @@ err:
 	return(ret);
 	}
 
-RSA *d2i_Netscape_RSA(a,pp,length,cb)
-RSA **a;
-unsigned char **pp;
-long length;
-int (*cb)();
+RSA *d2i_Netscape_RSA(RSA **a, unsigned char **pp, long length, int (*cb)())
 	{
 	RSA *ret=NULL;
 	ASN1_OCTET_STRING *os=NULL;
@@ -235,11 +228,8 @@ int (*cb)();
 	M_ASN1_D2I_Finish(a,RSA_free,ASN1_F_D2I_NETSCAPE_RSA);
 	}
 
-RSA *d2i_Netscape_RSA_2(a,pp,length,cb)
-RSA **a;
-unsigned char **pp;
-long length;
-int (*cb)();
+RSA *d2i_Netscape_RSA_2(RSA **a, unsigned char **pp, long length,
+	     int (*cb)())
 	{
 	NETSCAPE_PKEY *pkey=NULL;
 	RSA *ret=NULL;
@@ -306,9 +296,7 @@ err:
 	return(ret);
 	}
 
-static int i2d_NETSCAPE_PKEY(a,pp)
-NETSCAPE_PKEY *a;
-unsigned char **pp;
+static int i2d_NETSCAPE_PKEY(NETSCAPE_PKEY *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -326,10 +314,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-static NETSCAPE_PKEY *d2i_NETSCAPE_PKEY(a,pp,length)
-NETSCAPE_PKEY **a;
-unsigned char **pp;
-long length;
+static NETSCAPE_PKEY *d2i_NETSCAPE_PKEY(NETSCAPE_PKEY **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,NETSCAPE_PKEY *,NETSCAPE_PKEY_new);
 
@@ -341,7 +327,7 @@ long length;
 	M_ASN1_D2I_Finish(a,NETSCAPE_PKEY_free,ASN1_F_D2I_NETSCAPE_PKEY);
 	}
 
-static NETSCAPE_PKEY *NETSCAPE_PKEY_new()
+static NETSCAPE_PKEY *NETSCAPE_PKEY_new(void)
 	{
 	NETSCAPE_PKEY *ret=NULL;
 	ASN1_CTX c;
@@ -354,8 +340,7 @@ static NETSCAPE_PKEY *NETSCAPE_PKEY_new()
 	M_ASN1_New_Error(ASN1_F_NETSCAPE_PKEY_NEW);
 	}
 
-static void NETSCAPE_PKEY_free(a)
-NETSCAPE_PKEY *a;
+static void NETSCAPE_PKEY_free(NETSCAPE_PKEY *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/nsseq.c b/crypto/asn1/nsseq.c
index 5f95cfd69f..ba43be59b2 100644
--- a/crypto/asn1/nsseq.c
+++ b/crypto/asn1/nsseq.c
@@ -70,9 +70,7 @@
  * ASN1err(ASN1_F_D2I_NETSCAPE_CERT_SEQUENCE,ERR_R_MALLOC_FAILURE);
  */
 
-int i2d_NETSCAPE_CERT_SEQUENCE(a,pp)
-NETSCAPE_CERT_SEQUENCE *a;
-unsigned char **pp;
+int i2d_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE *a, unsigned char **pp)
 {
 	int v = 0;
 	M_ASN1_I2D_vars(a);
@@ -89,7 +87,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 }
 
-NETSCAPE_CERT_SEQUENCE *NETSCAPE_CERT_SEQUENCE_new()
+NETSCAPE_CERT_SEQUENCE *NETSCAPE_CERT_SEQUENCE_new(void)
 {
 	NETSCAPE_CERT_SEQUENCE *ret=NULL;
 	ASN1_CTX c;
@@ -101,10 +99,8 @@ NETSCAPE_CERT_SEQUENCE *NETSCAPE_CERT_SEQUENCE_new()
 	M_ASN1_New_Error(ASN1_F_NETSCAPE_CERT_SEQUENCE_NEW);
 }
 
-NETSCAPE_CERT_SEQUENCE *d2i_NETSCAPE_CERT_SEQUENCE(a,pp,length)
-NETSCAPE_CERT_SEQUENCE **a;
-unsigned char **pp;
-long length;
+NETSCAPE_CERT_SEQUENCE *d2i_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE **a,
+	     unsigned char **pp, long length)
 {
 	M_ASN1_D2I_vars(a,NETSCAPE_CERT_SEQUENCE *,
 					NETSCAPE_CERT_SEQUENCE_new);
@@ -116,8 +112,7 @@ long length;
 	M_ASN1_D2I_Finish(a, NETSCAPE_CERT_SEQUENCE_free, ASN1_F_D2I_NETSCAPE_CERT_SEQUENCE);
 }
 
-void NETSCAPE_CERT_SEQUENCE_free (a)
-NETSCAPE_CERT_SEQUENCE *a;
+void NETSCAPE_CERT_SEQUENCE_free (NETSCAPE_CERT_SEQUENCE *a)
 {
 	if (a == NULL) return;
 	ASN1_OBJECT_free(a->type);
diff --git a/crypto/asn1/p5_pbe.c b/crypto/asn1/p5_pbe.c
index 5396a5a47b..b0de0d843b 100644
--- a/crypto/asn1/p5_pbe.c
+++ b/crypto/asn1/p5_pbe.c
@@ -70,9 +70,7 @@
  *ASN1err(ASN1_F_D2I_PBEPARAM,ASN1_R_DECODE_ERROR)
  */
 
-int i2d_PBEPARAM(a, pp)
-PBEPARAM *a;
-unsigned char **pp;
+int i2d_PBEPARAM(PBEPARAM *a, unsigned char **pp)
 {
 	M_ASN1_I2D_vars(a);
 	M_ASN1_I2D_len (a->salt, i2d_ASN1_OCTET_STRING);
@@ -85,7 +83,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 }
 
-PBEPARAM *PBEPARAM_new()
+PBEPARAM *PBEPARAM_new(void)
 {
 	PBEPARAM *ret=NULL;
 	ASN1_CTX c;
@@ -96,10 +94,7 @@ PBEPARAM *PBEPARAM_new()
 	M_ASN1_New_Error(ASN1_F_PBEPARAM_NEW);
 }
 
-PBEPARAM *d2i_PBEPARAM(a,pp,length)
-PBEPARAM **a;
-unsigned char **pp;
-long length;
+PBEPARAM *d2i_PBEPARAM(PBEPARAM **a, unsigned char **pp, long length)
 {
 	M_ASN1_D2I_vars(a,PBEPARAM *,PBEPARAM_new);
 	M_ASN1_D2I_Init();
@@ -109,8 +104,7 @@ long length;
 	M_ASN1_D2I_Finish(a, PBEPARAM_free, ASN1_F_D2I_PBEPARAM);
 }
 
-void PBEPARAM_free (a)
-PBEPARAM *a;
+void PBEPARAM_free (PBEPARAM *a)
 {
 	if(a==NULL) return;
 	ASN1_OCTET_STRING_free(a->salt);
@@ -120,11 +114,8 @@ PBEPARAM *a;
 
 /* Return an algorithm identifier for a PKCS#5 PBE algorithm */
 
-X509_ALGOR *PKCS5_pbe_set(alg, iter, salt, saltlen)
-int alg;
-int iter;
-unsigned char *salt;
-int saltlen;
+X509_ALGOR *PKCS5_pbe_set(int alg, int iter, unsigned char *salt,
+	     int saltlen)
 {
 	unsigned char *pdata, *ptmp;
 	int plen;
diff --git a/crypto/asn1/p5_pbev2.c b/crypto/asn1/p5_pbev2.c
index b81703e5cb..2e496022de 100644
--- a/crypto/asn1/p5_pbev2.c
+++ b/crypto/asn1/p5_pbev2.c
@@ -70,9 +70,7 @@
  *ASN1err(ASN1_F_D2I_PBKDF2PARAM,ASN1_R_DECODE_ERROR)
  */
 
-int i2d_PBE2PARAM(a, pp)
-PBE2PARAM *a;
-unsigned char **pp;
+int i2d_PBE2PARAM(PBE2PARAM *a, unsigned char **pp)
 {
 	M_ASN1_I2D_vars(a);
 	M_ASN1_I2D_len (a->keyfunc, i2d_X509_ALGOR);
@@ -86,7 +84,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 }
 
-PBE2PARAM *PBE2PARAM_new()
+PBE2PARAM *PBE2PARAM_new(void)
 {
 	PBE2PARAM *ret=NULL;
 	ASN1_CTX c;
@@ -97,10 +95,7 @@ PBE2PARAM *PBE2PARAM_new()
 	M_ASN1_New_Error(ASN1_F_PBE2PARAM_NEW);
 }
 
-PBE2PARAM *d2i_PBE2PARAM(a,pp,length)
-PBE2PARAM **a;
-unsigned char **pp;
-long length;
+PBE2PARAM *d2i_PBE2PARAM(PBE2PARAM **a, unsigned char **pp, long length)
 {
 	M_ASN1_D2I_vars(a,PBE2PARAM *,PBE2PARAM_new);
 	M_ASN1_D2I_Init();
@@ -110,8 +105,7 @@ long length;
 	M_ASN1_D2I_Finish(a, PBE2PARAM_free, ASN1_F_D2I_PBE2PARAM);
 }
 
-void PBE2PARAM_free (a)
-PBE2PARAM *a;
+void PBE2PARAM_free (PBE2PARAM *a)
 {
 	if(a==NULL) return;
 	X509_ALGOR_free(a->keyfunc);
@@ -119,9 +113,7 @@ PBE2PARAM *a;
 	Free ((char *)a);
 }
 
-int i2d_PBKDF2PARAM(a, pp)
-PBKDF2PARAM *a;
-unsigned char **pp;
+int i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **pp)
 {
 	M_ASN1_I2D_vars(a);
 	M_ASN1_I2D_len (a->salt, i2d_ASN1_OCTET_STRING);
@@ -139,7 +131,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 }
 
-PBKDF2PARAM *PBKDF2PARAM_new()
+PBKDF2PARAM *PBKDF2PARAM_new(void)
 {
 	PBKDF2PARAM *ret=NULL;
 	ASN1_CTX c;
@@ -152,10 +144,8 @@ PBKDF2PARAM *PBKDF2PARAM_new()
 	M_ASN1_New_Error(ASN1_F_PBKDF2PARAM_NEW);
 }
 
-PBKDF2PARAM *d2i_PBKDF2PARAM(a,pp,length)
-PBKDF2PARAM **a;
-unsigned char **pp;
-long length;
+PBKDF2PARAM *d2i_PBKDF2PARAM(PBKDF2PARAM **a, unsigned char **pp,
+	     long length)
 {
 	M_ASN1_D2I_vars(a,PBKDF2PARAM *,PBKDF2PARAM_new);
 	M_ASN1_D2I_Init();
@@ -167,8 +157,7 @@ long length;
 	M_ASN1_D2I_Finish(a, PBKDF2PARAM_free, ASN1_F_D2I_PBKDF2PARAM);
 }
 
-void PBKDF2PARAM_free (a)
-PBKDF2PARAM *a;
+void PBKDF2PARAM_free (PBKDF2PARAM *a)
 {
 	if(a==NULL) return;
 	ASN1_OCTET_STRING_free(a->salt);
diff --git a/crypto/asn1/p7_dgst.c b/crypto/asn1/p7_dgst.c
index bf7b8e2f43..516746b104 100644
--- a/crypto/asn1/p7_dgst.c
+++ b/crypto/asn1/p7_dgst.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_DIGEST,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_DIGEST(a,pp)
-PKCS7_DIGEST *a;
-unsigned char **pp;
+int i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -87,10 +85,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_DIGEST *d2i_PKCS7_DIGEST(a,pp,length)
-PKCS7_DIGEST **a;
-unsigned char **pp;
-long length;
+PKCS7_DIGEST *d2i_PKCS7_DIGEST(PKCS7_DIGEST **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_DIGEST *,PKCS7_DIGEST_new);
 
@@ -104,7 +100,7 @@ long length;
 	M_ASN1_D2I_Finish(a,PKCS7_DIGEST_free,ASN1_F_D2I_PKCS7_DIGEST);
 	}
 
-PKCS7_DIGEST *PKCS7_DIGEST_new()
+PKCS7_DIGEST *PKCS7_DIGEST_new(void)
 	{
 	PKCS7_DIGEST *ret=NULL;
 	ASN1_CTX c;
@@ -118,8 +114,7 @@ PKCS7_DIGEST *PKCS7_DIGEST_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_DIGEST_NEW);
 	}
 
-void PKCS7_DIGEST_free(a)
-PKCS7_DIGEST *a;
+void PKCS7_DIGEST_free(PKCS7_DIGEST *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/p7_enc.c b/crypto/asn1/p7_enc.c
index 56e27fa112..f5ebbf776d 100644
--- a/crypto/asn1/p7_enc.c
+++ b/crypto/asn1/p7_enc.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_ENCRYPT,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_ENCRYPT(a,pp)
-PKCS7_ENCRYPT *a;
-unsigned char **pp;
+int i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -83,10 +81,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_ENCRYPT *d2i_PKCS7_ENCRYPT(a,pp,length)
-PKCS7_ENCRYPT **a;
-unsigned char **pp;
-long length;
+PKCS7_ENCRYPT *d2i_PKCS7_ENCRYPT(PKCS7_ENCRYPT **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_ENCRYPT *,PKCS7_ENCRYPT_new);
 
@@ -98,7 +94,7 @@ long length;
 	M_ASN1_D2I_Finish(a,PKCS7_ENCRYPT_free,ASN1_F_D2I_PKCS7_ENCRYPT);
 	}
 
-PKCS7_ENCRYPT *PKCS7_ENCRYPT_new()
+PKCS7_ENCRYPT *PKCS7_ENCRYPT_new(void)
 	{
 	PKCS7_ENCRYPT *ret=NULL;
 	ASN1_CTX c;
@@ -110,8 +106,7 @@ PKCS7_ENCRYPT *PKCS7_ENCRYPT_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_ENCRYPT_NEW);
 	}
 
-void PKCS7_ENCRYPT_free(a)
-PKCS7_ENCRYPT *a;
+void PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/p7_enc_c.c b/crypto/asn1/p7_enc_c.c
index f98afb51b8..8914d87402 100644
--- a/crypto/asn1/p7_enc_c.c
+++ b/crypto/asn1/p7_enc_c.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_ENC_CONTENT,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_ENC_CONTENT(a,pp)
-PKCS7_ENC_CONTENT *a;
-unsigned char **pp;
+int i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -85,10 +83,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_ENC_CONTENT *d2i_PKCS7_ENC_CONTENT(a,pp,length)
-PKCS7_ENC_CONTENT **a;
-unsigned char **pp;
-long length;
+PKCS7_ENC_CONTENT *d2i_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT **a,
+	     unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_ENC_CONTENT *,PKCS7_ENC_CONTENT_new);
 
@@ -103,7 +99,7 @@ long length;
 		ASN1_F_D2I_PKCS7_ENC_CONTENT);
 	}
 
-PKCS7_ENC_CONTENT *PKCS7_ENC_CONTENT_new()
+PKCS7_ENC_CONTENT *PKCS7_ENC_CONTENT_new(void)
 	{
 	PKCS7_ENC_CONTENT *ret=NULL;
 	ASN1_CTX c;
@@ -117,8 +113,7 @@ PKCS7_ENC_CONTENT *PKCS7_ENC_CONTENT_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_ENC_CONTENT_NEW);
 	}
 
-void PKCS7_ENC_CONTENT_free(a)
-PKCS7_ENC_CONTENT *a;
+void PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a)
 	{
 	if (a == NULL) return;
 	ASN1_OBJECT_free(a->content_type);
diff --git a/crypto/asn1/p7_evp.c b/crypto/asn1/p7_evp.c
index 7879a66848..babb9b2752 100644
--- a/crypto/asn1/p7_evp.c
+++ b/crypto/asn1/p7_evp.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_ENVELOPE,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_ENVELOPE(a,pp)
-PKCS7_ENVELOPE *a;
-unsigned char **pp;
+int i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -85,10 +83,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_ENVELOPE *d2i_PKCS7_ENVELOPE(a,pp,length)
-PKCS7_ENVELOPE **a;
-unsigned char **pp;
-long length;
+PKCS7_ENVELOPE *d2i_PKCS7_ENVELOPE(PKCS7_ENVELOPE **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_ENVELOPE *,PKCS7_ENVELOPE_new);
 
@@ -102,7 +98,7 @@ long length;
 	M_ASN1_D2I_Finish(a,PKCS7_ENVELOPE_free,ASN1_F_D2I_PKCS7_ENVELOPE);
 	}
 
-PKCS7_ENVELOPE *PKCS7_ENVELOPE_new()
+PKCS7_ENVELOPE *PKCS7_ENVELOPE_new(void)
 	{
 	PKCS7_ENVELOPE *ret=NULL;
 	ASN1_CTX c;
@@ -115,8 +111,7 @@ PKCS7_ENVELOPE *PKCS7_ENVELOPE_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_ENVELOPE_NEW);
 	}
 
-void PKCS7_ENVELOPE_free(a)
-PKCS7_ENVELOPE *a;
+void PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/p7_i_s.c b/crypto/asn1/p7_i_s.c
index 9bae647feb..11ebfcadc9 100644
--- a/crypto/asn1/p7_i_s.c
+++ b/crypto/asn1/p7_i_s.c
@@ -66,9 +66,8 @@
  * ASN1err(ASN1_F_D2I_PKCS7_ISSUER_AND_SERIAL,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_ISSUER_AND_SERIAL(a,pp)
-PKCS7_ISSUER_AND_SERIAL *a;
-unsigned char **pp;
+int i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a,
+	     unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -83,10 +82,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_ISSUER_AND_SERIAL *d2i_PKCS7_ISSUER_AND_SERIAL(a,pp,length)
-PKCS7_ISSUER_AND_SERIAL **a;
-unsigned char **pp;
-long length;
+PKCS7_ISSUER_AND_SERIAL *d2i_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_ISSUER_AND_SERIAL *,PKCS7_ISSUER_AND_SERIAL_new);
 
@@ -98,7 +94,7 @@ long length;
 		ASN1_F_D2I_PKCS7_ISSUER_AND_SERIAL);
 	}
 
-PKCS7_ISSUER_AND_SERIAL *PKCS7_ISSUER_AND_SERIAL_new()
+PKCS7_ISSUER_AND_SERIAL *PKCS7_ISSUER_AND_SERIAL_new(void)
 	{
 	PKCS7_ISSUER_AND_SERIAL *ret=NULL;
 	ASN1_CTX c;
@@ -110,8 +106,7 @@ PKCS7_ISSUER_AND_SERIAL *PKCS7_ISSUER_AND_SERIAL_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_ISSUER_AND_SERIAL_NEW);
 	}
 
-void PKCS7_ISSUER_AND_SERIAL_free(a)
-PKCS7_ISSUER_AND_SERIAL *a;
+void PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a)
 	{
 	if (a == NULL) return;
 	X509_NAME_free(a->issuer);
diff --git a/crypto/asn1/p7_lib.c b/crypto/asn1/p7_lib.c
index 4ab64777b3..560f63ddba 100644
--- a/crypto/asn1/p7_lib.c
+++ b/crypto/asn1/p7_lib.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_PKCS7_NEW,ASN1_R_BAD_PKCS7_TYPE);
  */
 
-int i2d_PKCS7(a,pp)
-PKCS7 *a;
-unsigned char **pp;
+int i2d_PKCS7(PKCS7 *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -150,10 +148,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7 *d2i_PKCS7(a,pp,length)
-PKCS7 **a;
-unsigned char **pp;
-long length;
+PKCS7 *d2i_PKCS7(PKCS7 **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7 *,PKCS7_new);
 
@@ -236,7 +231,7 @@ long length;
 	M_ASN1_D2I_Finish(a,PKCS7_free,ASN1_F_D2I_PKCS7);
 	}
 
-PKCS7 *PKCS7_new()
+PKCS7 *PKCS7_new(void)
 	{
 	PKCS7 *ret=NULL;
 	ASN1_CTX c;
@@ -251,8 +246,7 @@ PKCS7 *PKCS7_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_NEW);
 	}
 
-void PKCS7_free(a)
-PKCS7 *a;
+void PKCS7_free(PKCS7 *a)
 	{
 	if (a == NULL) return;
 
@@ -264,8 +258,7 @@ PKCS7 *a;
 	Free((char *)(char *)a);
 	}
 
-void PKCS7_content_free(a)
-PKCS7 *a;
+void PKCS7_content_free(PKCS7 *a)
 	{
 	if(a == NULL)
 	    return;
diff --git a/crypto/asn1/p7_recip.c b/crypto/asn1/p7_recip.c
index 2516d7b193..f6d121731a 100644
--- a/crypto/asn1/p7_recip.c
+++ b/crypto/asn1/p7_recip.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_RECIP_INFO,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_RECIP_INFO(a,pp)
-PKCS7_RECIP_INFO *a;
-unsigned char **pp;
+int i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -87,10 +85,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_RECIP_INFO *d2i_PKCS7_RECIP_INFO(a,pp,length)
-PKCS7_RECIP_INFO **a;
-unsigned char **pp;
-long length;
+PKCS7_RECIP_INFO *d2i_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO **a,
+	     unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_RECIP_INFO *,PKCS7_RECIP_INFO_new);
 
@@ -104,7 +100,7 @@ long length;
 	M_ASN1_D2I_Finish(a,PKCS7_RECIP_INFO_free,ASN1_F_D2I_PKCS7_RECIP_INFO);
 	}
 
-PKCS7_RECIP_INFO *PKCS7_RECIP_INFO_new()
+PKCS7_RECIP_INFO *PKCS7_RECIP_INFO_new(void)
 	{
 	PKCS7_RECIP_INFO *ret=NULL;
 	ASN1_CTX c;
@@ -119,8 +115,7 @@ PKCS7_RECIP_INFO *PKCS7_RECIP_INFO_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_RECIP_INFO_NEW);
 	}
 
-void PKCS7_RECIP_INFO_free(a)
-PKCS7_RECIP_INFO *a;
+void PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/p7_s_e.c b/crypto/asn1/p7_s_e.c
index 8271c8f8e3..c4d0eef4d7 100644
--- a/crypto/asn1/p7_s_e.c
+++ b/crypto/asn1/p7_s_e.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_SIGN_ENVELOPE,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_SIGN_ENVELOPE(a,pp)
-PKCS7_SIGN_ENVELOPE *a;
-unsigned char **pp;
+int i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -93,10 +91,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_SIGN_ENVELOPE *d2i_PKCS7_SIGN_ENVELOPE(a,pp,length)
-PKCS7_SIGN_ENVELOPE **a;
-unsigned char **pp;
-long length;
+PKCS7_SIGN_ENVELOPE *d2i_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE **a,
+	     unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_SIGN_ENVELOPE *,PKCS7_SIGN_ENVELOPE_new);
 
@@ -116,7 +112,7 @@ long length;
 		ASN1_F_D2I_PKCS7_SIGN_ENVELOPE);
 	}
 
-PKCS7_SIGN_ENVELOPE *PKCS7_SIGN_ENVELOPE_new()
+PKCS7_SIGN_ENVELOPE *PKCS7_SIGN_ENVELOPE_new(void)
 	{
 	PKCS7_SIGN_ENVELOPE *ret=NULL;
 	ASN1_CTX c;
@@ -133,8 +129,7 @@ PKCS7_SIGN_ENVELOPE *PKCS7_SIGN_ENVELOPE_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_SIGN_ENVELOPE_NEW);
 	}
 
-void PKCS7_SIGN_ENVELOPE_free(a)
-PKCS7_SIGN_ENVELOPE *a;
+void PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/p7_signd.c b/crypto/asn1/p7_signd.c
index f4d03f8b89..c7e78cd3a3 100644
--- a/crypto/asn1/p7_signd.c
+++ b/crypto/asn1/p7_signd.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_SIGNED,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_SIGNED(a,pp)
-PKCS7_SIGNED *a;
-unsigned char **pp;
+int i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -91,10 +89,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_SIGNED *d2i_PKCS7_SIGNED(a,pp,length)
-PKCS7_SIGNED **a;
-unsigned char **pp;
-long length;
+PKCS7_SIGNED *d2i_PKCS7_SIGNED(PKCS7_SIGNED **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_SIGNED *,PKCS7_SIGNED_new);
 
@@ -111,7 +107,7 @@ long length;
 	M_ASN1_D2I_Finish(a,PKCS7_SIGNED_free,ASN1_F_D2I_PKCS7_SIGNED);
 	}
 
-PKCS7_SIGNED *PKCS7_SIGNED_new()
+PKCS7_SIGNED *PKCS7_SIGNED_new(void)
 	{
 	PKCS7_SIGNED *ret=NULL;
 	ASN1_CTX c;
@@ -127,8 +123,7 @@ PKCS7_SIGNED *PKCS7_SIGNED_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_SIGNED_NEW);
 	}
 
-void PKCS7_SIGNED_free(a)
-PKCS7_SIGNED *a;
+void PKCS7_SIGNED_free(PKCS7_SIGNED *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/p7_signi.c b/crypto/asn1/p7_signi.c
index 2a5dcb39fa..3ca11d9fc0 100644
--- a/crypto/asn1/p7_signi.c
+++ b/crypto/asn1/p7_signi.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_PKCS7_SIGNER_INFO,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_PKCS7_SIGNER_INFO(a,pp)
-PKCS7_SIGNER_INFO *a;
-unsigned char **pp;
+int i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -93,10 +91,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-PKCS7_SIGNER_INFO *d2i_PKCS7_SIGNER_INFO(a,pp,length)
-PKCS7_SIGNER_INFO **a;
-unsigned char **pp;
-long length;
+PKCS7_SIGNER_INFO *d2i_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO **a,
+	     unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,PKCS7_SIGNER_INFO *,PKCS7_SIGNER_INFO_new);
 
@@ -116,7 +112,7 @@ long length;
 		ASN1_F_D2I_PKCS7_SIGNER_INFO);
 	}
 
-PKCS7_SIGNER_INFO *PKCS7_SIGNER_INFO_new()
+PKCS7_SIGNER_INFO *PKCS7_SIGNER_INFO_new(void)
 	{
 	PKCS7_SIGNER_INFO *ret=NULL;
 	ASN1_CTX c;
@@ -134,8 +130,7 @@ PKCS7_SIGNER_INFO *PKCS7_SIGNER_INFO_new()
 	M_ASN1_New_Error(ASN1_F_PKCS7_SIGNER_INFO_NEW);
 	}
 
-void PKCS7_SIGNER_INFO_free(a)
-PKCS7_SIGNER_INFO *a;
+void PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/p8_pkey.c b/crypto/asn1/p8_pkey.c
index 360009422f..455ee884b0 100644
--- a/crypto/asn1/p8_pkey.c
+++ b/crypto/asn1/p8_pkey.c
@@ -65,9 +65,7 @@
  *ASN1err(ASN1_F_D2I_PKCS8_PRIV_KEY_INFO,ASN1_R_DECODE_ERROR)
  */
 
-int i2d_PKCS8_PRIV_KEY_INFO (a,pp)
-PKCS8_PRIV_KEY_INFO *a;
-unsigned char **pp;
+int i2d_PKCS8_PRIV_KEY_INFO (PKCS8_PRIV_KEY_INFO *a, unsigned char **pp)
 {
 
 	M_ASN1_I2D_vars(a);
@@ -87,7 +85,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 }
 
-PKCS8_PRIV_KEY_INFO *PKCS8_PRIV_KEY_INFO_new()
+PKCS8_PRIV_KEY_INFO *PKCS8_PRIV_KEY_INFO_new(void)
 {
 	PKCS8_PRIV_KEY_INFO *ret=NULL;
 	ASN1_CTX c;
@@ -101,10 +99,8 @@ PKCS8_PRIV_KEY_INFO *PKCS8_PRIV_KEY_INFO_new()
 	M_ASN1_New_Error(ASN1_F_PKCS8_PRIV_KEY_INFO_NEW);
 }
 
-PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO(a,pp,length)
-PKCS8_PRIV_KEY_INFO **a;
-unsigned char **pp;
-long length;
+PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO **a,
+	     unsigned char **pp, long length)
 {
 	M_ASN1_D2I_vars(a,PKCS8_PRIV_KEY_INFO *,PKCS8_PRIV_KEY_INFO_new);
 	M_ASN1_D2I_Init();
@@ -119,8 +115,7 @@ long length;
 	M_ASN1_D2I_Finish(a, PKCS8_PRIV_KEY_INFO_free, ASN1_F_D2I_PKCS8_PRIV_KEY_INFO);
 }
 
-void PKCS8_PRIV_KEY_INFO_free (a)
-PKCS8_PRIV_KEY_INFO *a;
+void PKCS8_PRIV_KEY_INFO_free (PKCS8_PRIV_KEY_INFO *a)
 {
 	if (a == NULL) return;
 	ASN1_INTEGER_free (a->version);
diff --git a/crypto/asn1/pkcs8.c b/crypto/asn1/pkcs8.c
index d2bc9ce134..c9e94a276e 100644
--- a/crypto/asn1/pkcs8.c
+++ b/crypto/asn1/pkcs8.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_X509_KEY_NEW,ERR_R_BAD_GET_ASN1_OBJECT_CALL);
  */
 
-int i2d_X509_KEY(a,pp)
-X509 *a;
-unsigned char **pp;
+int i2d_X509_KEY(X509 *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -85,10 +83,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509 *d2i_X509_KEY(a,pp,length)
-X509 **a;
-unsigned char **pp;
-long length;
+X509 *d2i_X509_KEY(X509 **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,X509 *,X509_new);
 
@@ -100,7 +95,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_free,ASN1_F_D2I_X509);
 	}
 
-X509 *X509_KEY_new()
+X509 *X509_KEY_new(void)
 	{
 	X509_KEY *ret=NULL;
 
@@ -114,8 +109,7 @@ X509 *X509_KEY_new()
 	M_ASN1_New_Error(ASN1_F_X509_NEW);
 	}
 
-void X509_KEY_free(a)
-X509 *a;
+void X509_KEY_free(X509 *a)
 	{
 	int i;
 
diff --git a/crypto/asn1/t_crl.c b/crypto/asn1/t_crl.c
index eb0ab2e323..e919893265 100644
--- a/crypto/asn1/t_crl.c
+++ b/crypto/asn1/t_crl.c
@@ -71,9 +71,7 @@ static void ext_print();
 #endif
 
 #ifndef NO_FP_API
-int X509_CRL_print_fp(fp,x)
-FILE *fp;
-X509_CRL *x;
+int X509_CRL_print_fp(FILE *fp, X509_CRL *x)
         {
         BIO *b;
         int ret;
@@ -90,9 +88,7 @@ X509_CRL *x;
         }
 #endif
 
-int X509_CRL_print(out, x)
-BIO *out;
-X509_CRL *x;
+int X509_CRL_print(BIO *out, X509_CRL *x)
 {
 	char buf[256];
 	unsigned char *s;
@@ -157,9 +153,7 @@ X509_CRL *x;
 
 }
 
-static void ext_print(out, ex)
-BIO *out;
-X509_EXTENSION *ex;
+static void ext_print(BIO *out, X509_EXTENSION *ex)
 {
 	ASN1_OBJECT *obj;
 	int j;
diff --git a/crypto/asn1/t_pkey.c b/crypto/asn1/t_pkey.c
index 8a960f9cb2..fde4a37902 100644
--- a/crypto/asn1/t_pkey.c
+++ b/crypto/asn1/t_pkey.c
@@ -83,10 +83,7 @@ static int print();
 
 #ifndef NO_RSA
 #ifndef NO_FP_API
-int RSA_print_fp(fp,x,off)
-FILE *fp;
-RSA *x;
-int off;
+int RSA_print_fp(FILE *fp, RSA *x, int off)
         {
         BIO *b;
         int ret;
@@ -103,10 +100,7 @@ int off;
         }
 #endif
 
-int RSA_print(bp,x,off)
-BIO *bp;
-RSA *x;
-int off;
+int RSA_print(BIO *bp, RSA *x, int off)
 	{
 	char str[128];
 	const char *s;
@@ -155,10 +149,7 @@ err:
 
 #ifndef NO_DSA
 #ifndef NO_FP_API
-int DSA_print_fp(fp,x,off)
-FILE *fp;
-DSA *x;
-int off;
+int DSA_print_fp(FILE *fp, DSA *x, int off)
 	{
 	BIO *b;
 	int ret;
@@ -175,10 +166,7 @@ int off;
 	}
 #endif
 
-int DSA_print(bp,x,off)
-BIO *bp;
-DSA *x;
-int off;
+int DSA_print(BIO *bp, DSA *x, int off)
 	{
 	char str[128];
 	unsigned char *m=NULL;
@@ -230,12 +218,8 @@ err:
 	}
 #endif /* !NO_DSA */
 
-static int print(bp,number,num,buf,off)
-BIO *bp;
-const char *number;
-BIGNUM *num;
-unsigned char *buf;
-int off;
+static int print(BIO *bp, const char *number, BIGNUM *num, unsigned char *buf,
+	     int off)
 	{
 	int n,i;
 	char str[128];
@@ -286,9 +270,7 @@ int off;
 
 #ifndef NO_DH
 #ifndef NO_FP_API
-int DHparams_print_fp(fp,x)
-FILE *fp;
-DH *x;
+int DHparams_print_fp(FILE *fp, DH *x)
         {
         BIO *b;
         int ret;
@@ -305,9 +287,7 @@ DH *x;
         }
 #endif
 
-int DHparams_print(bp,x)
-BIO *bp;
-DH *x;
+int DHparams_print(BIO *bp, DH *x)
 	{
 	unsigned char *m=NULL;
 	int reason=ERR_R_BUF_LIB,i,ret=0;
@@ -343,9 +323,7 @@ err:
 
 #ifndef NO_DSA
 #ifndef NO_FP_API
-int DSAparams_print_fp(fp,x)
-FILE *fp;
-DSA *x;
+int DSAparams_print_fp(FILE *fp, DSA *x)
         {
         BIO *b;
         int ret;
@@ -362,9 +340,7 @@ DSA *x;
         }
 #endif
 
-int DSAparams_print(bp,x)
-BIO *bp;
-DSA *x;
+int DSAparams_print(BIO *bp, DSA *x)
 	{
 	unsigned char *m=NULL;
 	int reason=ERR_R_BUF_LIB,i,ret=0;
diff --git a/crypto/asn1/t_req.c b/crypto/asn1/t_req.c
index bc05ff6c0e..1079fe643d 100644
--- a/crypto/asn1/t_req.c
+++ b/crypto/asn1/t_req.c
@@ -64,9 +64,7 @@
 #include "x509.h"
 
 #ifndef NO_FP_API
-int X509_REQ_print_fp(fp,x)
-FILE *fp;
-X509_REQ *x;
+int X509_REQ_print_fp(FILE *fp, X509_REQ *x)
         {
         BIO *b;
         int ret;
@@ -83,9 +81,7 @@ X509_REQ *x;
         }
 #endif
 
-int X509_REQ_print(bp,x)
-BIO *bp;
-X509_REQ *x;
+int X509_REQ_print(BIO *bp, X509_REQ *x)
 	{
 	unsigned long l;
 	int i,n;
diff --git a/crypto/asn1/t_x509.c b/crypto/asn1/t_x509.c
index 1ab2caef19..e804635be2 100644
--- a/crypto/asn1/t_x509.c
+++ b/crypto/asn1/t_x509.c
@@ -71,9 +71,7 @@
 #include "x509v3.h"
 
 #ifndef NO_FP_API
-int X509_print_fp(fp,x)
-FILE *fp;
-X509 *x;
+int X509_print_fp(FILE *fp, X509 *x)
         {
         BIO *b;
         int ret;
@@ -90,9 +88,7 @@ X509 *x;
         }
 #endif
 
-int X509_print(bp,x)
-BIO *bp;
-X509 *x;
+int X509_print(BIO *bp, X509 *x)
 	{
 	long l;
 	int ret=0,i,j,n;
@@ -233,9 +229,7 @@ err:
 	return(ret);
 	}
 
-int ASN1_STRING_print(bp,v)
-BIO *bp;
-ASN1_STRING *v;
+int ASN1_STRING_print(BIO *bp, ASN1_STRING *v)
 	{
 	int i,n;
 	char buf[80],*p;;
@@ -264,9 +258,7 @@ ASN1_STRING *v;
 	return(1);
 	}
 
-int ASN1_TIME_print(bp, tm)
-BIO *bp;
-ASN1_TIME *tm;
+int ASN1_TIME_print(BIO *bp, ASN1_TIME *tm)
 {
 	if(tm->type == V_ASN1_UTCTIME) return ASN1_UTCTIME_print(bp, tm);
 	if(tm->type == V_ASN1_GENERALIZEDTIME)
@@ -281,9 +273,7 @@ static const char *mon[12]=
     "Jul","Aug","Sep","Oct","Nov","Dec"
     };
 
-int ASN1_GENERALIZEDTIME_print(bp,tm)
-BIO *bp;
-ASN1_GENERALIZEDTIME *tm;
+int ASN1_GENERALIZEDTIME_print(BIO *bp, ASN1_GENERALIZEDTIME *tm)
 	{
 	char *v;
 	int gmt=0;
@@ -317,9 +307,7 @@ err:
 	return(0);
 	}
 
-int ASN1_UTCTIME_print(bp,tm)
-BIO *bp;
-ASN1_UTCTIME *tm;
+int ASN1_UTCTIME_print(BIO *bp, ASN1_UTCTIME *tm)
 	{
 	char *v;
 	int gmt=0;
@@ -354,10 +342,7 @@ err:
 	return(0);
 	}
 
-int X509_NAME_print(bp,name,obase)
-BIO *bp;
-X509_NAME *name;
-int obase;
+int X509_NAME_print(BIO *bp, X509_NAME *name, int obase)
 	{
 	char *s,*c;
 	int ret=0,l,ll,i,first=1;
diff --git a/crypto/asn1/x_algor.c b/crypto/asn1/x_algor.c
index 01aa0cb6fc..70b3779947 100644
--- a/crypto/asn1/x_algor.c
+++ b/crypto/asn1/x_algor.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_D2I_X509_ALGOR,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_X509_ALGOR(a,pp)
-X509_ALGOR *a;
-unsigned char **pp;
+int i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -84,10 +82,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_ALGOR *d2i_X509_ALGOR(a,pp,length)
-X509_ALGOR **a;
-unsigned char **pp;
-long length;
+X509_ALGOR *d2i_X509_ALGOR(X509_ALGOR **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,X509_ALGOR *,X509_ALGOR_new);
 
@@ -104,7 +99,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_ALGOR_free,ASN1_F_D2I_X509_ALGOR);
 	}
 
-X509_ALGOR *X509_ALGOR_new()
+X509_ALGOR *X509_ALGOR_new(void)
 	{
 	X509_ALGOR *ret=NULL;
 	ASN1_CTX c;
@@ -116,8 +111,7 @@ X509_ALGOR *X509_ALGOR_new()
 	M_ASN1_New_Error(ASN1_F_X509_ALGOR_NEW);
 	}
 
-void X509_ALGOR_free(a)
-X509_ALGOR *a;
+void X509_ALGOR_free(X509_ALGOR *a)
 	{
 	if (a == NULL) return;
 	ASN1_OBJECT_free(a->algorithm);
diff --git a/crypto/asn1/x_attrib.c b/crypto/asn1/x_attrib.c
index 68b2648af3..ab8777a79f 100644
--- a/crypto/asn1/x_attrib.c
+++ b/crypto/asn1/x_attrib.c
@@ -68,9 +68,7 @@
  */
 
 /* sequence */
-int i2d_X509_ATTRIBUTE(a,pp)
-X509_ATTRIBUTE *a;
-unsigned char **pp;
+int i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a, unsigned char **pp)
 	{
 	int k=0;
 	int r=0,ret=0;
@@ -100,10 +98,8 @@ unsigned char **pp;
 		}
 	}
 
-X509_ATTRIBUTE *d2i_X509_ATTRIBUTE(a,pp,length)
-X509_ATTRIBUTE **a;
-unsigned char **pp;
-long length;
+X509_ATTRIBUTE *d2i_X509_ATTRIBUTE(X509_ATTRIBUTE **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,X509_ATTRIBUTE *,X509_ATTRIBUTE_new);
 
@@ -126,10 +122,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_ATTRIBUTE_free,ASN1_F_D2I_X509_ATTRIBUTE);
 	}
 
-X509_ATTRIBUTE *X509_ATTRIBUTE_create(nid,atrtype,value)
-int nid;
-int atrtype;
-char *value;
+X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, char *value)
 	{
 	X509_ATTRIBUTE *ret=NULL;
 	ASN1_TYPE *val=NULL;
@@ -150,7 +143,7 @@ err:
 	return(NULL);
 	}
 
-X509_ATTRIBUTE *X509_ATTRIBUTE_new()
+X509_ATTRIBUTE *X509_ATTRIBUTE_new(void)
 	{
 	X509_ATTRIBUTE *ret=NULL;
 	ASN1_CTX c;
@@ -163,8 +156,7 @@ X509_ATTRIBUTE *X509_ATTRIBUTE_new()
 	M_ASN1_New_Error(ASN1_F_X509_ATTRIBUTE_NEW);
 	}
 	
-void X509_ATTRIBUTE_free(a)
-X509_ATTRIBUTE *a;
+void X509_ATTRIBUTE_free(X509_ATTRIBUTE *a)
 	{
 	if (a == NULL) return;
 	ASN1_OBJECT_free(a->object);
diff --git a/crypto/asn1/x_cinf.c b/crypto/asn1/x_cinf.c
index 88099ea9f7..41939334be 100644
--- a/crypto/asn1/x_cinf.c
+++ b/crypto/asn1/x_cinf.c
@@ -65,9 +65,7 @@
  * ASN1err(ASN1_F_X509_CINF_NEW,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_X509_CINF(a,pp)
-X509_CINF *a;
-unsigned char **pp;
+int i2d_X509_CINF(X509_CINF *a, unsigned char **pp)
 	{
 	int v1=0,v2=0;
 	M_ASN1_I2D_vars(a);
@@ -99,10 +97,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_CINF *d2i_X509_CINF(a,pp,length)
-X509_CINF **a;
-unsigned char **pp;
-long length;
+X509_CINF *d2i_X509_CINF(X509_CINF **a, unsigned char **pp, long length)
 	{
 	int ver=0;
 	M_ASN1_D2I_vars(a,X509_CINF *,X509_CINF_new);
@@ -166,7 +161,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_CINF_free,ASN1_F_D2I_X509_CINF);
 	}
 
-X509_CINF *X509_CINF_new()
+X509_CINF *X509_CINF_new(void)
 	{
 	X509_CINF *ret=NULL;
 	ASN1_CTX c;
@@ -186,8 +181,7 @@ X509_CINF *X509_CINF_new()
 	M_ASN1_New_Error(ASN1_F_X509_CINF_NEW);
 	}
 
-void X509_CINF_free(a)
-X509_CINF *a;
+void X509_CINF_free(X509_CINF *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
diff --git a/crypto/asn1/x_crl.c b/crypto/asn1/x_crl.c
index 1dd651b3ec..e8f8ebd76c 100644
--- a/crypto/asn1/x_crl.c
+++ b/crypto/asn1/x_crl.c
@@ -78,9 +78,7 @@ static int X509_REVOKED_cmp();
 static int X509_REVOKED_seq_cmp();
 #endif
 
-int i2d_X509_REVOKED(a,pp)
-X509_REVOKED *a;
-unsigned char **pp;
+int i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -97,10 +95,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_REVOKED *d2i_X509_REVOKED(a,pp,length)
-X509_REVOKED **a;
-unsigned char **pp;
-long length;
+X509_REVOKED *d2i_X509_REVOKED(X509_REVOKED **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,X509_REVOKED *,X509_REVOKED_new);
 
@@ -113,9 +109,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_REVOKED_free,ASN1_F_D2I_X509_REVOKED);
 	}
 
-int i2d_X509_CRL_INFO(a,pp)
-X509_CRL_INFO *a;
-unsigned char **pp;
+int i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **pp)
 	{
 	int v1=0;
 	long l=0;
@@ -155,10 +149,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_CRL_INFO *d2i_X509_CRL_INFO(a,pp,length)
-X509_CRL_INFO **a;
-unsigned char **pp;
-long length;
+X509_CRL_INFO *d2i_X509_CRL_INFO(X509_CRL_INFO **a, unsigned char **pp,
+	     long length)
 	{
 	int i,ver=0;
 	M_ASN1_D2I_vars(a,X509_CRL_INFO *,X509_CRL_INFO_new);
@@ -220,9 +212,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_CRL_INFO_free,ASN1_F_D2I_X509_CRL_INFO);
 	}
 
-int i2d_X509_CRL(a,pp)
-X509_CRL *a;
-unsigned char **pp;
+int i2d_X509_CRL(X509_CRL *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -239,10 +229,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_CRL *d2i_X509_CRL(a,pp,length)
-X509_CRL **a;
-unsigned char **pp;
-long length;
+X509_CRL *d2i_X509_CRL(X509_CRL **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,X509_CRL *,X509_CRL_new);
 
@@ -256,7 +243,7 @@ long length;
 	}
 
 
-X509_REVOKED *X509_REVOKED_new()
+X509_REVOKED *X509_REVOKED_new(void)
 	{
 	X509_REVOKED *ret=NULL;
 	ASN1_CTX c;
@@ -269,7 +256,7 @@ X509_REVOKED *X509_REVOKED_new()
 	M_ASN1_New_Error(ASN1_F_X509_REVOKED_NEW);
 	}
 
-X509_CRL_INFO *X509_CRL_INFO_new()
+X509_CRL_INFO *X509_CRL_INFO_new(void)
 	{
 	X509_CRL_INFO *ret=NULL;
 	ASN1_CTX c;
@@ -287,7 +274,7 @@ X509_CRL_INFO *X509_CRL_INFO_new()
 	M_ASN1_New_Error(ASN1_F_X509_CRL_INFO_NEW);
 	}
 
-X509_CRL *X509_CRL_new()
+X509_CRL *X509_CRL_new(void)
 	{
 	X509_CRL *ret=NULL;
 	ASN1_CTX c;
@@ -301,8 +288,7 @@ X509_CRL *X509_CRL_new()
 	M_ASN1_New_Error(ASN1_F_X509_CRL_NEW);
 	}
 
-void X509_REVOKED_free(a)
-X509_REVOKED *a;
+void X509_REVOKED_free(X509_REVOKED *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->serialNumber);
@@ -311,8 +297,7 @@ X509_REVOKED *a;
 	Free((char *)a);
 	}
 
-void X509_CRL_INFO_free(a)
-X509_CRL_INFO *a;
+void X509_CRL_INFO_free(X509_CRL_INFO *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
@@ -326,8 +311,7 @@ X509_CRL_INFO *a;
 	Free((char *)a);
 	}
 
-void X509_CRL_free(a)
-X509_CRL *a;
+void X509_CRL_free(X509_CRL *a)
 	{
 	int i;
 
@@ -352,16 +336,14 @@ X509_CRL *a;
 	Free((char *)a);
 	}
 
-static int X509_REVOKED_cmp(a,b)
-X509_REVOKED **a,**b;
+static int X509_REVOKED_cmp(X509_REVOKED **a, X509_REVOKED **b)
 	{
 	return(ASN1_STRING_cmp(
 		(ASN1_STRING *)(*a)->serialNumber,
 		(ASN1_STRING *)(*b)->serialNumber));
 	}
 
-static int X509_REVOKED_seq_cmp(a,b)
-X509_REVOKED **a,**b;
+static int X509_REVOKED_seq_cmp(X509_REVOKED **a, X509_REVOKED **b)
 	{
 	return((*a)->sequence-(*b)->sequence);
 	}
diff --git a/crypto/asn1/x_exten.c b/crypto/asn1/x_exten.c
index f5e3ece226..15c46e3526 100644
--- a/crypto/asn1/x_exten.c
+++ b/crypto/asn1/x_exten.c
@@ -66,9 +66,7 @@
  * ASN1err(ASN1_F_X509_EXTENSION_NEW,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_X509_EXTENSION(a,pp)
-X509_EXTENSION *a;
-unsigned char **pp;
+int i2d_X509_EXTENSION(X509_EXTENSION *a, unsigned char **pp)
 	{
 	int k=0;
 	int r=0,ret=0;
@@ -96,10 +94,8 @@ unsigned char **pp;
 		}
 	}
 
-X509_EXTENSION *d2i_X509_EXTENSION(a,pp,length)
-X509_EXTENSION **a;
-unsigned char **pp;
-long length;
+X509_EXTENSION *d2i_X509_EXTENSION(X509_EXTENSION **a, unsigned char **pp,
+	     long length)
 	{
 	int i;
 	M_ASN1_D2I_vars(a,X509_EXTENSION *,X509_EXTENSION_new);
@@ -127,7 +123,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_EXTENSION_free,ASN1_F_D2I_X509_EXTENSION);
 	}
 
-X509_EXTENSION *X509_EXTENSION_new()
+X509_EXTENSION *X509_EXTENSION_new(void)
 	{
 	X509_EXTENSION *ret=NULL;
 	ASN1_CTX c;
@@ -144,8 +140,7 @@ X509_EXTENSION *X509_EXTENSION_new()
 	M_ASN1_New_Error(ASN1_F_X509_EXTENSION_NEW);
 	}
 	
-void X509_EXTENSION_free(a)
-X509_EXTENSION *a;
+void X509_EXTENSION_free(X509_EXTENSION *a)
 	{
 	if (a == NULL) return;
 	if ((a->argp != NULL) && (a->ex_free != NULL))
diff --git a/crypto/asn1/x_info.c b/crypto/asn1/x_info.c
index b55f0ce77a..03bc38cdf7 100644
--- a/crypto/asn1/x_info.c
+++ b/crypto/asn1/x_info.c
@@ -62,7 +62,7 @@
 #include "asn1_mac.h"
 #include "x509.h"
 
-X509_INFO *X509_INFO_new()
+X509_INFO *X509_INFO_new(void)
 	{
 	X509_INFO *ret=NULL;
 
@@ -84,8 +84,7 @@ X509_INFO *X509_INFO_new()
 	return(ret);
 	}
 
-void X509_INFO_free(x)
-X509_INFO *x;
+void X509_INFO_free(X509_INFO *x)
 	{
 	int i;
 
diff --git a/crypto/asn1/x_name.c b/crypto/asn1/x_name.c
index 3af14c8e6c..939b1699d6 100644
--- a/crypto/asn1/x_name.c
+++ b/crypto/asn1/x_name.c
@@ -74,9 +74,7 @@ static int i2d_X509_NAME_entries(X509_NAME *a);
 static int i2d_X509_NAME_entries();
 #endif
 
-int i2d_X509_NAME_ENTRY(a,pp)
-X509_NAME_ENTRY *a;
-unsigned char **pp;
+int i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -91,10 +89,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_NAME_ENTRY *d2i_X509_NAME_ENTRY(a,pp,length)
-X509_NAME_ENTRY **a;
-unsigned char **pp;
-long length;
+X509_NAME_ENTRY *d2i_X509_NAME_ENTRY(X509_NAME_ENTRY **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,X509_NAME_ENTRY *,X509_NAME_ENTRY_new);
 
@@ -106,9 +102,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_NAME_ENTRY_free,ASN1_F_D2I_X509_NAME_ENTRY);
 	}
 
-int i2d_X509_NAME(a,pp)
-X509_NAME *a;
-unsigned char **pp;
+int i2d_X509_NAME(X509_NAME *a, unsigned char **pp)
 	{
 	int ret;
 
@@ -128,8 +122,7 @@ unsigned char **pp;
 	return(ret);
 	}
 
-static int i2d_X509_NAME_entries(a)
-X509_NAME *a;
+static int i2d_X509_NAME_entries(X509_NAME *a)
 	{
 	X509_NAME_ENTRY *ne,*fe=NULL;
 	STACK *sk;
@@ -190,10 +183,7 @@ err:
 	return(-1);
 	}
 
-X509_NAME *d2i_X509_NAME(a,pp,length)
-X509_NAME **a;
-unsigned char **pp;
-long length;
+X509_NAME *d2i_X509_NAME(X509_NAME **a, unsigned char **pp, long length)
 	{
 	int set=0,i;
 	int idx=0;
@@ -232,7 +222,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_NAME_free,ASN1_F_D2I_X509_NAME);
 	}
 
-X509_NAME *X509_NAME_new()
+X509_NAME *X509_NAME_new(void)
 	{
 	X509_NAME *ret=NULL;
 	ASN1_CTX c;
@@ -246,7 +236,7 @@ X509_NAME *X509_NAME_new()
 	M_ASN1_New_Error(ASN1_F_X509_NAME_NEW);
 	}
 
-X509_NAME_ENTRY *X509_NAME_ENTRY_new()
+X509_NAME_ENTRY *X509_NAME_ENTRY_new(void)
 	{
 	X509_NAME_ENTRY *ret=NULL;
 	ASN1_CTX c;
@@ -260,8 +250,7 @@ X509_NAME_ENTRY *X509_NAME_ENTRY_new()
 	M_ASN1_New_Error(ASN1_F_X509_NAME_ENTRY_NEW);
 	}
 
-void X509_NAME_free(a)
-X509_NAME *a;
+void X509_NAME_free(X509_NAME *a)
 	{
 	if(a == NULL)
 	    return;
@@ -271,8 +260,7 @@ X509_NAME *a;
 	Free((char *)a);
 	}
 
-void X509_NAME_ENTRY_free(a)
-X509_NAME_ENTRY *a;
+void X509_NAME_ENTRY_free(X509_NAME_ENTRY *a)
 	{
 	if (a == NULL) return;
 	ASN1_OBJECT_free(a->object);
@@ -280,9 +268,7 @@ X509_NAME_ENTRY *a;
 	Free((char *)a);
 	}
 
-int X509_NAME_set(xn,name)
-X509_NAME **xn;
-X509_NAME *name;
+int X509_NAME_set(X509_NAME **xn, X509_NAME *name)
 	{
 	X509_NAME *in;
 
diff --git a/crypto/asn1/x_pkey.c b/crypto/asn1/x_pkey.c
index 3a359cce9e..2e677f0b24 100644
--- a/crypto/asn1/x_pkey.c
+++ b/crypto/asn1/x_pkey.c
@@ -66,17 +66,12 @@
 /* ASN1err(ASN1_F_X509_PKEY_NEW,ASN1_R_IV_TOO_LARGE); */
 
 /* need to implement */
-int i2d_X509_PKEY(a,pp)
-X509_PKEY *a;
-unsigned char **pp;
+int i2d_X509_PKEY(X509_PKEY *a, unsigned char **pp)
 	{
 	return(0);
 	}
 
-X509_PKEY *d2i_X509_PKEY(a,pp,length)
-X509_PKEY **a;
-unsigned char **pp;
-long length;
+X509_PKEY *d2i_X509_PKEY(X509_PKEY **a, unsigned char **pp, long length)
 	{
 	int i;
 	M_ASN1_D2I_vars(a,X509_PKEY *,X509_PKEY_new);
@@ -111,7 +106,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_PKEY_free,ASN1_F_D2I_X509_PKEY);
 	}
 
-X509_PKEY *X509_PKEY_new()
+X509_PKEY *X509_PKEY_new(void)
 	{
 	X509_PKEY *ret=NULL;
 	ASN1_CTX c;
@@ -131,8 +126,7 @@ X509_PKEY *X509_PKEY_new()
 	M_ASN1_New_Error(ASN1_F_X509_PKEY_NEW);
 	}
 
-void X509_PKEY_free(x)
-X509_PKEY *x;
+void X509_PKEY_free(X509_PKEY *x)
 	{
 	int i;
 
diff --git a/crypto/asn1/x_pubkey.c b/crypto/asn1/x_pubkey.c
index 2177ebd6ed..9711f98da1 100644
--- a/crypto/asn1/x_pubkey.c
+++ b/crypto/asn1/x_pubkey.c
@@ -65,9 +65,7 @@
  * ASN1err(ASN1_F_X509_PUBKEY_NEW,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_X509_PUBKEY(a,pp)
-X509_PUBKEY *a;
-unsigned char **pp;
+int i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -82,10 +80,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_PUBKEY *d2i_X509_PUBKEY(a,pp,length)
-X509_PUBKEY **a;
-unsigned char **pp;
-long length;
+X509_PUBKEY *d2i_X509_PUBKEY(X509_PUBKEY **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,X509_PUBKEY *,X509_PUBKEY_new);
 
@@ -101,7 +97,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_PUBKEY_free,ASN1_F_D2I_X509_PUBKEY);
 	}
 
-X509_PUBKEY *X509_PUBKEY_new()
+X509_PUBKEY *X509_PUBKEY_new(void)
 	{
 	X509_PUBKEY *ret=NULL;
 	ASN1_CTX c;
@@ -114,8 +110,7 @@ X509_PUBKEY *X509_PUBKEY_new()
 	M_ASN1_New_Error(ASN1_F_X509_PUBKEY_NEW);
 	}
 
-void X509_PUBKEY_free(a)
-X509_PUBKEY *a;
+void X509_PUBKEY_free(X509_PUBKEY *a)
 	{
 	if (a == NULL) return;
 	X509_ALGOR_free(a->algor);
@@ -124,9 +119,7 @@ X509_PUBKEY *a;
 	Free((char *)a);
 	}
 
-int X509_PUBKEY_set(x,pkey)
-X509_PUBKEY **x;
-EVP_PKEY *pkey;
+int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey)
 	{
 	int ok=0;
 	X509_PUBKEY *pk;
@@ -209,8 +202,7 @@ err:
 	return(ok);
 	}
 
-EVP_PKEY *X509_PUBKEY_get(key)
-X509_PUBKEY *key;
+EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key)
 	{
 	EVP_PKEY *ret=NULL;
 	long j;
diff --git a/crypto/asn1/x_req.c b/crypto/asn1/x_req.c
index 949632c325..4bb604e5a4 100644
--- a/crypto/asn1/x_req.c
+++ b/crypto/asn1/x_req.c
@@ -68,9 +68,7 @@
  * ASN1err(ASN1_F_X509_REQ_INFO_NEW,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_X509_REQ_INFO(a,pp)
-X509_REQ_INFO *a;
-unsigned char **pp;
+int i2d_X509_REQ_INFO(X509_REQ_INFO *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -117,10 +115,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_REQ_INFO *d2i_X509_REQ_INFO(a,pp,length)
-X509_REQ_INFO **a;
-unsigned char **pp;
-long length;
+X509_REQ_INFO *d2i_X509_REQ_INFO(X509_REQ_INFO **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,X509_REQ_INFO *,X509_REQ_INFO_new);
 
@@ -148,7 +144,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_REQ_INFO_free,ASN1_F_D2I_X509_REQ_INFO);
 	}
 
-X509_REQ_INFO *X509_REQ_INFO_new()
+X509_REQ_INFO *X509_REQ_INFO_new(void)
 	{
 	X509_REQ_INFO *ret=NULL;
 	ASN1_CTX c;
@@ -163,8 +159,7 @@ X509_REQ_INFO *X509_REQ_INFO_new()
 	M_ASN1_New_Error(ASN1_F_X509_REQ_INFO_NEW);
 	}
 	
-void X509_REQ_INFO_free(a)
-X509_REQ_INFO *a;
+void X509_REQ_INFO_free(X509_REQ_INFO *a)
 	{
 	if (a == NULL) return;
 	ASN1_INTEGER_free(a->version);
@@ -174,9 +169,7 @@ X509_REQ_INFO *a;
 	Free((char *)a);
 	}
 
-int i2d_X509_REQ(a,pp)
-X509_REQ *a;
-unsigned char **pp;
+int i2d_X509_REQ(X509_REQ *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 	M_ASN1_I2D_len(a->req_info,	i2d_X509_REQ_INFO);
@@ -192,10 +185,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_REQ *d2i_X509_REQ(a,pp,length)
-X509_REQ **a;
-unsigned char **pp;
-long length;
+X509_REQ *d2i_X509_REQ(X509_REQ **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,X509_REQ *,X509_REQ_new);
 
@@ -207,7 +197,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_REQ_free,ASN1_F_D2I_X509_REQ);
 	}
 
-X509_REQ *X509_REQ_new()
+X509_REQ *X509_REQ_new(void)
 	{
 	X509_REQ *ret=NULL;
 	ASN1_CTX c;
@@ -221,8 +211,7 @@ X509_REQ *X509_REQ_new()
 	M_ASN1_New_Error(ASN1_F_X509_REQ_NEW);
 	}
 
-void X509_REQ_free(a)
-X509_REQ *a;
+void X509_REQ_free(X509_REQ *a)
 	{
 	int i;
 
diff --git a/crypto/asn1/x_sig.c b/crypto/asn1/x_sig.c
index 245a76b0f0..b0675b74c3 100644
--- a/crypto/asn1/x_sig.c
+++ b/crypto/asn1/x_sig.c
@@ -65,9 +65,7 @@
  * ASN1err(ASN1_F_X509_SIG_NEW,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_X509_SIG(a,pp)
-X509_SIG *a;
-unsigned char **pp;
+int i2d_X509_SIG(X509_SIG *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -82,10 +80,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_SIG *d2i_X509_SIG(a,pp,length)
-X509_SIG **a;
-unsigned char **pp;
-long length;
+X509_SIG *d2i_X509_SIG(X509_SIG **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,X509_SIG *,X509_SIG_new);
 
@@ -96,7 +91,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_SIG_free,ASN1_F_D2I_X509_SIG);
 	}
 
-X509_SIG *X509_SIG_new()
+X509_SIG *X509_SIG_new(void)
 	{
 	X509_SIG *ret=NULL;
 	ASN1_CTX c;
@@ -108,8 +103,7 @@ X509_SIG *X509_SIG_new()
 	M_ASN1_New_Error(ASN1_F_X509_SIG_NEW);
 	}
 
-void X509_SIG_free(a)
-X509_SIG *a;
+void X509_SIG_free(X509_SIG *a)
 	{
 	if (a == NULL) return;
 	X509_ALGOR_free(a->algor);
diff --git a/crypto/asn1/x_spki.c b/crypto/asn1/x_spki.c
index 5600d305a3..8cb1aaee33 100644
--- a/crypto/asn1/x_spki.c
+++ b/crypto/asn1/x_spki.c
@@ -72,9 +72,7 @@
  * ASN1err(ASN1_F_NETSCAPE_SPKI_NEW,ERR_R_ASN1_LENGTH_MISMATCH);
  */
 
-int i2d_NETSCAPE_SPKAC(a,pp)
-NETSCAPE_SPKAC *a;
-unsigned char **pp;
+int i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -89,10 +87,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-NETSCAPE_SPKAC *d2i_NETSCAPE_SPKAC(a,pp,length)
-NETSCAPE_SPKAC **a;
-unsigned char **pp;
-long length;
+NETSCAPE_SPKAC *d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,NETSCAPE_SPKAC *,NETSCAPE_SPKAC_new);
 
@@ -103,7 +99,7 @@ long length;
 	M_ASN1_D2I_Finish(a,NETSCAPE_SPKAC_free,ASN1_F_D2I_NETSCAPE_SPKAC);
 	}
 
-NETSCAPE_SPKAC *NETSCAPE_SPKAC_new()
+NETSCAPE_SPKAC *NETSCAPE_SPKAC_new(void)
 	{
 	NETSCAPE_SPKAC *ret=NULL;
 	ASN1_CTX c;
@@ -115,8 +111,7 @@ NETSCAPE_SPKAC *NETSCAPE_SPKAC_new()
 	M_ASN1_New_Error(ASN1_F_NETSCAPE_SPKAC_NEW);
 	}
 
-void NETSCAPE_SPKAC_free(a)
-NETSCAPE_SPKAC *a;
+void NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a)
 	{
 	if (a == NULL) return;
 	X509_PUBKEY_free(a->pubkey);
@@ -124,9 +119,7 @@ NETSCAPE_SPKAC *a;
 	Free((char *)a);
 	}
 
-int i2d_NETSCAPE_SPKI(a,pp)
-NETSCAPE_SPKI *a;
-unsigned char **pp;
+int i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -143,10 +136,8 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-NETSCAPE_SPKI *d2i_NETSCAPE_SPKI(a,pp,length)
-NETSCAPE_SPKI **a;
-unsigned char **pp;
-long length;
+NETSCAPE_SPKI *d2i_NETSCAPE_SPKI(NETSCAPE_SPKI **a, unsigned char **pp,
+	     long length)
 	{
 	M_ASN1_D2I_vars(a,NETSCAPE_SPKI *,NETSCAPE_SPKI_new);
 
@@ -158,7 +149,7 @@ long length;
 	M_ASN1_D2I_Finish(a,NETSCAPE_SPKI_free,ASN1_F_D2I_NETSCAPE_SPKI);
 	}
 
-NETSCAPE_SPKI *NETSCAPE_SPKI_new()
+NETSCAPE_SPKI *NETSCAPE_SPKI_new(void)
 	{
 	NETSCAPE_SPKI *ret=NULL;
 	ASN1_CTX c;
@@ -171,8 +162,7 @@ NETSCAPE_SPKI *NETSCAPE_SPKI_new()
 	M_ASN1_New_Error(ASN1_F_NETSCAPE_SPKI_NEW);
 	}
 
-void NETSCAPE_SPKI_free(a)
-NETSCAPE_SPKI *a;
+void NETSCAPE_SPKI_free(NETSCAPE_SPKI *a)
 	{
 	if (a == NULL) return;
 	NETSCAPE_SPKAC_free(a->spkac);
diff --git a/crypto/asn1/x_val.c b/crypto/asn1/x_val.c
index f6534a6a5c..9ffa8671d5 100644
--- a/crypto/asn1/x_val.c
+++ b/crypto/asn1/x_val.c
@@ -65,9 +65,7 @@
  * ASN1err(ASN1_F_D2I_X509_VAL,ERR_R_MALLOC_FAILURE);
  */
 
-int i2d_X509_VAL(a,pp)
-X509_VAL *a;
-unsigned char **pp;
+int i2d_X509_VAL(X509_VAL *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -82,10 +80,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509_VAL *d2i_X509_VAL(a,pp,length)
-X509_VAL **a;
-unsigned char **pp;
-long length;
+X509_VAL *d2i_X509_VAL(X509_VAL **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,X509_VAL *,X509_VAL_new);
 
@@ -96,7 +91,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_VAL_free,ASN1_F_D2I_X509_VAL);
 	}
 
-X509_VAL *X509_VAL_new()
+X509_VAL *X509_VAL_new(void)
 	{
 	X509_VAL *ret=NULL;
 	ASN1_CTX c;
@@ -108,8 +103,7 @@ X509_VAL *X509_VAL_new()
 	M_ASN1_New_Error(ASN1_F_X509_VAL_NEW);
 	}
 
-void X509_VAL_free(a)
-X509_VAL *a;
+void X509_VAL_free(X509_VAL *a)
 	{
 	if (a == NULL) return;
 	ASN1_TIME_free(a->notBefore);
diff --git a/crypto/asn1/x_x509.c b/crypto/asn1/x_x509.c
index 8e7d214d21..f1459a7989 100644
--- a/crypto/asn1/x_x509.c
+++ b/crypto/asn1/x_x509.c
@@ -72,14 +72,12 @@ static ASN1_METHOD meth={
 	(char *(*)())X509_new,
 	(void (*)()) X509_free};
 
-ASN1_METHOD *X509_asn1_meth()
+ASN1_METHOD *X509_asn1_meth(void)
 	{
 	return(&meth);
 	}
 
-int i2d_X509(a,pp)
-X509 *a;
-unsigned char **pp;
+int i2d_X509(X509 *a, unsigned char **pp)
 	{
 	M_ASN1_I2D_vars(a);
 
@@ -96,10 +94,7 @@ unsigned char **pp;
 	M_ASN1_I2D_finish();
 	}
 
-X509 *d2i_X509(a,pp,length)
-X509 **a;
-unsigned char **pp;
-long length;
+X509 *d2i_X509(X509 **a, unsigned char **pp, long length)
 	{
 	M_ASN1_D2I_vars(a,X509 *,X509_new);
 
@@ -114,7 +109,7 @@ long length;
 	M_ASN1_D2I_Finish(a,X509_free,ASN1_F_D2I_X509);
 	}
 
-X509 *X509_new()
+X509 *X509_new(void)
 	{
 	X509 *ret=NULL;
 	ASN1_CTX c;
@@ -130,8 +125,7 @@ X509 *X509_new()
 	M_ASN1_New_Error(ASN1_F_X509_NEW);
 	}
 
-void X509_free(a)
-X509 *a;
+void X509_free(X509 *a)
 	{
 	int i;
 
-- 
cgit v1.2.3