Changes between 0.9.2b and 0.9.3
+ *) Change functions to ANSI C.
+ [Ulf Möller]
+
*) Fix typos in error codes.
[Martin Kraemer <Martin.Kraemer@MchP.Siemens.De>, Ulf Möller]
#endif
#ifdef undef /* never finished - probably never will be :-) */
-int args_from_file(file,argc,argv)
-char *file;
-int *argc;
-char **argv[];
+int args_from_file(char *file, int *argc, char **argv[])
{
FILE *fp;
int num,i;
}
#endif
-int str2fmt(s)
-char *s;
+int str2fmt(char *s)
{
if ((*s == 'D') || (*s == 'd'))
return(FORMAT_ASN1);
}
#if defined(MSDOS) || defined(WIN32) || defined(WIN16)
-void program_name(in,out,size)
-char *in;
-char *out;
-int size;
+void program_name(char *in, char *out, int size)
{
int i,n;
char *p=NULL;
out[n]='\0';
}
#else
-void program_name(in,out,size)
-char *in;
-char *out;
-int size;
+void program_name(char *in, char *out, int size)
{
char *p;
#endif
#ifdef WIN32
-int WIN32_rename(from,to)
-char *from;
-char *to;
+int WIN32_rename(char *from, char *to)
{
int ret;
}
#endif
-int chopup_args(arg,buf,argc,argv)
-ARGS *arg;
-char *buf;
-int *argc;
-char **argv[];
+int chopup_args(ARGS *arg, char *buf, int *argc, char **argv[])
{
int num,len,i;
char *p;
}
#ifndef APP_INIT
-int app_init(mesgwin)
-long mesgwin;
+int app_init(long mesgwin)
{
return(1);
}
#undef PROG
#define PROG asn1parse_main
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int i,badops=0,offset=0,ret=1,j;
unsigned int length=0;
static int preserve=0;
static int msie_hack=0;
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int total=0;
int total_done=0;
EXIT(ret);
}
-static void lookup_fail(name,tag)
-char *name;
-char *tag;
+static void lookup_fail(char *name, char *tag)
{
BIO_printf(bio_err,"variable lookup failed for %s::%s\n",name,tag);
}
-static int MS_CALLBACK key_callback(buf,len,verify)
-char *buf;
-int len,verify;
+static int MS_CALLBACK key_callback(char *buf, int len, int verify)
{
int i;
return(i);
}
-static unsigned long index_serial_hash(a)
-char **a;
+static unsigned long index_serial_hash(char **a)
{
char *n;
return(lh_strhash(n));
}
-static int index_serial_cmp(a,b)
-char **a;
-char **b;
+static int index_serial_cmp(char **a, char **b)
{
char *aa,*bb;
return(strcmp(aa,bb));
}
-static unsigned long index_name_hash(a)
-char **a;
+static unsigned long index_name_hash(char **a)
{ return(lh_strhash(a[DB_name])); }
-static int index_name_qual(a)
-char **a;
+static int index_name_qual(char **a)
{ return(a[0][0] == 'V'); }
-static int index_name_cmp(a,b)
-char **a;
-char **b;
- { return(strcmp(a[DB_name],b[DB_name])); }
+static int index_name_cmp(char **a, char **b)
+ { return(strcmp(a[DB_name],
+ b[DB_name])); }
-static BIGNUM *load_serial(serialfile)
-char *serialfile;
+static BIGNUM *load_serial(char *serialfile)
{
BIO *in=NULL;
BIGNUM *ret=NULL;
return(ret);
}
-static int save_serial(serialfile,serial)
-char *serialfile;
-BIGNUM *serial;
+static int save_serial(char *serialfile, BIGNUM *serial)
{
BIO *out;
int ret=0;
return(ret);
}
-static int certify(xret,infile,pkey,x509,dgst,policy,db,serial,startdate,days,
- batch,ext_sect,lconf,verbose)
-X509 **xret;
-char *infile;
-EVP_PKEY *pkey;
-X509 *x509;
-const EVP_MD *dgst;
-STACK *policy;
-TXT_DB *db;
-BIGNUM *serial;
-char *startdate;
-int days;
-int batch;
-char *ext_sect;
-LHASH *lconf;
-int verbose;
+static int certify(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
+ const EVP_MD *dgst, STACK *policy, TXT_DB *db, BIGNUM *serial,
+ char *startdate, int days, int batch, char *ext_sect, LHASH *lconf,
+ int verbose)
{
X509_REQ *req=NULL;
BIO *in=NULL;
return(ok);
}
-static int certify_cert(xret,infile,pkey,x509,dgst,policy,db,serial,startdate,
- days,batch,ext_sect,lconf,verbose)
-X509 **xret;
-char *infile;
-EVP_PKEY *pkey;
-X509 *x509;
-const EVP_MD *dgst;
-STACK *policy;
-TXT_DB *db;
-BIGNUM *serial;
-char *startdate;
-int days;
-int batch;
-char *ext_sect;
-LHASH *lconf;
-int verbose;
+static int certify_cert(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
+ const EVP_MD *dgst, STACK *policy, TXT_DB *db, BIGNUM *serial,
+ char *startdate, int days, int batch, char *ext_sect, LHASH *lconf,
+ int verbose)
+
{
X509 *req=NULL;
X509_REQ *rreq=NULL;
return(ok);
}
-static int do_body(xret,pkey,x509,dgst,policy,db,serial,startdate,days,
- batch,verbose,req,ext_sect,lconf)
-X509 **xret;
-EVP_PKEY *pkey;
-X509 *x509;
-const EVP_MD *dgst;
-STACK *policy;
-TXT_DB *db;
-BIGNUM *serial;
-char *startdate;
-int days;
-int batch;
-int verbose;
-X509_REQ *req;
-char *ext_sect;
-LHASH *lconf;
+static int do_body(X509 **xret, EVP_PKEY *pkey, X509 *x509, const EVP_MD *dgst,
+ STACK *policy, TXT_DB *db, BIGNUM *serial, char *startdate, int days,
+ int batch, int verbose, X509_REQ *req, char *ext_sect, LHASH *lconf)
{
X509_NAME *name=NULL,*CAname=NULL,*subject=NULL;
ASN1_UTCTIME *tm,*tmptm;
return(ok);
}
-static void write_new_certificate(bp,x, output_der)
-BIO *bp;
-X509 *x;
-int output_der;
+static void write_new_certificate(BIO *bp, X509 *x, int output_der)
{
char *f;
char buf[256];
BIO_puts(bp,"\n");
}
-static int certify_spkac(xret,infile,pkey,x509,dgst,policy,db,serial,
- startdate,days,ext_sect,lconf,verbose)
-X509 **xret;
-char *infile;
-EVP_PKEY *pkey;
-X509 *x509;
-const EVP_MD *dgst;
-STACK *policy;
-TXT_DB *db;
-BIGNUM *serial;
-char *startdate;
-int days;
-char *ext_sect;
-LHASH *lconf;
-int verbose;
+static int certify_spkac(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
+ const EVP_MD *dgst, STACK *policy, TXT_DB *db, BIGNUM *serial,
+ char *startdate, int days, char *ext_sect, LHASH *lconf, int verbose)
{
STACK *sk=NULL;
LHASH *parms=NULL;
return(ok);
}
-static int fix_data(nid,type)
-int nid;
-int *type;
+static int fix_data(int nid, int *type)
{
if (nid == NID_pkcs9_emailAddress)
*type=V_ASN1_IA5STRING;
return(1);
}
-static int check_time_format(str)
-char *str;
+static int check_time_format(char *str)
{
ASN1_UTCTIME tm;
return(ASN1_UTCTIME_check(&tm));
}
-static int add_oid_section(hconf)
-LHASH *hconf;
+static int add_oid_section(LHASH *hconf)
{
char *p;
STACK *sktmp;
return 1;
}
-static int do_revoke(x509,db)
-X509 *x509;
-TXT_DB *db;
+static int do_revoke(X509 *x509, TXT_DB *db)
{
ASN1_UTCTIME *tm=NULL;
char *row[DB_NUMBER],**rrow,**irow;
NULL
};
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int ret=1,i;
int verbose=0;
static BIO *bio_out=NULL;
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
X509_CRL *x=NULL;
int ret=1,i,num,badops=0;
EXIT(ret);
}
-static X509_CRL *load_crl(infile, format)
-char *infile;
-int format;
+static X509_CRL *load_crl(char *infile, int format)
{
X509_CRL *x=NULL;
BIO *in=NULL;
* -out arg - output file - default stdout
*/
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int i,badops=0;
BIO *in=NULL,*out=NULL;
* number of certs added if successful, -1 if not.
*----------------------------------------------------------------------
*/
-static int add_certs_from_file(stack,certfile)
-STACK_OF(X509) *stack;
-char *certfile;
+static int add_certs_from_file(STACK_OF(X509) *stack, char *certfile)
{
struct stat st;
BIO *in=NULL;
void do_fp();
#endif
-int MAIN(argc,argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
unsigned char *buf=NULL;
int i,err=0;
EXIT(err);
}
-void do_fp(buf,bp,sep)
-unsigned char *buf;
-BIO *bp;
-int sep;
+void do_fp(unsigned char *buf, BIO *bp, int sep)
{
int len;
int i;
* -C
*/
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
DH *dh=NULL;
int i,badops=0,text=0;
* -modulus - print the DSA public key
*/
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int ret=1;
DSA *dsa=NULL;
static void MS_CALLBACK dsa_cb();
#endif
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
DSA *dsa=NULL;
int i,badops=0,text=0;
EXIT(ret);
}
-static void MS_CALLBACK dsa_cb(p, n, arg)
-int p;
-int n;
-char *arg;
+static void MS_CALLBACK dsa_cb(int p, int n, char *arg)
{
char c='*';
#define BSIZE (8*1024)
#define PROG enc_main
-int MAIN(argc,argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
char *strbuf=NULL;
unsigned char *buff=NULL,*bufsize=NULL;
EXIT(ret);
}
-int set_hex(in,out,size)
-char *in;
-unsigned char *out;
-int size;
+int set_hex(char *in, unsigned char *out, int size)
{
int i,n;
unsigned char j;
#undef PROG
#define PROG errstr_main
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int i,ret=0;
char buf[256];
static long dh_load_rand();
#endif
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
char buffer[200];
DH *dh=NULL;
EXIT(ret);
}
-static void MS_CALLBACK dh_cb(p,n,arg)
-int p;
-int n;
-char *arg;
+static void MS_CALLBACK dh_cb(int p, int n, char *arg)
{
char c='*';
#endif
}
-static long dh_load_rand(name)
-char *name;
+static long dh_load_rand(char *name)
{
char *p,*n;
int last;
static long dsa_load_rand();
#endif
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
char buffer[200];
DSA *dsa=NULL;
EXIT(ret);
}
-static long dsa_load_rand(name)
-char *name;
+static long dsa_load_rand(char *name)
{
char *p,*n;
int last;
static long gr_load_rand();
#endif
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int ret=1;
char buffer[200];
EXIT(ret);
}
-static void MS_CALLBACK genrsa_cb(p, n, arg)
-int p;
-int n;
-char *arg;
+static void MS_CALLBACK genrsa_cb(int p, int n, char *arg)
{
char c='*';
#endif
}
-static long gr_load_rand(name)
-char *name;
+static long gr_load_rand(char *name)
{
char *p,*n;
int last;
static int dump_cert_text();
#endif
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
char **args, *infile = NULL, *outfile = NULL;
BIO *in = NULL, *out = NULL;
EXIT(ret);
}
-static int dump_cert_text(out, x)
-BIO *out;
-X509 *x;
+static int dump_cert_text(BIO *out, X509 *x)
{
char buf[256];
X509_NAME_oneline(X509_get_subject_name(x),buf,256);
char *default_config_file=NULL;
#ifdef DEBUG
-static void sig_stop(i)
-int i;
+static void sig_stop(int i)
{
char *a=NULL;
BIO *bio_err=NULL;
#endif
-int main(Argc,Argv)
-int Argc;
-char *Argv[];
+int main(int Argc, char *Argv[])
{
ARGS arg;
#define PROG_NAME_SIZE 16
#define LIST_MESSAGE_DIGEST_COMMANDS "list-message-digest-commands"
#define LIST_CIPHER_COMMANDS "list-cipher-commands"
-static int do_cmd(prog,argc,argv)
-LHASH *prog;
-int argc;
-char *argv[];
+static int do_cmd(LHASH *prog, int argc, char *argv[])
{
FUNCTION f,*fp;
int i,ret=1,tp,nl;
return strcmp(f1->name,f2->name);
}
-static LHASH *prog_init()
+static LHASH *prog_init(void)
{
LHASH *ret;
FUNCTION *f;
return(ret);
}
-static int MS_CALLBACK cmp(a,b)
-FUNCTION *a,*b;
+static int MS_CALLBACK cmp(FUNCTION *a, FUNCTION *b)
{
return(strncmp(a->name,b->name,8));
}
-static unsigned long MS_CALLBACK hash(a)
-FUNCTION *a;
+static unsigned long MS_CALLBACK hash(FUNCTION *a)
{
return(lh_strhash(a->name));
}
struct lines_st *next;
} LINES;
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
FILE *in;
RSA *rsa=NULL;
int cert_load();
#endif
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
char *infile=NULL, *outfile=NULL, *keyname = NULL;
char *certfile=NULL;
EXIT(ret);
}
-int dump_cert_text (out, x)
-BIO *out;
-X509 *x;
+int dump_cert_text (BIO *out, X509 *x)
{
char buf[256];
X509_NAME_oneline(X509_get_subject_name(x),buf,256);
return 0;
}
-int dump_certs_keys_p12 (out, p12, pass, passlen, options)
-BIO *out;
-PKCS12 *p12;
-unsigned char *pass;
-int passlen;
-int options;
+int dump_certs_keys_p12 (BIO *out, PKCS12 *p12, unsigned char *pass,
+ int passlen, int options)
{
STACK *asafes, *bags;
int i, bagnid;
return 1;
}
-int dump_certs_pkeys_bags (out, bags, pass, passlen, options)
-BIO *out;
-STACK *bags;
-unsigned char *pass;
-int passlen;
-int options;
+int dump_certs_pkeys_bags (BIO *out, STACK *bags, unsigned char *pass,
+ int passlen, int options)
{
int i;
for (i = 0; i < sk_num (bags); i++) {
return 1;
}
-int dump_certs_pkeys_bag (out, bag, pass, passlen, options)
-BIO *out;
-PKCS12_SAFEBAG *bag;
-unsigned char *pass;
-int passlen;
-int options;
+int dump_certs_pkeys_bag (BIO *out, PKCS12_SAFEBAG *bag, unsigned char *pass,
+ int passlen, int options)
{
EVP_PKEY *pkey;
PKCS8_PRIV_KEY_INFO *p8;
/* Hope this is OK .... */
-int get_cert_chain (cert, chain)
-X509 *cert;
-STACK **chain;
+int get_cert_chain (X509 *cert, STACK **chain)
{
X509_STORE *store;
X509_STORE_CTX store_ctx;
return i;
}
-int alg_print (x, alg)
-BIO *x;
-X509_ALGOR *alg;
+int alg_print (BIO *x, X509_ALGOR *alg)
{
PBEPARAM *pbe;
unsigned char *p;
/* Load all certificates from a given file */
-int cert_load(in, sk)
-BIO *in;
-STACK *sk;
+int cert_load(BIO *in, STACK *sk)
{
int ret;
X509 *cert;
/* Generalised attribute print: handle PKCS#8 and bag attributes */
-int print_attribs (out, attrlst, name)
-BIO *out;
-STACK *attrlst;
-char *name;
+int print_attribs (BIO *out, STACK *attrlst, char *name)
{
X509_ATTRIBUTE *attr;
ASN1_TYPE *av;
return 1;
}
-void hex_prin(out, buf, len)
-BIO *out;
-unsigned char *buf;
-int len;
+void hex_prin(BIO *out, unsigned char *buf, int len)
{
int i;
for (i = 0; i < len; i++) BIO_printf (out, "%02X ", buf[i]);
* -print_certs
*/
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
PKCS7 *p7=NULL;
int i,badops=0;
#define TYPE_DSA 2
#define TYPE_DH 3
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
#ifndef NO_DSA
DSA *dsa_params=NULL;
EXIT(ex);
}
-static int make_REQ(req,pkey,attribs)
-X509_REQ *req;
-EVP_PKEY *pkey;
-int attribs;
+static int make_REQ(X509_REQ *req, EVP_PKEY *pkey, int attribs)
{
int ret=0,i;
unsigned char *p,*q;
return(ret);
}
-static int add_DN_object(n,text,def,value,nid,min,max)
-X509_NAME *n;
-char *text;
-char *def;
-char *value;
-int nid;
-int min;
-int max;
+static int add_DN_object(X509_NAME *n, char *text, char *def, char *value,
+ int nid, int min, int max)
{
int i,j,ret=0;
X509_NAME_ENTRY *ne=NULL;
return(ret);
}
-static int add_attribute_object(n,text,def,value,nid,min,max)
-STACK *n;
-char *text;
-char *def;
-char *value;
-int nid;
-int min;
-int max;
+static int add_attribute_object(STACK *n, char *text, char *def, char *value,
+ int nid, int min, int max)
{
int i,z;
X509_ATTRIBUTE *xa=NULL;
return(0);
}
-static void MS_CALLBACK req_cb(p,n,arg)
-int p;
-int n;
-char *arg;
+static void MS_CALLBACK req_cb(int p, int n, char *arg)
{
char c='*';
#endif
}
-static int req_fix_data(nid,type,len,min,max)
-int nid;
-int *type;
-int len,min,max;
+static int req_fix_data(int nid, int *type, int len, int min, int max)
{
if (nid == NID_pkcs9_emailAddress)
*type=V_ASN1_IA5STRING;
}
/* Check if the end of a string matches 'end' */
-static int check_end(str, end)
-char *str;
-char *end;
+static int check_end(char *str, char *end)
{
int elen, slen;
char *tmp;
return strcmp(tmp, end);
}
-static int add_oid_section(conf)
-LHASH *conf;
+static int add_oid_section(LHASH *conf)
{
char *p;
STACK *sktmp;
* -modulus - print the RSA key modulus
*/
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int ret=1;
RSA *rsa=NULL;
int verify_depth=0;
int verify_error=X509_V_OK;
-int MS_CALLBACK verify_callback(ok, ctx)
-int ok;
-X509_STORE_CTX *ctx;
+int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
{
char buf[256];
X509 *err_cert;
return(ok);
}
-int set_cert_stuff(ctx, cert_file, key_file)
-SSL_CTX *ctx;
-char *cert_file;
-char *key_file;
+int set_cert_stuff(SSL_CTX *ctx, char *cert_file, char *key_file)
{
if (cert_file != NULL)
{
return(1);
}
-long MS_CALLBACK bio_dump_cb(bio,cmd,argp,argi,argl,ret)
-BIO *bio;
-int cmd;
-const char *argp;
-int argi;
-long argl;
-long ret;
+long MS_CALLBACK bio_dump_cb(BIO *bio, int cmd, const char *argp, int argi,
+ long argl, long ret)
{
BIO *out;
return(ret);
}
-void MS_CALLBACK apps_ssl_info_callback(s,where,ret)
-SSL *s;
-int where;
-int ret;
+void MS_CALLBACK apps_ssl_info_callback(SSL *s, int where, int ret)
{
char *str;
int w;
static BIO *bio_c_out=NULL;
static int c_quiet=0;
-static void sc_usage()
+static void sc_usage(void)
{
BIO_printf(bio_err,"usage: s_client args\n");
BIO_printf(bio_err,"\n");
}
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int off=0;
SSL *con=NULL,*con2=NULL;
}
-static void print_stuff(bio,s,full)
-BIO *bio;
-SSL *s;
-int full;
+static void print_stuff(BIO *bio, SSL *s, int full)
{
X509 *peer=NULL;
char *p;
0x02,
};
-static DH *get_dh512()
+static DH *get_dh512(void)
{
DH *dh=NULL;
static int s_quiet=0;
#if 0
-static void s_server_init()
+static void s_server_init(void)
{
cipher=NULL;
s_server_verify=SSL_VERIFY_NONE;
}
#endif
-static void sv_usage()
+static void sv_usage(void)
{
BIO_printf(bio_err,"usage: s_server [args ...]\n");
BIO_printf(bio_err,"\n");
static char **local_argv;
static int hack=0;
-int MAIN(argc, argv)
-int argc;
-char *argv[];
+int MAIN(int argc, char *argv[])
{
short port=PORT;
char *CApath=NULL,*CAfile=NULL;
EXIT(ret);
}
-static void print_stats(bio,ssl_ctx)
-BIO *bio;
-SSL_CTX *ssl_ctx;
+static void print_stats(BIO *bio, SSL_CTX *ssl_ctx)
{
BIO_printf(bio,"%4ld items in the session cache\n",
SSL_CTX_sess_number(ssl_ctx));
SSL_CTX_sess_get_cache_size(ssl_ctx));
}
-static int sv_body(hostname, s, context)
-char *hostname;
-int s;
-char *context;
+static int sv_body(char *hostname, int s, char *context)
{
char *buf=NULL;
fd_set readfds;
return(ret);
}
-static void close_accept_socket()
+static void close_accept_socket(void)
{
BIO_printf(bio_err,"shutdown accept socket\n");
if (accept_socket >= 0)
}
}
-static int init_ssl_connection(con)
-SSL *con;
+static int init_ssl_connection(SSL *con)
{
int i;
const char *str;
}
#ifndef NO_DH
-static DH *load_dh_param()
+static DH *load_dh_param(void)
{
DH *ret=NULL;
BIO *bio;
#endif
#if 0
-static int load_CA(ctx,file)
-SSL_CTX *ctx;
-char *file;
+static int load_CA(SSL_CTX *ctx, char *file)
{
FILE *in;
X509 *x=NULL;
}
#endif
-static int www_body(hostname, s, context)
-char *hostname;
-int s;
-char *context;
+static int www_body(char *hostname, int s, char *context)
{
char *buf=NULL;
int ret=1;
return(ret);
}
-static RSA MS_CALLBACK *tmp_rsa_cb(s,export,keylength)
-SSL *s;
-int export;
-int keylength;
+static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int export, int keylength)
{
static RSA *rsa_tmp=NULL;
static FARPROC lpTopHookProc=NULL;
extern HINSTANCE _hInstance; /* nice global CRT provides */
-static LONG FAR PASCAL topHookProc(hwnd,message,wParam,lParam)
-HWND hwnd;
-UINT message;
-WPARAM wParam;
-LPARAM lParam;
+static LONG FAR PASCAL topHookProc(HWND hwnd, UINT message, WPARAM wParam,
+ LPARAM lParam)
{
if (hwnd == topWnd)
{
#endif /* WIN32 */
#endif /* WINDOWS */
-void sock_cleanup()
+void sock_cleanup(void)
{
#ifdef WINDOWS
if (wsa_init_done)
#endif
}
-int sock_init()
+int sock_init(void)
{
#ifdef WINDOWS
if (!wsa_init_done)
return(1);
}
-int init_client(sock, host, port)
-int *sock;
-char *host;
-int port;
+int init_client(int *sock, char *host, int port)
{
unsigned char ip[4];
short p=0;
return(init_client_ip(sock,ip,port));
}
-int init_client_ip(sock, ip, port)
-int *sock;
-unsigned char ip[4];
-int port;
+int init_client_ip(int *sock, unsigned char ip[4], int port)
{
unsigned long addr;
struct sockaddr_in them;
return(1);
}
-int nbio_sock_error(sock)
-int sock;
+int nbio_sock_error(int sock)
{
int j,i,size;
return(j);
}
-int nbio_init_client_ip(sock, ip, port)
-int *sock;
-unsigned char ip[4];
-int port;
+int nbio_init_client_ip(int *sock, unsigned char ip[4], int port)
{
unsigned long addr;
struct sockaddr_in them;
return(1);
}
-int do_server(port, ret, cb, context)
-int port;
-int *ret;
-int (*cb)();
-char *context;
+int do_server(int port, int *ret, int (*cb)(), char *context)
{
int sock;
char *name;
}
}
-int init_server_long(sock, port, ip)
-int *sock;
-int port;
-char *ip;
+int init_server_long(int *sock, int port, char *ip)
{
int ret=0;
struct sockaddr_in server;
return(ret);
}
-int init_server(sock,port)
-int *sock;
-int port;
+int init_server(int *sock, int port)
{
return(init_server_long(sock, port, NULL));
}
-int do_accept(acc_sock, sock, host)
-int acc_sock;
-int *sock;
-char **host;
+int do_accept(int acc_sock, int *sock, char **host)
{
int ret,i;
struct hostent *h1,*h2;
return(1);
}
-int extract_host_port(str,host_ptr,ip,port_ptr)
-char *str;
-char **host_ptr;
-unsigned char *ip;
-short *port_ptr;
+int extract_host_port(char *str, char **host_ptr, unsigned char *ip,
+ short *port_ptr)
{
char *h,*p;
return(0);
}
-int host_ip(str,ip)
-char *str;
-unsigned char ip[4];
+int host_ip(char *str, unsigned char ip[4])
{
unsigned int in[4];
int i;
return(0);
}
-int extract_port(str,port_ptr)
-char *str;
-short *port_ptr;
+int extract_port(char *str, short *port_ptr)
{
int i;
struct servent *s;
static unsigned long ghbn_hits=0L;
static unsigned long ghbn_miss=0L;
-static struct hostent *GetHostByName(name)
-char *name;
+static struct hostent *GetHostByName(char *name)
{
struct hostent *ret;
int i,lowi=0;
}
#ifndef MSDOS
-int spawn(argc, argv, in, out)
-int argc;
-char **argv;
-int *in;
-int *out;
+int spawn(int argc, char **argv, int *in, int *out)
{
int pid;
#define CHILD_READ p1[0]
static int exitNow = 0; /* Set when it's time to exit main */
#endif
-static void s_time_init()
+static void s_time_init(void)
{
host=SSL_CONNECT_NAME;
t_cert_file=NULL;
/***********************************************************************
* usage - display usage message
*/
-static void s_time_usage()
+static void s_time_usage(void)
{
static char umsg[] = "\
-time arg - max number of seconds to collect data, default %d\n\
*
* Returns 0 if ok, -1 on bad args
*/
-static int parseArgs(argc,argv)
-int argc;
-char **argv;
+static int parseArgs(int argc, char **argv)
{
int badop = 0;
#define START 0
#define STOP 1
-static double tm_Time_F(s)
-int s;
+static double tm_Time_F(int s)
{
static double ret;
#ifdef TIMES
* MAIN - main processing area for client
* real name depends on MONOLITH
*/
-int
-MAIN(argc,argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
double totalTime = 0.0;
int nConn = 0;
* Returns:
* SSL * = the connection pointer.
*/
-static SSL *
-doConnection(scon)
-SSL *scon;
+static SSL *doConnection(SSL *scon)
{
BIO *conn;
SSL *serverCon;
static BIO *bio_c_out=NULL;
static int c_quiet=0;
-static void sc_usage()
+static void sc_usage(void)
{
BIO_printf(bio_err,"usage: client args\n");
BIO_printf(bio_err,"\n");
}
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int off=0;
SSL *con=NULL,*con2=NULL;
static SSL_SESSION *load_sess_id();
#endif
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
SSL_SESSION *x=NULL;
int ret=1,i,num,badops=0;
EXIT(ret);
}
-static SSL_SESSION *load_sess_id(infile, format)
-char *infile;
-int format;
+static SSL_SESSION *load_sess_id(char *infile, int format)
{
SSL_SESSION *x=NULL;
BIO *in=NULL;
static SIGRETTYPE sig_done();
#endif
-static SIGRETTYPE sig_done(sig)
-int sig;
+static SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-static double Time_F(s)
-int s;
+static double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int MAIN(argc,argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
unsigned char *buf=NULL,*buf2=NULL;
int ret=1;
EXIT(ret);
}
-static void print_message(s,num,length)
-char *s;
-long num;
-int length;
+static void print_message(char *s, long num, int length)
{
#ifdef SIGALRM
BIO_printf(bio_err,"Doing %s for %ds on %d size blocks: ",s,SECONDS,length);
#endif
}
-static void pkey_print_message(str,str2,num,bits,tm)
-char *str;
-char *str2;
-long num;
-int bits;
-int tm;
+static void pkey_print_message(char *str, char *str2, long num, int bits,
+ int tm)
{
#ifdef SIGALRM
BIO_printf(bio_err,"Doing %d bit %s %s's for %ds: ",bits,str,str2,tm);
static int v_verbose=0;
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int i,ret=1;
char *CApath=NULL,*CAfile=NULL;
EXIT(ret);
}
-static int check(ctx,file)
-X509_STORE *ctx;
-char *file;
+static int check(X509_STORE *ctx, char *file)
{
X509 *x=NULL;
BIO *in=NULL;
return(ret);
}
-static int MS_CALLBACK cb(ok,ctx)
-int ok;
-X509_STORE_CTX *ctx;
+static int MS_CALLBACK cb(int ok, X509_STORE_CTX *ctx)
{
char buf[256];
#undef PROG
#define PROG version_main
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int i,ret=0;
int cflags=0,version=0,date=0,options=0,platform=0;
static int reqfile=0;
-int MAIN(argc, argv)
-int argc;
-char **argv;
+int MAIN(int argc, char **argv)
{
int ret=1;
X509_REQ *req=NULL;
EXIT(ret);
}
-static int x509_certify(ctx,CAfile,digest,x,xca,pkey,serialfile,create,days)
-X509_STORE *ctx;
-char *CAfile;
-const EVP_MD *digest;
-X509 *x;
-X509 *xca;
-EVP_PKEY *pkey;
-char *serialfile;
-int create;
-int days;
+static int x509_certify(X509_STORE *ctx, char *CAfile, const EVP_MD *digest,
+ X509 *x, X509 *xca, EVP_PKEY *pkey, char *serialfile, int create,
+ int days)
{
int ret=0;
BIO *io=NULL;
return(ret);
}
-static int MS_CALLBACK callb(ok, ctx)
-int ok;
-X509_STORE_CTX *ctx;
+static int MS_CALLBACK callb(int ok, X509_STORE_CTX *ctx)
{
char buf[256];
int err;
}
}
-static EVP_PKEY *load_key(file, format)
-char *file;
-int format;
+static EVP_PKEY *load_key(char *file, int format)
{
BIO *key=NULL;
EVP_PKEY *pkey=NULL;
return(pkey);
}
-static X509 *load_cert(file, format)
-char *file;
-int format;
+static X509 *load_cert(char *file, int format)
{
ASN1_HEADER *ah=NULL;
BUF_MEM *buf=NULL;
}
/* self sign */
-static int sign(x, pkey, days, digest)
-X509 *x;
-EVP_PKEY *pkey;
-int days;
-const EVP_MD *digest;
+static int sign(X509 *x, EVP_PKEY *pkey, int days, const EVP_MD *digest)
{
EVP_PKEY *pktmp;
* 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;
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;
/* 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;
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;
/* 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;
* 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;
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;
/* 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;
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;
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;
* 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;
#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;
}
#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;
#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;
#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;
/* 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;
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;
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];
return(1);
}
-long ASN1_ENUMERATED_get(a)
-ASN1_ENUMERATED *a;
+long ASN1_ENUMERATED_get(ASN1_ENUMERATED *a)
{
int neg=0,i;
long r=0;
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;
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;
* 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;
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};
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;
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;
* 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);
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);
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;
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);
#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;
}
#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;
/* 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;
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;
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];
return(1);
}
-long ASN1_INTEGER_get(a)
-ASN1_INTEGER *a;
+long ASN1_INTEGER_get(ASN1_INTEGER *a)
{
int neg=0,i;
long r=0;
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;
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;
(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);
}
* 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;
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];
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;
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;
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;
return(NULL);
}
-ASN1_OBJECT *ASN1_OBJECT_new()
+ASN1_OBJECT *ASN1_OBJECT_new(void)
{
ASN1_OBJECT *ret;
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)
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;
/* 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;
* 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;
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;
}
-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)); }
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;
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;
#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;
#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,
}
-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;
}
-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)
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;
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;
return(NULL);
}
-ASN1_TYPE *ASN1_TYPE_new()
+ASN1_TYPE *ASN1_TYPE_new(void)
{
ASN1_TYPE *ret=NULL;
ASN1_CTX c;
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);
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);
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;
* 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;
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};
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;
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;
/* 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;
#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;
/* 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;
#endif
-void ERR_load_ASN1_strings()
+void ERR_load_ASN1_strings(void)
{
static int init=1;
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 */
}
-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;
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;
/* 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;
*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;
*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;
return(ret);
}
-int asn1_Finish(c)
-ASN1_CTX *c;
+int asn1_Finish(ASN1_CTX *c)
{
if ((c->inf == (1|V_ASN1_CONSTRUCTED)) && (!c->eos))
{
return(1);
}
-int asn1_GetSequence(c,length)
-ASN1_CTX *c;
-long *length;
+int asn1_GetSequence(ASN1_CTX *c, long *length)
{
unsigned char *q;
return(1);
}
-ASN1_STRING *ASN1_STRING_dup(str)
-ASN1_STRING *str;
+ASN1_STRING *ASN1_STRING_dup(ASN1_STRING *str)
{
ASN1_STRING *ret;
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;
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;
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;
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];
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";
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;
/* 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;
* 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;
/* 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;
/* 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;
* 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;
* 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;
#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;
#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;
(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;
* 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;
* 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;
* 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;
#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;
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;
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;
/* 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;
/* 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";
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;
#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";
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;
#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";
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;
* 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;
* 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;
#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)
#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)
{
* 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];
* 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;
* 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];
* 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;
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;
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;
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;
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);
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);
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;
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);
* 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);
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;
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);
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);
*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);
M_ASN1_I2D_finish();
}
-PBEPARAM *PBEPARAM_new()
+PBEPARAM *PBEPARAM_new(void)
{
PBEPARAM *ret=NULL;
ASN1_CTX c;
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();
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);
/* 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;
*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);
M_ASN1_I2D_finish();
}
-PBE2PARAM *PBE2PARAM_new()
+PBE2PARAM *PBE2PARAM_new(void)
{
PBE2PARAM *ret=NULL;
ASN1_CTX c;
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();
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);
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);
M_ASN1_I2D_finish();
}
-PBKDF2PARAM *PBKDF2PARAM_new()
+PBKDF2PARAM *PBKDF2PARAM_new(void)
{
PBKDF2PARAM *ret=NULL;
ASN1_CTX c;
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();
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);
* 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);
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);
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;
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);
* 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);
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);
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;
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);
* 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);
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);
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;
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);
* 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);
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);
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;
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);
* 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);
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);
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;
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);
* 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);
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);
M_ASN1_D2I_Finish(a,PKCS7_free,ASN1_F_D2I_PKCS7);
}
-PKCS7 *PKCS7_new()
+PKCS7 *PKCS7_new(void)
{
PKCS7 *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_PKCS7_NEW);
}
-void PKCS7_free(a)
-PKCS7 *a;
+void PKCS7_free(PKCS7 *a)
{
if (a == NULL) return;
Free((char *)(char *)a);
}
-void PKCS7_content_free(a)
-PKCS7 *a;
+void PKCS7_content_free(PKCS7 *a)
{
if(a == NULL)
return;
* 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);
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);
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;
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);
* 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);
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);
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;
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);
* 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);
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);
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;
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);
* 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);
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);
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;
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);
*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);
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;
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();
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);
* 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);
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);
M_ASN1_D2I_Finish(a,X509_free,ASN1_F_D2I_X509);
}
-X509 *X509_KEY_new()
+X509 *X509_KEY_new(void)
{
X509_KEY *ret=NULL;
M_ASN1_New_Error(ASN1_F_X509_NEW);
}
-void X509_KEY_free(a)
-X509 *a;
+void X509_KEY_free(X509 *a)
{
int i;
#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;
}
#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;
}
-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;
#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;
}
#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;
#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;
}
#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;
}
#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];
#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;
}
#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;
#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;
}
#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;
#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;
}
#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;
#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;
}
#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;
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;;
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)
"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;
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;
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;
* 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);
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);
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;
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);
*/
/* 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;
}
}
-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);
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;
return(NULL);
}
-X509_ATTRIBUTE *X509_ATTRIBUTE_new()
+X509_ATTRIBUTE *X509_ATTRIBUTE_new(void)
{
X509_ATTRIBUTE *ret=NULL;
ASN1_CTX c;
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);
* 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);
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);
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;
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);
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);
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);
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;
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);
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);
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);
}
-X509_REVOKED *X509_REVOKED_new()
+X509_REVOKED *X509_REVOKED_new(void)
{
X509_REVOKED *ret=NULL;
ASN1_CTX c;
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;
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;
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);
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);
Free((char *)a);
}
-void X509_CRL_free(a)
-X509_CRL *a;
+void X509_CRL_free(X509_CRL *a)
{
int i;
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);
}
* 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;
}
}
-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);
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;
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))
#include "asn1_mac.h"
#include "x509.h"
-X509_INFO *X509_INFO_new()
+X509_INFO *X509_INFO_new(void)
{
X509_INFO *ret=NULL;
return(ret);
}
-void X509_INFO_free(x)
-X509_INFO *x;
+void X509_INFO_free(X509_INFO *x)
{
int i;
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);
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);
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;
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;
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;
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;
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;
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;
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);
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;
/* 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);
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;
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;
* 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);
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);
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;
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);
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;
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;
* 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);
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);
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;
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);
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);
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);
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;
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;
* 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);
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);
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;
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);
* 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);
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);
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;
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);
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);
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);
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;
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);
* 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);
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);
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;
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);
(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);
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);
M_ASN1_D2I_Finish(a,X509_free,ASN1_F_D2I_X509);
}
-X509 *X509_new()
+X509 *X509_new(void)
{
X509 *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_X509_NEW);
}
-void X509_free(a)
-X509 *a;
+void X509_free(X509 *a)
{
int i;
#include "blowfish.h"
#include "bf_locl.h"
-void BF_cbc_encrypt(in, out, length, ks, iv, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-BF_KEY *ks;
-unsigned char *iv;
-int encrypt;
+void BF_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+ BF_KEY *ks, unsigned char *iv, int encrypt)
{
register BF_LONG tin0,tin1;
register BF_LONG tout0,tout1,xor0,xor1;
* 64bit block we have used is contained in *num;
*/
-void BF_cfb64_encrypt(in, out, length, schedule, ivec, num, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-BF_KEY *schedule;
-unsigned char *ivec;
-int *num;
-int encrypt;
+void BF_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ BF_KEY *schedule, unsigned char *ivec, int *num, int encrypt)
{
register BF_LONG v0,v1,t;
register int n= *num;
const char *BF_version="BlowFish" OPENSSL_VERSION_PTEXT;
-const char *BF_options()
+const char *BF_options(void)
{
#ifdef BF_PTR
return("blowfish(ptr)");
#endif
}
-void BF_ecb_encrypt(in, out, ks, encrypt)
-unsigned char *in;
-unsigned char *out;
-BF_KEY *ks;
-int encrypt;
+void BF_ecb_encrypt(unsigned char *in, unsigned char *out, BF_KEY *ks,
+ int encrypt)
{
BF_LONG l,d[2];
*/
#if (BF_ROUNDS != 16) && (BF_ROUNDS != 20)
-If you set BF_ROUNDS to some value other than 16 or 20, you will have
+#error If you set BF_ROUNDS to some value other than 16 or 20, you will have \
to modify the code.
#endif
-void BF_encrypt(data,key)
-BF_LONG *data;
-BF_KEY *key;
+void BF_encrypt(BF_LONG *data, BF_KEY *key)
{
register BF_LONG l,r,*p,*s;
#ifndef BF_DEFAULT_OPTIONS
-void BF_decrypt(data,key)
-BF_LONG *data;
-BF_KEY *key;
+void BF_decrypt(BF_LONG *data, BF_KEY *key)
{
register BF_LONG l,r,*p,*s;
data[0]=r&0xffffffffL;
}
-void BF_cbc_encrypt(in, out, length, ks, iv, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-BF_KEY *ks;
-unsigned char *iv;
-int encrypt;
+void BF_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+ BF_KEY *ks, unsigned char *iv, int encrypt)
{
register BF_LONG tin0,tin1;
register BF_LONG tout0,tout1,xor0,xor1;
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void BF_ofb64_encrypt(in, out, length, schedule, ivec, num)
-unsigned char *in;
-unsigned char *out;
-long length;
-BF_KEY *schedule;
-unsigned char *ivec;
-int *num;
+void BF_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ BF_KEY *schedule, unsigned char *ivec, int *num)
{
register BF_LONG v0,v1,t;
register int n= *num;
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
fprintf(stderr,"%s bytes per sec = %12.2f (%5.1fuS)\n",name, \
tm[index]*8,1.0e6/tm[index]);
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
#include "bf_locl.h"
#include "bf_pi.h"
-void BF_set_key(key,len,data)
-BF_KEY *key;
-int len;
-unsigned char *data;
+void BF_set_key(BF_KEY *key, int len, unsigned char *data)
{
int i;
BF_LONG *p,ri,in[2];
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
static int print_test_data();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int ret;
return(0);
}
-static int print_test_data()
+static int print_test_data(void)
{
unsigned int i,j;
return(0);
}
-static int test()
+static int test(void)
{
unsigned char cbc_in[40],cbc_out[40],iv[8];
int i,n,err=0;
#define TRUNCATE
#define DUMP_WIDTH 16
-int BIO_dump(bio,s,len)
-BIO *bio;
-const char *s;
-int len;
+int BIO_dump(BIO *bio, const char *s, int len)
{
int ret=0;
char buf[160+1],tmp[20];
static struct hostent *ghbn_dup();
#endif
-int BIO_get_host_ip(str,ip)
-const char *str;
-unsigned char *ip;
+int BIO_get_host_ip(const char *str, unsigned char *ip)
{
int i;
struct hostent *he;
return(1);
}
-int BIO_get_port(str,port_ptr)
-const char *str;
-unsigned short *port_ptr;
+int BIO_get_port(const char *str, unsigned short *port_ptr)
{
int i;
struct servent *s;
return(1);
}
-int BIO_sock_error(sock)
-int sock;
+int BIO_sock_error(int sock)
{
int j,i,size;
return(j);
}
-long BIO_ghbn_ctrl(cmd,iarg,parg)
-int cmd;
-int iarg;
-char *parg;
+long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
{
int i;
char **p;
return(1);
}
-static struct hostent *ghbn_dup(a)
-struct hostent *a;
+static struct hostent *ghbn_dup(struct hostent *a)
{
struct hostent *ret;
int i,j;
return(ret);
}
-static void ghbn_free(a)
-struct hostent *a;
+static void ghbn_free(struct hostent *a)
{
int i;
Free(a);
}
-struct hostent *BIO_gethostbyname(name)
-const char *name;
+struct hostent *BIO_gethostbyname(const char *name)
{
struct hostent *ret;
int i,lowi=0,j;
return(ret);
}
-int BIO_sock_init()
+int BIO_sock_init(void)
{
#ifdef WINDOWS
static struct WSAData wsa_state;
return(1);
}
-void BIO_sock_cleanup()
+void BIO_sock_cleanup(void)
{
#ifdef WINDOWS
if (wsa_init_done)
#endif
}
-int BIO_socket_ioctl(fd,type,arg)
-int fd;
-long type;
-unsigned long *arg;
+int BIO_socket_ioctl(int fd, long type, unsigned long *arg)
{
int i;
/* The reason I have implemented this instead of using sscanf is because
* Visual C 1.52c gives an unresolved external when linking a DLL :-( */
-static int get_ip(str,ip)
-const char *str;
-unsigned char ip[4];
+static int get_ip(const char *str, unsigned char ip[4])
{
unsigned int tmp[4];
int num=0,c,ok=0;
return(1);
}
-int BIO_get_accept_socket(host,bind_mode)
-char *host;
-int bind_mode;
+int BIO_get_accept_socket(char *host, int bind_mode)
{
int ret=0;
struct sockaddr_in server,client;
return(s);
}
-int BIO_accept(sock,addr)
-int sock;
-char **addr;
+int BIO_accept(int sock, char **addr)
{
int ret=INVALID_SOCKET;
static struct sockaddr_in from;
return(ret);
}
-int BIO_set_tcp_ndelay(s,on)
-int s;
-int on;
+int BIO_set_tcp_ndelay(int s, int on)
{
int ret=0;
#if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
}
#endif
-int BIO_socket_nbio(s,mode)
-int s;
-int mode;
+int BIO_socket_nbio(int s, int mode)
{
int ret= -1;
unsigned long l;
buffer_free,
};
-BIO_METHOD *BIO_f_buffer()
+BIO_METHOD *BIO_f_buffer(void)
{
return(&methods_buffer);
}
-static int buffer_new(bi)
-BIO *bi;
+static int buffer_new(BIO *bi)
{
BIO_F_BUFFER_CTX *ctx;
return(1);
}
-static int buffer_free(a)
-BIO *a;
+static int buffer_free(BIO *a)
{
BIO_F_BUFFER_CTX *b;
return(1);
}
-static int buffer_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int buffer_read(BIO *b, char *out, int outl)
{
int i,num=0;
BIO_F_BUFFER_CTX *ctx;
goto start;
}
-static int buffer_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int buffer_write(BIO *b, char *in, int inl)
{
int i,num=0;
BIO_F_BUFFER_CTX *ctx;
goto start;
}
-static long buffer_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long buffer_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO *dbio;
BIO_F_BUFFER_CTX *ctx;
return(0);
}
-static int buffer_gets(b,buf,size)
-BIO *b;
-char *buf;
-int size;
+static int buffer_gets(BIO *b, char *buf, int size)
{
BIO_F_BUFFER_CTX *ctx;
int num=0,i,flag;
}
}
-static int buffer_puts(b,str)
-BIO *b;
-char *str;
+static int buffer_puts(BIO *b, char *str)
{
return(BIO_write(b,str,strlen(str)));
}
nbiof_free,
};
-BIO_METHOD *BIO_f_nbio_test()
+BIO_METHOD *BIO_f_nbio_test(void)
{
return(&methods_nbiof);
}
-static int nbiof_new(bi)
-BIO *bi;
+static int nbiof_new(BIO *bi)
{
NBIO_TEST *nt;
return(1);
}
-static int nbiof_free(a)
-BIO *a;
+static int nbiof_free(BIO *a)
{
if (a == NULL) return(0);
if (a->ptr != NULL)
return(1);
}
-static int nbiof_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int nbiof_read(BIO *b, char *out, int outl)
{
NBIO_TEST *nt;
int ret=0;
return(ret);
}
-static int nbiof_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int nbiof_write(BIO *b, char *in, int inl)
{
NBIO_TEST *nt;
int ret=0;
return(ret);
}
-static long nbiof_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long nbiof_ctrl(BIO *b, int cmd, long num, char *ptr)
{
long ret;
return(ret);
}
-static int nbiof_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int nbiof_gets(BIO *bp, char *buf, int size)
{
if (bp->next_bio == NULL) return(0);
return(BIO_gets(bp->next_bio,buf,size));
}
-static int nbiof_puts(bp,str)
-BIO *bp;
-char *str;
+static int nbiof_puts(BIO *bp, char *str)
{
if (bp->next_bio == NULL) return(0);
return(BIO_puts(bp->next_bio,str));
nullf_free,
};
-BIO_METHOD *BIO_f_null()
+BIO_METHOD *BIO_f_null(void)
{
return(&methods_nullf);
}
-static int nullf_new(bi)
-BIO *bi;
+static int nullf_new(BIO *bi)
{
bi->init=1;
bi->ptr=NULL;
return(1);
}
-static int nullf_free(a)
-BIO *a;
+static int nullf_free(BIO *a)
{
if (a == NULL) return(0);
/* a->ptr=NULL;
return(1);
}
-static int nullf_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int nullf_read(BIO *b, char *out, int outl)
{
int ret=0;
return(ret);
}
-static int nullf_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int nullf_write(BIO *b, char *in, int inl)
{
int ret=0;
return(ret);
}
-static long nullf_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long nullf_ctrl(BIO *b, int cmd, long num, char *ptr)
{
long ret;
return(ret);
}
-static int nullf_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int nullf_gets(BIO *bp, char *buf, int size)
{
if (bp->next_bio == NULL) return(0);
return(BIO_gets(bp->next_bio,buf,size));
}
-static int nullf_puts(bp,str)
-BIO *bp;
-char *str;
+static int nullf_puts(BIO *bp, char *str)
{
if (bp->next_bio == NULL) return(0);
return(BIO_puts(bp->next_bio,str));
#include "bio.h"
#include "err.h"
-long MS_CALLBACK BIO_debug_callback(bio,cmd,argp,argi,argl,ret)
-BIO *bio;
-int cmd;
-const char *argp;
-int argi;
-long argl;
-long ret;
+long MS_CALLBACK BIO_debug_callback(BIO *bio, int cmd, const char *argp,
+ int argi, long argl, long ret)
{
BIO *b;
MS_STATIC char buf[256];
#endif
-void ERR_load_BIO_strings()
+void ERR_load_BIO_strings(void)
{
static int init=1;
static STACK *bio_meth=NULL;
static int bio_meth_num=0;
-BIO *BIO_new(method)
-BIO_METHOD *method;
+BIO *BIO_new(BIO_METHOD *method)
{
BIO *ret=NULL;
return(ret);
}
-int BIO_set(bio,method)
-BIO *bio;
-BIO_METHOD *method;
+int BIO_set(BIO *bio, BIO_METHOD *method)
{
bio->method=method;
bio->callback=NULL;
return(1);
}
-int BIO_free(a)
-BIO *a;
+int BIO_free(BIO *a)
{
int ret=0,i;
return(1);
}
-int BIO_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+int BIO_read(BIO *b, char *out, int outl)
{
int i;
long (*cb)();
return(i);
}
-int BIO_write(b,in,inl)
-BIO *b;
-const char *in;
-int inl;
+int BIO_write(BIO *b, const char *in, int inl)
{
int i;
long (*cb)();
return(i);
}
-int BIO_puts(b,in)
-BIO *b;
-const char *in;
+int BIO_puts(BIO *b, const char *in)
{
int i;
long (*cb)();
return(i);
}
-int BIO_gets(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+int BIO_gets(BIO *b, char *in, int inl)
{
int i;
long (*cb)();
return(i);
}
-long BIO_int_ctrl(b,cmd,larg,iarg)
-BIO *b;
-int cmd;
-long larg;
-int iarg;
+long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
{
int i;
return(BIO_ctrl(b,cmd,larg,(char *)&i));
}
-char *BIO_ptr_ctrl(b,cmd,larg)
-BIO *b;
-int cmd;
-long larg;
+char *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
{
char *p=NULL;
return(p);
}
-long BIO_ctrl(b,cmd,larg,parg)
-BIO *b;
-int cmd;
-long larg;
-char *parg;
+long BIO_ctrl(BIO *b, int cmd, long larg, char *parg)
{
long ret;
long (*cb)();
}
/* put the 'bio' on the end of b's list of operators */
-BIO *BIO_push(b,bio)
-BIO *b,*bio;
+BIO *BIO_push(BIO *b, BIO *bio)
{
BIO *lb;
}
/* Remove the first and return the rest */
-BIO *BIO_pop(b)
-BIO *b;
+BIO *BIO_pop(BIO *b)
{
BIO *ret;
return(ret);
}
-BIO *BIO_get_retry_BIO(bio,reason)
-BIO *bio;
-int *reason;
+BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
{
BIO *b,*last;
return(last);
}
-int BIO_get_retry_reason(bio)
-BIO *bio;
+int BIO_get_retry_reason(BIO *bio)
{
return(bio->retry_reason);
}
-BIO *BIO_find_type(bio,type)
-BIO *bio;
-int type;
+BIO *BIO_find_type(BIO *bio, int type)
{
int mt,mask;
return(NULL);
}
-void BIO_free_all(bio)
-BIO *bio;
+void BIO_free_all(BIO *bio)
{
BIO *b;
int ref;
}
}
-BIO *BIO_dup_chain(in)
-BIO *in;
+BIO *BIO_dup_chain(BIO *in)
{
BIO *ret=NULL,*eoc=NULL,*bio,*new;
return(NULL);
}
-void BIO_copy_next_retry(b)
-BIO *b;
+void BIO_copy_next_retry(BIO *b)
{
BIO_set_flags(b,BIO_get_retry_flags(b->next_bio));
b->retry_reason=b->next_bio->retry_reason;
}
-int BIO_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
+int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
+ int (*dup_func)(), void (*free_func)())
{
bio_meth_num++;
return(CRYPTO_get_ex_new_index(bio_meth_num-1,&bio_meth,
argl,argp,new_func,dup_func,free_func));
}
-int BIO_set_ex_data(bio,idx,data)
-BIO *bio;
-int idx;
-char *data;
+int BIO_set_ex_data(BIO *bio, int idx, char *data)
{
return(CRYPTO_set_ex_data(&(bio->ex_data),idx,data));
}
-char *BIO_get_ex_data(bio,idx)
-BIO *bio;
-int idx;
+char *BIO_get_ex_data(BIO *bio, int idx)
{
return(CRYPTO_get_ex_data(&(bio->ex_data),idx));
}
acpt_free,
};
-BIO_METHOD *BIO_s_accept()
+BIO_METHOD *BIO_s_accept(void)
{
return(&methods_acceptp);
}
-static int acpt_new(bi)
-BIO *bi;
+static int acpt_new(BIO *bi)
{
BIO_ACCEPT *ba;
return(1);
}
-BIO_ACCEPT *BIO_ACCEPT_new()
+BIO_ACCEPT *BIO_ACCEPT_new(void)
{
BIO_ACCEPT *ret;
return(ret);
}
-void BIO_ACCEPT_free(a)
-BIO_ACCEPT *a;
+void BIO_ACCEPT_free(BIO_ACCEPT *a)
{
if(a == NULL)
return;
Free(a);
}
-static void acpt_close_socket(bio)
-BIO *bio;
+static void acpt_close_socket(BIO *bio)
{
BIO_ACCEPT *c;
}
}
-static int acpt_free(a)
-BIO *a;
+static int acpt_free(BIO *a)
{
BIO_ACCEPT *data;
return(1);
}
-static int acpt_state(b,c)
-BIO *b;
-BIO_ACCEPT *c;
+static int acpt_state(BIO *b, BIO_ACCEPT *c)
{
BIO *bio=NULL,*dbio;
int s= -1;
}
-static int acpt_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int acpt_read(BIO *b, char *out, int outl)
{
int ret=0;
BIO_ACCEPT *data;
return(ret);
}
-static int acpt_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int acpt_write(BIO *b, char *in, int inl)
{
int ret;
BIO_ACCEPT *data;
return(ret);
}
-static long acpt_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long acpt_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO *dbio;
int *ip;
return(ret);
}
-static int acpt_puts(bp,str)
-BIO *bp;
-char *str;
+static int acpt_puts(BIO *bp, char *str)
{
int n,ret;
return(ret);
}
-BIO *BIO_new_accept(str)
-char *str;
+BIO *BIO_new_accept(char *str)
{
BIO *ret;
conn_free,
};
-static int conn_state(b,c)
-BIO *b;
-BIO_CONNECT *c;
+static int conn_state(BIO *b, BIO_CONNECT *c)
{
int ret= -1,i;
unsigned long l;
return(ret);
}
-BIO_CONNECT *BIO_CONNECT_new()
+BIO_CONNECT *BIO_CONNECT_new(void)
{
BIO_CONNECT *ret;
return(ret);
}
-void BIO_CONNECT_free(a)
-BIO_CONNECT *a;
+void BIO_CONNECT_free(BIO_CONNECT *a)
{
if(a == NULL)
return;
Free(a);
}
-BIO_METHOD *BIO_s_connect()
+BIO_METHOD *BIO_s_connect(void)
{
return(&methods_connectp);
}
-static int conn_new(bi)
-BIO *bi;
+static int conn_new(BIO *bi)
{
bi->init=0;
bi->num=INVALID_SOCKET;
return(1);
}
-static void conn_close_socket(bio)
-BIO *bio;
+static void conn_close_socket(BIO *bio)
{
BIO_CONNECT *c;
}
}
-static int conn_free(a)
-BIO *a;
+static int conn_free(BIO *a)
{
BIO_CONNECT *data;
return(1);
}
-static int conn_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int conn_read(BIO *b, char *out, int outl)
{
int ret=0;
BIO_CONNECT *data;
return(ret);
}
-static int conn_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int conn_write(BIO *b, char *in, int inl)
{
int ret;
BIO_CONNECT *data;
return(ret);
}
-static long conn_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long conn_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO *dbio;
int *ip;
return(ret);
}
-static int conn_puts(bp,str)
-BIO *bp;
-char *str;
+static int conn_puts(BIO *bp, char *str)
{
int n,ret;
return(ret);
}
-BIO *BIO_new_connect(str)
-char *str;
+BIO *BIO_new_connect(char *str)
{
BIO *ret;
file_free,
};
-BIO *BIO_new_file(filename,mode)
-char *filename;
-char *mode;
+BIO *BIO_new_file(char *filename, char *mode)
{
BIO *ret;
FILE *file;
return(ret);
}
-BIO *BIO_new_fp(stream,close_flag)
-FILE *stream;
-int close_flag;
+BIO *BIO_new_fp(FILE *stream, int close_flag)
{
BIO *ret;
return(ret);
}
-BIO_METHOD *BIO_s_file()
+BIO_METHOD *BIO_s_file(void)
{
return(&methods_filep);
}
-static int MS_CALLBACK file_new(bi)
-BIO *bi;
+static int MS_CALLBACK file_new(BIO *bi)
{
bi->init=0;
bi->num=0;
return(1);
}
-static int MS_CALLBACK file_free(a)
-BIO *a;
+static int MS_CALLBACK file_free(BIO *a)
{
if (a == NULL) return(0);
if (a->shutdown)
return(1);
}
-static int MS_CALLBACK file_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int MS_CALLBACK file_read(BIO *b, char *out, int outl)
{
int ret=0;
return(ret);
}
-static int MS_CALLBACK file_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int MS_CALLBACK file_write(BIO *b, char *in, int inl)
{
int ret=0;
return(ret);
}
-static long MS_CALLBACK file_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, char *ptr)
{
long ret=1;
FILE *fp=(FILE *)b->ptr;
return(ret);
}
-static int MS_CALLBACK file_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int MS_CALLBACK file_gets(BIO *bp, char *buf, int size)
{
int ret=0;
return(ret);
}
-static int MS_CALLBACK file_puts(bp,str)
-BIO *bp;
-char *str;
+static int MS_CALLBACK file_puts(BIO *bp, char *str)
{
int n,ret;
slg_free,
};
-BIO_METHOD *BIO_s_log()
+BIO_METHOD *BIO_s_log(void)
{
return(&methods_slg);
}
-static int MS_CALLBACK slg_new(bi)
-BIO *bi;
+static int MS_CALLBACK slg_new(BIO *bi)
{
bi->init=1;
bi->num=0;
return(1);
}
-static int MS_CALLBACK slg_free(a)
-BIO *a;
+static int MS_CALLBACK slg_free(BIO *a)
{
if (a == NULL) return(0);
xcloselog(a);
return(1);
}
-static int MS_CALLBACK slg_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int MS_CALLBACK slg_write(BIO *b, char *in, int inl)
{
int ret= inl;
char* buf= in;
return(ret);
}
-static long MS_CALLBACK slg_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, char *ptr)
{
switch (cmd)
{
return(0);
}
-static int MS_CALLBACK slg_puts(bp,str)
-BIO *bp;
-char *str;
+static int MS_CALLBACK slg_puts(BIO *bp, char *str)
{
int n,ret;
/* bio->num is used to hold the value to return on 'empty', if it is
* 0, should_retry is not set */
-BIO_METHOD *BIO_s_mem()
+BIO_METHOD *BIO_s_mem(void)
{
return(&mem_method);
}
-static int mem_new(bi)
-BIO *bi;
+static int mem_new(BIO *bi)
{
BUF_MEM *b;
return(1);
}
-static int mem_free(a)
-BIO *a;
+static int mem_free(BIO *a)
{
if (a == NULL) return(0);
if (a->shutdown)
return(1);
}
-static int mem_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int mem_read(BIO *b, char *out, int outl)
{
int ret= -1;
BUF_MEM *bm;
return(ret);
}
-static int mem_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int mem_write(BIO *b, char *in, int inl)
{
int ret= -1;
int blen;
return(ret);
}
-static long mem_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long mem_ctrl(BIO *b, int cmd, long num, char *ptr)
{
long ret=1;
char **pptr;
return(ret);
}
-static int mem_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int mem_gets(BIO *bp, char *buf, int size)
{
int i,j;
int ret= -1;
return(ret);
}
-static int mem_puts(bp,str)
-BIO *bp;
-char *str;
+static int mem_puts(BIO *bp, char *str)
{
int n,ret;
null_free,
};
-BIO_METHOD *BIO_s_null()
+BIO_METHOD *BIO_s_null(void)
{
return(&null_method);
}
-static int null_new(bi)
-BIO *bi;
+static int null_new(BIO *bi)
{
bi->init=1;
bi->num=0;
return(1);
}
-static int null_free(a)
-BIO *a;
+static int null_free(BIO *a)
{
if (a == NULL) return(0);
return(1);
}
-static int null_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int null_read(BIO *b, char *out, int outl)
{
return(0);
}
-static int null_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int null_write(BIO *b, char *in, int inl)
{
return(inl);
}
-static long null_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long null_ctrl(BIO *b, int cmd, long num, char *ptr)
{
long ret=1;
return(ret);
}
-static int null_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int null_gets(BIO *bp, char *buf, int size)
{
return(0);
}
-static int null_puts(bp,str)
-BIO *bp;
-char *str;
+static int null_puts(BIO *bp, char *str)
{
if (str == NULL) return(0);
return(strlen(str));
rtcp_free,
};
-BIO_METHOD *BIO_s_rtcp()
+BIO_METHOD *BIO_s_rtcp(void)
{
return(&rtcp_method);
}
}
/***************************************************************************/
-static int rtcp_new(bi)
-BIO *bi;
+static int rtcp_new(BIO *bi)
{
struct rpc_ctx *ctx;
bi->init=1;
return(1);
}
-static int rtcp_free(a)
-BIO *a;
+static int rtcp_free(BIO *a)
{
if (a == NULL) return(0);
if ( a->ptr ) Free ( a->ptr );
return(1);
}
-static int rtcp_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int rtcp_read(BIO *b, char *out, int outl)
{
int status, length;
struct rpc_ctx *ctx;
return length;
}
-static int rtcp_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int rtcp_write(BIO *b, char *in, int inl)
{
int status, i, segment, length;
struct rpc_ctx *ctx;
return(i);
}
-static long rtcp_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long rtcp_ctrl(BIO *b, int cmd, long num, char *ptr)
{
long ret=1;
return(ret);
}
-static int rtcp_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int rtcp_gets(BIO *bp, char *buf, int size)
{
return(0);
}
-static int rtcp_puts(bp,str)
-BIO *bp;
-char *str;
+static int rtcp_puts(BIO *bp, char *str)
{
int length;
if (str == NULL) return(0);
sock_free,
};
-BIO_METHOD *BIO_s_socket()
+BIO_METHOD *BIO_s_socket(void)
{
return(&methods_sockp);
}
fd_free,
};
-BIO_METHOD *BIO_s_fd()
+BIO_METHOD *BIO_s_fd(void)
{
return(&methods_fdp);
}
#endif
#ifndef BIO_FD
-BIO *BIO_new_socket(fd,close_flag)
+BIO *BIO_new_socket(int fd, int close_flag)
#else
-BIO *BIO_new_fd(fd,close_flag)
+BIO *BIO_new_fd(int fd,int close_flag)
#endif
-int fd;
-int close_flag;
{
BIO *ret;
}
#ifndef BIO_FD
-static int sock_new(bi)
+static int sock_new(BIO *bi)
#else
-static int fd_new(bi)
+static int fd_new(BIO *bi)
#endif
-BIO *bi;
{
bi->init=0;
bi->num=0;
}
#ifndef BIO_FD
-static int sock_free(a)
+static int sock_free(BIO *a)
#else
-static int fd_free(a)
+static int fd_free(BIO *a)
#endif
-BIO *a;
{
if (a == NULL) return(0);
if (a->shutdown)
}
#ifndef BIO_FD
-static int sock_read(b,out,outl)
+static int sock_read(BIO *b, char *out, int outl)
#else
-static int fd_read(b,out,outl)
+static int fd_read(BIO *b, char *out,int outl)
#endif
-BIO *b;
-char *out;
-int outl;
{
int ret=0;
}
#ifndef BIO_FD
-static int sock_write(b,in,inl)
+static int sock_write(BIO *b, char *in, int inl)
#else
-static int fd_write(b,in,inl)
+static int fd_write(BIO *b, char *in, int inl)
#endif
-BIO *b;
-char *in;
-int inl;
{
int ret;
}
#ifndef BIO_FD
-static long sock_ctrl(b,cmd,num,ptr)
+static long sock_ctrl(BIO *b, int cmd, long num, char *ptr)
#else
-static long fd_ctrl(b,cmd,num,ptr)
+static long fd_ctrl(BIO *b, int cmd, long num, char *ptr)
#endif
-BIO *b;
-int cmd;
-long num;
-char *ptr;
{
long ret=1;
int *ip;
}
#ifdef undef
-static int sock_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int sock_gets(BIO *bp, char *buf,int size)
{
return(-1);
}
#endif
#ifndef BIO_FD
-static int sock_puts(bp,str)
+static int sock_puts(BIO *bp, char *str)
#else
-static int fd_puts(bp,str)
+static int fd_puts(BIO *bp, char *str)
#endif
-BIO *bp;
-char *str;
{
int n,ret;
}
#ifndef BIO_FD
-int BIO_sock_should_retry(i)
+int BIO_sock_should_retry(int i)
#else
-int BIO_fd_should_retry(i)
+int BIO_fd_should_retry(int i)
#endif
-int i;
{
int err;
}
#ifndef BIO_FD
-int BIO_sock_non_fatal_error(err)
+int BIO_sock_non_fatal_error(int err)
#else
-int BIO_fd_non_fatal_error(err)
+int BIO_fd_non_fatal_error(int err)
#endif
-int err;
{
switch (err)
{
#include "bn_lcl.h"
/* r can == a or b */
-int BN_add(r, a, b)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
+int BN_add(BIGNUM *r, BIGNUM *a, BIGNUM *b)
{
BIGNUM *tmp;
}
/* unsigned add of b to a, r must be large enough */
-int BN_uadd(r,a,b)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
+int BN_uadd(BIGNUM *r, BIGNUM *a, BIGNUM *b)
{
register int i;
int max,min;
}
/* unsigned subtraction of b from a, a must be larger than b. */
-int BN_usub(r, a, b)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
+int BN_usub(BIGNUM *r, BIGNUM *a, BIGNUM *b)
{
int max,min;
register BN_ULONG t1,t2,*ap,*bp,*rp;
return(1);
}
-int BN_sub(r, a, b)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
+int BN_sub(BIGNUM *r, BIGNUM *a, BIGNUM *b)
{
int max;
int add=0,neg=0;
#ifdef BN_LLONG
-BN_ULONG bn_mul_add_words(rp,ap,num,w)
-BN_ULONG *rp,*ap;
-int num;
-BN_ULONG w;
+BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
{
BN_ULONG c1=0;
return(c1);
}
-BN_ULONG bn_mul_words(rp,ap,num,w)
-BN_ULONG *rp,*ap;
-int num;
-BN_ULONG w;
+BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
{
BN_ULONG c1=0;
return(c1);
}
-void bn_sqr_words(r,a,n)
-BN_ULONG *r,*a;
-int n;
+void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n)
{
bn_check_num(n);
if (n <= 0) return;
#else
-BN_ULONG bn_mul_add_words(rp,ap,num,w)
-BN_ULONG *rp,*ap;
-int num;
-BN_ULONG w;
+BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
{
BN_ULONG c=0;
BN_ULONG bl,bh;
return(c);
}
-BN_ULONG bn_mul_words(rp,ap,num,w)
-BN_ULONG *rp,*ap;
-int num;
-BN_ULONG w;
+BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
{
BN_ULONG carry=0;
BN_ULONG bl,bh;
return(carry);
}
-void bn_sqr_words(r,a,n)
-BN_ULONG *r,*a;
-int n;
+void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n)
{
bn_check_num(n);
if (n <= 0) return;
#if defined(BN_LLONG) && defined(BN_DIV2W)
-BN_ULONG bn_div_words(h,l,d)
-BN_ULONG h,l,d;
+BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d)
{
return((BN_ULONG)(((((BN_ULLONG)h)<<BN_BITS2)|l)/(BN_ULLONG)d));
}
/* Divide h-l by d and return the result. */
/* I need to test this some more :-( */
-BN_ULONG bn_div_words(h,l,d)
-BN_ULONG h,l,d;
+BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d)
{
BN_ULONG dh,dl,q,ret=0,th,tl,t;
int i,count=2;
#endif
#ifdef BN_LLONG
-BN_ULONG bn_add_words(r,a,b,n)
-BN_ULONG *r,*a,*b;
-int n;
+BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
{
BN_ULLONG ll=0;
return((BN_ULONG)ll);
}
#else
-BN_ULONG bn_add_words(r,a,b,n)
-BN_ULONG *r,*a,*b;
-int n;
+BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
{
BN_ULONG c,l,t;
}
#endif
-BN_ULONG bn_sub_words(r,a,b,n)
-BN_ULONG *r,*a,*b;
-int n;
+BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
{
BN_ULONG t1,t2;
int c=0;
mul_add_c2((a)[i],(a)[j],c0,c1,c2)
#endif
-void bn_mul_comba8(r,a,b)
-BN_ULONG *r,*a,*b;
+void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
{
#ifdef BN_LLONG
BN_ULLONG t;
r[15]=c1;
}
-void bn_mul_comba4(r,a,b)
-BN_ULONG *r,*a,*b;
+void bn_mul_comba4(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
{
#ifdef BN_LLONG
BN_ULLONG t;
r[7]=c2;
}
-void bn_sqr_comba8(r,a)
-BN_ULONG *r,*a;
+void bn_sqr_comba8(BN_ULONG *r, BN_ULONG *a)
{
#ifdef BN_LLONG
BN_ULLONG t,tt;
r[15]=c1;
}
-void bn_sqr_comba4(r,a)
-BN_ULONG *r,*a;
+void bn_sqr_comba4(BN_ULONG *r, BN_ULONG *a)
{
#ifdef BN_LLONG
BN_ULLONG t,tt;
/* hmm... is it faster just to do a multiply? */
#undef bn_sqr_comba4
-void bn_sqr_comba4(r,a)
-BN_ULONG *r,*a;
+void bn_sqr_comba4(BN_ULONG *r, BN_ULONG *a)
{
BN_ULONG t[8];
bn_sqr_normal(r,a,4,t);
}
#undef bn_sqr_comba8
-void bn_sqr_comba8(r,a)
-BN_ULONG *r,*a;
+void bn_sqr_comba8(BN_ULONG *r, BN_ULONG *a)
{
BN_ULONG t[16];
bn_sqr_normal(r,a,8,t);
}
-void bn_mul_comba4(r,a,b)
-BN_ULONG *r,*a,*b;
+void bn_mul_comba4(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
{
r[4]=bn_mul_words( &(r[0]),a,4,b[0]);
r[5]=bn_mul_add_words(&(r[1]),a,4,b[1]);
r[7]=bn_mul_add_words(&(r[3]),a,4,b[3]);
}
-void bn_mul_comba8(r,a,b)
-BN_ULONG *r,*a,*b;
+void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
{
r[ 8]=bn_mul_words( &(r[0]),a,8,b[0]);
r[ 9]=bn_mul_add_words(&(r[1]),a,8,b[1]);
#include "cryptlib.h"
#include "bn_lcl.h"
-BN_BLINDING *BN_BLINDING_new(A,Ai,mod)
-BIGNUM *A;
-BIGNUM *Ai;
-BIGNUM *mod;
+BN_BLINDING *BN_BLINDING_new(BIGNUM *A, BIGNUM *Ai, BIGNUM *mod)
{
BN_BLINDING *ret=NULL;
return(NULL);
}
-void BN_BLINDING_free(r)
-BN_BLINDING *r;
+void BN_BLINDING_free(BN_BLINDING *r)
{
if(r == NULL)
return;
Free(r);
}
-int BN_BLINDING_update(b,ctx)
-BN_BLINDING *b;
-BN_CTX *ctx;
+int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
{
int ret=0;
return(ret);
}
-int BN_BLINDING_convert(n,b,ctx)
-BIGNUM *n;
-BN_BLINDING *b;
-BN_CTX *ctx;
+int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
{
bn_check_top(n);
return(BN_mod_mul(n,n,b->A,b->mod,ctx));
}
-int BN_BLINDING_invert(n,b,ctx)
-BIGNUM *n;
-BN_BLINDING *b;
-BN_CTX *ctx;
+int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
{
int ret;
void bn_sqr_comba88(BN_ULONG *r,BN_ULONG *a);
void bn_sqr_comba44(BN_ULONG *r,BN_ULONG *a);
-void bn_mul_comba88(r,a,b)
-BN_ULONG *r,*a,*b;
+void bn_mul_comba88(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
{
#ifdef BN_LLONG
BN_ULLONG t;
r[15]=c1;
}
-void bn_mul_comba44(r,a,b)
-BN_ULONG *r,*a,*b;
+void bn_mul_comba44(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
{
#ifdef BN_LLONG
BN_ULLONG t;
r[7]=c2;
}
-void bn_sqr_comba88(r,a)
-BN_ULONG *r,*a;
+void bn_sqr_comba88(BN_ULONG *r, BN_ULONG *a)
{
#ifdef BN_LLONG
BN_ULLONG t,tt;
r[15]=c1;
}
-void bn_sqr_comba44(r,a)
-BN_ULONG *r,*a;
+void bn_sqr_comba44(BN_ULONG *r, BN_ULONG *a)
{
#ifdef BN_LLONG
BN_ULLONG t,tt;
/* The old slow way */
#if 0
-int BN_div(dv, rem, m, d,ctx)
-BIGNUM *dv;
-BIGNUM *rem;
-BIGNUM *m;
-BIGNUM *d;
-BN_CTX *ctx;
+int BN_div(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx)
{
int i,nm,nd;
BIGNUM *D;
#else
-int BN_div(dv, rm, num, divisor,ctx)
-BIGNUM *dv;
-BIGNUM *rm;
-BIGNUM *num;
-BIGNUM *divisor;
-BN_CTX *ctx;
+int BN_div(BIGNUM *dv, BIGNUM *rm, BIGNUM *num, BIGNUM *divisor,
+ BN_CTX *ctx)
{
int norm_shift,i,j,loop;
BIGNUM *tmp,wnum,*snum,*sdiv,*res;
#endif
/* rem != m */
-int BN_mod(rem, m, d,ctx)
-BIGNUM *rem;
-BIGNUM *m;
-BIGNUM *d;
-BN_CTX *ctx;
+int BN_mod(BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx)
{
#if 0 /* The old slow way */
int i,nm,nd;
#endif
-void ERR_load_BN_strings()
+void ERR_load_BN_strings(void)
{
static int init=1;
#define TABLE_SIZE 16
/* slow but works */
-int BN_mod_mul(ret, a, b, m, ctx)
-BIGNUM *ret;
-BIGNUM *a;
-BIGNUM *b;
-BIGNUM *m;
-BN_CTX *ctx;
+int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, BIGNUM *m, BN_CTX *ctx)
{
BIGNUM *t;
int r=0;
#if 0
/* this one works - simple but works */
-int BN_mod_exp(r,a,p,m,ctx)
-BIGNUM *r,*a,*p,*m;
-BN_CTX *ctx;
+int BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx)
{
int i,bits,ret=0;
BIGNUM *v,*tmp;
#endif
/* this one works - simple but works */
-int BN_exp(r,a,p,ctx)
-BIGNUM *r,*a,*p;
-BN_CTX *ctx;
+int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx)
{
int i,bits,ret=0,tos;
BIGNUM *v,*rr;
return(ret);
}
-int BN_mod_exp(r,a,p,m,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
+int BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx)
{
int ret;
}
/* #ifdef RECP_MUL_MOD */
-int BN_mod_exp_recp(r,a,p,m,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
+int BN_mod_exp_recp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx)
{
int i,j,bits,ret=0,wstart,wend,window,wvalue;
int start=1,ts=0;
/* #endif */
/* #ifdef MONT_MUL_MOD */
-int BN_mod_exp_mont(rr,a,p,m,ctx,in_mont)
-BIGNUM *rr;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
-BN_MONT_CTX *in_mont;
+int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx,
+ BN_MONT_CTX *in_mont)
{
int i,j,bits,ret=0,wstart,wend,window,wvalue;
int start=1,ts=0;
/* #endif */
/* The old fallback, simple version :-) */
-int BN_mod_exp_simple(r,a,p,m,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *p;
-BIGNUM *m;
-BN_CTX *ctx;
+int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
+ BN_CTX *ctx)
{
int i,j,bits,ret=0,wstart,wend,window,wvalue,ts=0;
int start=1;
#define EXP2_TABLE_BITS 2 /* 1 2 3 4 5 */
#define EXP2_TABLE_SIZE 4 /* 2 4 8 16 32 */
-int BN_mod_exp2_mont(rr,a1,p1,a2,p2,m,ctx,in_mont)
-BIGNUM *rr;
-BIGNUM *a1;
-BIGNUM *p1;
-BIGNUM *a2;
-BIGNUM *p2;
-BIGNUM *m;
-BN_CTX *ctx;
-BN_MONT_CTX *in_mont;
+int BN_mod_exp2_mont(BIGNUM *rr, BIGNUM *a1, BIGNUM *p1, BIGNUM *a2,
+ BIGNUM *p2, BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *in_mont)
{
int i,j,k,bits,bits1,bits2,ret=0,wstart,wend,window,xvalue,yvalue;
int start=1,ts=0,x,y;
static BIGNUM *euclid();
#endif
-int BN_gcd(r,in_a,in_b,ctx)
-BIGNUM *r,*in_a,*in_b;
-BN_CTX *ctx;
+int BN_gcd(BIGNUM *r, BIGNUM *in_a, BIGNUM *in_b, BN_CTX *ctx)
{
BIGNUM *a,*b,*t;
int ret=0;
return(ret);
}
-static BIGNUM *euclid(a,b)
-BIGNUM *a,*b;
+static BIGNUM *euclid(BIGNUM *a, BIGNUM *b)
{
BIGNUM *t;
int shifts=0;
}
/* solves ax == 1 (mod n) */
-BIGNUM *BN_mod_inverse(in, a, n, ctx)
-BIGNUM *in;
-BIGNUM *a;
-BIGNUM *n;
-BN_CTX *ctx;
+BIGNUM *BN_mod_inverse(BIGNUM *in, BIGNUM *a, BIGNUM *n, BN_CTX *ctx)
{
BIGNUM *A,*B,*X,*Y,*M,*D,*R;
BIGNUM *T,*ret=NULL;
int bn_limit_bits_mont=0;
int bn_limit_num_mont=8; /* (1<<bn_limit_bits_mont) */
-void BN_set_params(mult,high,low,mont)
-int mult,high,low,mont;
+void BN_set_params(int mult, int high, int low, int mont)
{
if (mult >= 0)
{
}
}
-int BN_get_params(which)
-int which;
+int BN_get_params(int which)
{
if (which == 0) return(bn_limit_bits);
else if (which == 1) return(bn_limit_bits_high);
else return(0);
}
-BIGNUM *BN_value_one()
+BIGNUM *BN_value_one(void)
{
static BN_ULONG data_one=1L;
static BIGNUM const_one={&data_one,1,1,0};
return(&const_one);
}
-char *BN_options()
+char *BN_options(void)
{
static int init=0;
static char data[16];
return(data);
}
-int BN_num_bits_word(l)
-BN_ULONG l;
+int BN_num_bits_word(BN_ULONG l)
{
static char bits[256]={
0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,
}
}
-int BN_num_bits(a)
-BIGNUM *a;
+int BN_num_bits(BIGNUM *a)
{
BN_ULONG l;
int i;
return(i+BN_num_bits_word(l));
}
-void BN_clear_free(a)
-BIGNUM *a;
+void BN_clear_free(BIGNUM *a)
{
int i;
Free(a);
}
-void BN_free(a)
-BIGNUM *a;
+void BN_free(BIGNUM *a)
{
if (a == NULL) return;
if ((a->d != NULL) && !(BN_get_flags(a,BN_FLG_STATIC_DATA)))
Free(a);
}
-void BN_init(a)
-BIGNUM *a;
+void BN_init(BIGNUM *a)
{
memset(a,0,sizeof(BIGNUM));
}
-BIGNUM *BN_new()
+BIGNUM *BN_new(void)
{
BIGNUM *ret;
}
-BN_CTX *BN_CTX_new()
+BN_CTX *BN_CTX_new(void)
{
BN_CTX *ret;
return(ret);
}
-void BN_CTX_init(ctx)
-BN_CTX *ctx;
+void BN_CTX_init(BN_CTX *ctx)
{
memset(ctx,0,sizeof(BN_CTX));
ctx->tos=0;
ctx->flags=0;
}
-void BN_CTX_free(c)
-BN_CTX *c;
+void BN_CTX_free(BN_CTX *c)
{
int i;
Free(c);
}
-BIGNUM *bn_expand2(b, words)
-BIGNUM *b;
-int words;
+BIGNUM *bn_expand2(BIGNUM *b, int words)
{
BN_ULONG *A,*B,*a;
int i,j;
return(b);
}
-BIGNUM *BN_dup(a)
-BIGNUM *a;
+BIGNUM *BN_dup(BIGNUM *a)
{
BIGNUM *r;
return((BIGNUM *)BN_copy(r,a));
}
-BIGNUM *BN_copy(a, b)
-BIGNUM *a;
-BIGNUM *b;
+BIGNUM *BN_copy(BIGNUM *a, BIGNUM *b)
{
int i;
BN_ULONG *A,*B;
return(a);
}
-void BN_clear(a)
-BIGNUM *a;
+void BN_clear(BIGNUM *a)
{
if (a->d != NULL)
memset(a->d,0,a->max*sizeof(a->d[0]));
a->neg=0;
}
-BN_ULONG BN_get_word(a)
-BIGNUM *a;
+BN_ULONG BN_get_word(BIGNUM *a)
{
int i,n;
BN_ULONG ret=0;
return(ret);
}
-int BN_set_word(a,w)
-BIGNUM *a;
-BN_ULONG w;
+int BN_set_word(BIGNUM *a, BN_ULONG w)
{
int i,n;
if (bn_expand(a,sizeof(BN_ULONG)*8) == NULL) return(0);
}
/* ignore negative */
-BIGNUM *BN_bin2bn(s, len, ret)
-unsigned char *s;
-int len;
-BIGNUM *ret;
+BIGNUM *BN_bin2bn(unsigned char *s, int len, BIGNUM *ret)
{
unsigned int i,m;
unsigned int n;
}
/* ignore negative */
-int BN_bn2bin(a, to)
-BIGNUM *a;
-unsigned char *to;
+int BN_bn2bin(BIGNUM *a, unsigned char *to)
{
int n,i;
BN_ULONG l;
return(n);
}
-int BN_ucmp(a, b)
-BIGNUM *a;
-BIGNUM *b;
+int BN_ucmp(BIGNUM *a, BIGNUM *b)
{
int i;
BN_ULONG t1,t2,*ap,*bp;
return(0);
}
-int BN_cmp(a, b)
-BIGNUM *a;
-BIGNUM *b;
+int BN_cmp(BIGNUM *a, BIGNUM *b)
{
int i;
int gt,lt;
return(0);
}
-int BN_set_bit(a, n)
-BIGNUM *a;
-int n;
+int BN_set_bit(BIGNUM *a, int n)
{
int i,j,k;
return(1);
}
-int BN_clear_bit(a, n)
-BIGNUM *a;
-int n;
+int BN_clear_bit(BIGNUM *a, int n)
{
int i,j;
return(1);
}
-int BN_is_bit_set(a, n)
-BIGNUM *a;
-int n;
+int BN_is_bit_set(BIGNUM *a, int n)
{
int i,j;
return((a->d[i]&(((BN_ULONG)1)<<j))?1:0);
}
-int BN_mask_bits(a,n)
-BIGNUM *a;
-int n;
+int BN_mask_bits(BIGNUM *a, int n)
{
int b,w;
return(1);
}
-int bn_cmp_words(a,b,n)
-BN_ULONG *a,*b;
-int n;
+int bn_cmp_words(BN_ULONG *a, BN_ULONG *b, int n)
{
int i;
BN_ULONG aa,bb;
STACK *sk;
} BN_POOL;
-BIGNUM *BN_POOL_push(bp)
-BN_POOL *bp;
+BIGNUM *BN_POOL_push(BN_POOL *bp)
{
BIGNUM *ret;
return(ret);
}
-void BN_POOL_pop(bp,num)
-BN_POOL *bp;
-int num;
+void BN_POOL_pop(BN_POOL *bp, int num)
{
bp->used-=num;
}
-int BN_m(r,a,b)
-BIGNUM *r,*a,*b;
+int BN_m(BIGNUM *r, BIGNUM *a, BIGNUM *b)
{
static BN_POOL bp;
static init=1;
}
/* r must be different to a and b */
-int BN_mm(m, A, B, bp)
-BIGNUM *m,*A,*B;
-BN_POOL *bp;
+int BN_mm(BIGNUM *m, BIGNUM *A, BIGNUM *B, BN_POOL *bp)
{
int i,num;
int an,bn;
#define MONT_WORD
-int BN_mod_mul_montgomery(r,a,b,mont,ctx)
-BIGNUM *r,*a,*b;
-BN_MONT_CTX *mont;
-BN_CTX *ctx;
+int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_MONT_CTX *mont,
+ BN_CTX *ctx)
{
BIGNUM *tmp,*tmp2;
return(0);
}
-int BN_from_montgomery(ret,a,mont,ctx)
-BIGNUM *ret;
-BIGNUM *a;
-BN_MONT_CTX *mont;
-BN_CTX *ctx;
+int BN_from_montgomery(BIGNUM *ret, BIGNUM *a, BN_MONT_CTX *mont,
+ BN_CTX *ctx)
{
#ifdef BN_RECURSION_MONT
if (mont->use_word)
#endif
}
-BN_MONT_CTX *BN_MONT_CTX_new()
+BN_MONT_CTX *BN_MONT_CTX_new(void)
{
BN_MONT_CTX *ret;
return(ret);
}
-void BN_MONT_CTX_init(ctx)
-BN_MONT_CTX *ctx;
+void BN_MONT_CTX_init(BN_MONT_CTX *ctx)
{
ctx->use_word=0;
ctx->ri=0;
ctx->flags=0;
}
-void BN_MONT_CTX_free(mont)
-BN_MONT_CTX *mont;
+void BN_MONT_CTX_free(BN_MONT_CTX *mont)
{
if(mont == NULL)
return;
Free(mont);
}
-int BN_MONT_CTX_set(mont,mod,ctx)
-BN_MONT_CTX *mont;
-BIGNUM *mod;
-BN_CTX *ctx;
+int BN_MONT_CTX_set(BN_MONT_CTX *mont, BIGNUM *mod, BN_CTX *ctx)
{
BIGNUM Ri,*R;
return(0);
}
-BN_MONT_CTX *BN_MONT_CTX_copy(to, from)
-BN_MONT_CTX *to, *from;
+BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from)
{
if (to == from) return(to);
#include "cryptlib.h"
#include "bn_lcl.h"
-int BN_bn2mpi(a,d)
-BIGNUM *a;
-unsigned char *d;
+int BN_bn2mpi(BIGNUM *a, unsigned char *d)
{
int bits;
int num=0;
return(num+4+ext);
}
-BIGNUM *BN_mpi2bn(d,n,a)
-unsigned char *d;
-int n;
-BIGNUM *a;
+BIGNUM *BN_mpi2bn(unsigned char *d, int n, BIGNUM *a)
{
long len;
int neg=0;
* a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
* a[1]*b[1]
*/
-void bn_mul_recursive(r,a,b,n2,t)
-BN_ULONG *r,*a,*b;
-int n2;
-BN_ULONG *t;
+void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
+ BN_ULONG *t)
{
int n=n2/2,c1,c2;
unsigned int neg,zero;
/* n+tn is the word length
* t needs to be n*4 is size, as does r */
-void bn_mul_part_recursive(r,a,b,tn,n,t)
-BN_ULONG *r,*a,*b;
-int tn,n;
-BN_ULONG *t;
+void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
+ int n, BN_ULONG *t)
{
int i,j,n2=n*2;
unsigned int c1;
/* a and b must be the same size, which is n2.
* r needs to be n2 words and t needs to be n2*2
*/
-void bn_mul_low_recursive(r,a,b,n2,t)
-BN_ULONG *r,*a,*b;
-int n2;
-BN_ULONG *t;
+void bn_mul_low_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
+ BN_ULONG *t)
{
int n=n2/2;
* l is the low words of the output.
* t needs to be n2*3
*/
-void bn_mul_high(r,a,b,l,n2,t)
-BN_ULONG *r,*a,*b,*l;
-int n2;
-BN_ULONG *t;
+void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l, int n2,
+ BN_ULONG *t)
{
int i,n;
int c1,c2;
}
#endif
-int BN_mul(r,a,b,ctx)
-BIGNUM *r,*a,*b;
-BN_CTX *ctx;
+int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
{
int top,al,bl;
BIGNUM *rr;
return(1);
}
-void bn_mul_normal(r,a,na,b,nb)
-BN_ULONG *r,*a;
-int na;
-BN_ULONG *b;
-int nb;
+void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
{
BN_ULONG *rr;
}
}
-void bn_mul_low_normal(r,a,b,n)
-BN_ULONG *r,*a,*b;
-int n;
+void bn_mul_low_normal(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
{
#ifdef BN_COUNT
printf(" bn_mul_low_normal %d * %d\n",n,n);
#define P_MULH 5
#define P_MRED 6
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
PARMS p;
BN_MONT_CTX *mont;
do_it(num,&p);
}
-void do_it(num,p)
-int num;
-PARMS *p;
+void do_it(int num, PARMS *p)
{
char *start,*end;
int i,j,number;
}
}
-int time_it(sec,p)
-int sec;
-PARMS *p;
+int time_it(int sec, PARMS *p)
{
char *start,*end;
int i,j;
return(i);
}
-void do_mul_exp(num,p)
-int num;
-PARMS *p;
+void do_mul_exp(int num, PARMS *p)
{
int i;
p->ctx,p->mont);
}
-void do_mul(num,p)
-int num;
-PARMS *p;
+void do_mul(int num, PARMS *p)
{
int i;
BN_mul(&(p->r),&(p->a),&(p->b),p->ctx);
}
-void do_sqr(num,p)
-int num;
-PARMS *p;
+void do_sqr(int num, PARMS *p)
{
int i;
BN_sqr(&(p->r),&(p->a),p->ctx);
}
-void do_mul_low(num,p)
-int num;
-PARMS *p;
+void do_mul_low(int num, PARMS *p)
{
int i;
BN_mul_low(&(p->r),&(p->a),&(p->b),p->w,p->ctx);
}
-void do_mul_high(num,p)
-int num;
-PARMS *p;
+void do_mul_high(int num, PARMS *p)
{
int i;
BN_mul_low(&(p->r),&(p->a),&(p->b),&(p->low),p->w,p->ctx);
}
-void do_from_montgomery(num,p)
-int num;
-PARMS *p;
+void do_from_montgomery(int num, PARMS *p)
{
int i;
static int probable_prime_dh_strong();
#endif
-BIGNUM *BN_generate_prime(ret,bits,strong,add,rem,callback,cb_arg)
-BIGNUM *ret;
-int bits;
-int strong;
-BIGNUM *add;
-BIGNUM *rem;
-void (*callback)(P_I_I_P);
-char *cb_arg;
+BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int strong, BIGNUM *add,
+ BIGNUM *rem, void (*callback)(P_I_I_P), char *cb_arg)
{
BIGNUM *rnd=NULL;
BIGNUM t;
return(ret);
}
-int BN_is_prime(a,checks,callback,ctx_passed,cb_arg)
-BIGNUM *a;
-int checks;
-void (*callback)(P_I_I_P);
-BN_CTX *ctx_passed;
-char *cb_arg;
+int BN_is_prime(BIGNUM *a, int checks, void (*callback)(P_I_I_P),
+ BN_CTX *ctx_passed, char *cb_arg)
{
int i,j,c2=0,ret= -1;
BIGNUM *check;
#define RECP_MUL_MOD
-static int witness(a,n,ctx,ctx2,mont)
-BIGNUM *a;
-BIGNUM *n;
-BN_CTX *ctx,*ctx2;
-BN_MONT_CTX *mont;
+static int witness(BIGNUM *a, BIGNUM *n, BN_CTX *ctx, BN_CTX *ctx2,
+ BN_MONT_CTX *mont)
{
int k,i,ret= -1,good;
BIGNUM *d,*dd,*tmp,*d1,*d2,*n1;
return(ret);
}
-static int probable_prime(rnd, bits)
-BIGNUM *rnd;
-int bits;
+static int probable_prime(BIGNUM *rnd, int bits)
{
int i;
MS_STATIC BN_ULONG mods[NUMPRIMES];
return(1);
}
-static int probable_prime_dh(rnd, bits, add, rem,ctx)
-BIGNUM *rnd;
-int bits;
-BIGNUM *add;
-BIGNUM *rem;
-BN_CTX *ctx;
+static int probable_prime_dh(BIGNUM *rnd, int bits, BIGNUM *add, BIGNUM *rem,
+ BN_CTX *ctx)
{
int i,ret=0;
BIGNUM *t1;
return(ret);
}
-static int probable_prime_dh_strong(p, bits, padd, rem,ctx)
-BIGNUM *p;
-int bits;
-BIGNUM *padd;
-BIGNUM *rem;
-BN_CTX *ctx;
+static int probable_prime_dh_strong(BIGNUM *p, int bits, BIGNUM *padd,
+ BIGNUM *rem, BN_CTX *ctx)
{
int i,ret=0;
BIGNUM *t1,*qadd=NULL,*q=NULL;
}
#if 0
-static int witness(a, n,ctx)
-BIGNUM *a;
-BIGNUM *n;
-BN_CTX *ctx;
+static int witness(BIGNUM *a, BIGNUM *n, BN_CTX *ctx)
{
int k,i,nb,ret= -1;
BIGNUM *d,*dd,*tmp;
const static char *Hex="0123456789ABCDEF";
/* Must 'Free' the returned data */
-char *BN_bn2hex(a)
-BIGNUM *a;
+char *BN_bn2hex(BIGNUM *a)
{
int i,j,v,z=0;
char *buf;
}
/* Must 'Free' the returned data */
-char *BN_bn2dec(a)
-BIGNUM *a;
+char *BN_bn2dec(BIGNUM *a)
{
int i=0,num;
char *buf=NULL;
return(buf);
}
-int BN_hex2bn(bn,a)
-BIGNUM **bn;
-char *a;
+int BN_hex2bn(BIGNUM **bn, char *a)
{
BIGNUM *ret=NULL;
BN_ULONG l=0;
return(0);
}
-int BN_dec2bn(bn,a)
-BIGNUM **bn;
-char *a;
+int BN_dec2bn(BIGNUM **bn, char *a)
{
BIGNUM *ret=NULL;
BN_ULONG l=0;
#ifndef NO_BIO
#ifndef NO_FP_API
-int BN_print_fp(fp, a)
-FILE *fp;
-BIGNUM *a;
+int BN_print_fp(FILE *fp, BIGNUM *a)
{
BIO *b;
int ret;
}
#endif
-int BN_print(bp, a)
-BIO *bp;
-BIGNUM *a;
+int BN_print(BIO *bp, BIGNUM *a)
{
int i,j,v,z=0;
int ret=0;
#include "bn_lcl.h"
#include "rand.h"
-int BN_rand(rnd, bits, top, bottom)
-BIGNUM *rnd;
-int bits;
-int top;
-int bottom;
+int BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
{
unsigned char *buf=NULL;
int ret=0,bit,bytes,mask;
#include "cryptlib.h"
#include "bn_lcl.h"
-void BN_RECP_CTX_init(recp)
-BN_RECP_CTX *recp;
+void BN_RECP_CTX_init(BN_RECP_CTX *recp)
{
BN_init(&(recp->N));
BN_init(&(recp->Nr));
recp->flags=0;
}
-BN_RECP_CTX *BN_RECP_CTX_new()
+BN_RECP_CTX *BN_RECP_CTX_new(void)
{
BN_RECP_CTX *ret;
return(ret);
}
-void BN_RECP_CTX_free(recp)
-BN_RECP_CTX *recp;
+void BN_RECP_CTX_free(BN_RECP_CTX *recp)
{
if(recp == NULL)
return;
Free(recp);
}
-int BN_RECP_CTX_set(recp,d,ctx)
-BN_RECP_CTX *recp;
-BIGNUM *d;
-BN_CTX *ctx;
+int BN_RECP_CTX_set(BN_RECP_CTX *recp, BIGNUM *d, BN_CTX *ctx)
{
BN_copy(&(recp->N),d);
BN_zero(&(recp->Nr));
return(1);
}
-int BN_mod_mul_reciprocal(r, x, y, recp, ctx)
-BIGNUM *r;
-BIGNUM *x;
-BIGNUM *y;
-BN_RECP_CTX *recp;
-BN_CTX *ctx;
+int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *x, BIGNUM *y, BN_RECP_CTX *recp,
+ BN_CTX *ctx)
{
int ret=0;
BIGNUM *a;
return(ret);
}
-int BN_div_recp(dv,rem,m,recp,ctx)
-BIGNUM *dv;
-BIGNUM *rem;
-BIGNUM *m;
-BN_RECP_CTX *recp;
-BN_CTX *ctx;
+int BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BN_RECP_CTX *recp,
+ BN_CTX *ctx)
{
int i,j,tos,ret=0,ex;
BIGNUM *a,*b,*d,*r;
* We actually calculate with an extra word of precision, so
* we can do faster division if the remainder is not required.
*/
-int BN_reciprocal(r,m,len,ctx)
-BIGNUM *r;
-BIGNUM *m;
-int len;
-BN_CTX *ctx;
+int BN_reciprocal(BIGNUM *r, BIGNUM *m, int len, BN_CTX *ctx)
{
int ret= -1;
BIGNUM t;
#include "cryptlib.h"
#include "bn_lcl.h"
-int BN_lshift1(r, a)
-BIGNUM *r;
-BIGNUM *a;
+int BN_lshift1(BIGNUM *r, BIGNUM *a)
{
register BN_ULONG *ap,*rp,t,c;
int i;
return(1);
}
-int BN_rshift1(r, a)
-BIGNUM *r;
-BIGNUM *a;
+int BN_rshift1(BIGNUM *r, BIGNUM *a)
{
BN_ULONG *ap,*rp,t,c;
int i;
return(1);
}
-int BN_lshift(r, a, n)
-BIGNUM *r;
-BIGNUM *a;
-int n;
+int BN_lshift(BIGNUM *r, BIGNUM *a, int n)
{
int i,nw,lb,rb;
BN_ULONG *t,*f;
return(1);
}
-int BN_rshift(r, a, n)
-BIGNUM *r;
-BIGNUM *a;
-int n;
+int BN_rshift(BIGNUM *r, BIGNUM *a, int n)
{
int i,j,nw,lb,rb;
BN_ULONG *t,*f;
/* r must not be a */
/* I've just gone over this and it is now %20 faster on x86 - eay - 27 Jun 96 */
-int BN_sqr(r, a, ctx)
-BIGNUM *r;
-BIGNUM *a;
-BN_CTX *ctx;
+int BN_sqr(BIGNUM *r, BIGNUM *a, BN_CTX *ctx)
{
int max,al;
BIGNUM *tmp,*rr;
}
/* tmp must have 2*n words */
-void bn_sqr_normal(r, a, n, tmp)
-BN_ULONG *r;
-BN_ULONG *a;
-int n;
-BN_ULONG *tmp;
+void bn_sqr_normal(BN_ULONG *r, BN_ULONG *a, int n, BN_ULONG *tmp)
{
int i,j,max;
BN_ULONG *ap,*rp;
* a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
* a[1]*b[1]
*/
-void bn_sqr_recursive(r,a,n2,t)
-BN_ULONG *r,*a;
-int n2;
-BN_ULONG *t;
+void bn_sqr_recursive(BN_ULONG *r, BN_ULONG *a, int n2, BN_ULONG *t)
{
int n=n2/2;
int zero,c1;
#include "cryptlib.h"
#include "bn_lcl.h"
-BN_ULONG BN_mod_word(a, w)
-BIGNUM *a;
-BN_ULONG w;
+BN_ULONG BN_mod_word(BIGNUM *a, BN_ULONG w)
{
#ifndef BN_LLONG
BN_ULONG ret=0;
return((BN_ULONG)ret);
}
-BN_ULONG BN_div_word(a, w)
-BIGNUM *a;
-BN_ULONG w;
+BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w)
{
BN_ULONG ret;
int i;
return(ret);
}
-int BN_add_word(a, w)
-BIGNUM *a;
-BN_ULONG w;
+int BN_add_word(BIGNUM *a, BN_ULONG w)
{
BN_ULONG l;
int i;
return(1);
}
-int BN_sub_word(a, w)
-BIGNUM *a;
-BN_ULONG w;
+int BN_sub_word(BIGNUM *a, BN_ULONG w)
{
int i;
return(1);
}
-int BN_mul_word(a,w)
-BIGNUM *a;
-BN_ULONG w;
+int BN_mul_word(BIGNUM *a, BN_ULONG w)
{
BN_ULONG ll;
#define START 0
#define STOP 1
-static double Time_F(s)
-int s;
+static double Time_F(int s)
{
double ret;
#ifdef TIMES
void do_mul(BIGNUM *r,BIGNUM *a,BIGNUM *b,BN_CTX *ctx);
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
BN_CTX *ctx;
BIGNUM a,b,c;
do_mul(&a,&b,&c,ctx);
}
-void do_mul(r,a,b,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
-BN_CTX *ctx;
+void do_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
{
int i,j,k;
double tm;
#include "bss_file.c"
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
BN_CTX *ctx;
BIO *out;
return(1);
}
-int test_add(bp)
-BIO *bp;
+int test_add(BIO *bp)
{
BIGNUM a,b,c;
int i;
return(1);
}
-int test_sub(bp)
-BIO *bp;
+int test_sub(BIO *bp)
{
BIGNUM a,b,c;
int i;
return(1);
}
-int test_div(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_div(BIO *bp, BN_CTX *ctx)
{
BIGNUM a,b,c,d;
int i;
return(1);
}
-int test_div_recp(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_div_recp(BIO *bp, BN_CTX *ctx)
{
BIGNUM a,b,c,d;
BN_RECP_CTX recp;
return(1);
}
-int test_mul(bp)
-BIO *bp;
+int test_mul(BIO *bp)
{
BIGNUM a,b,c;
int i;
return(1);
}
-int test_sqr(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_sqr(BIO *bp, BN_CTX *ctx)
{
BIGNUM a,c;
int i;
return(1);
}
-int test_mont(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_mont(BIO *bp, BN_CTX *ctx)
{
BIGNUM a,b,c,A,B;
BIGNUM n;
return(1);
}
-int test_mod(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_mod(BIO *bp, BN_CTX *ctx)
{
BIGNUM *a,*b,*c;
int i;
return(1);
}
-int test_mod_mul(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_mod_mul(BIO *bp, BN_CTX *ctx)
{
BIGNUM *a,*b,*c,*d,*e;
int i;
return(1);
}
-int test_mod_exp(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_mod_exp(BIO *bp, BN_CTX *ctx)
{
BIGNUM *a,*b,*c,*d,*e;
int i;
return(1);
}
-int test_exp(bp,ctx)
-BIO *bp;
-BN_CTX *ctx;
+int test_exp(BIO *bp, BN_CTX *ctx)
{
BIGNUM *a,*b,*d,*e;
int i;
return(1);
}
-int test_lshift(bp)
-BIO *bp;
+int test_lshift(BIO *bp)
{
BIGNUM *a,*b,*c;
int i;
return(1);
}
-int test_lshift1(bp)
-BIO *bp;
+int test_lshift1(BIO *bp)
{
BIGNUM *a,*b;
int i;
return(1);
}
-int test_rshift(bp)
-BIO *bp;
+int test_rshift(BIO *bp)
{
BIGNUM *a,*b,*c;
int i;
return(1);
}
-int test_rshift1(bp)
-BIO *bp;
+int test_rshift1(BIO *bp)
{
BIGNUM *a,*b;
int i;
return(1);
}
-int rand_neg()
+int rand_neg(void)
{
static unsigned int neg=0;
static int sign[8]={0,0,0,1,1,0,1,1};
#define START 0
#define STOP 1
-static double Time_F(s)
-int s;
+static double Time_F(int s)
{
double ret;
#ifdef TIMES
void do_mul_exp(BIGNUM *r,BIGNUM *a,BIGNUM *b,BIGNUM *c,BN_CTX *ctx);
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
BN_CTX *ctx;
BIGNUM *a,*b,*c,*r;
do_mul_exp(r,a,b,c,ctx);
}
-void do_mul_exp(r,a,b,c,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
-BIGNUM *c;
-BN_CTX *ctx;
+void do_mul_exp(BIGNUM *r, BIGNUM *a, BIGNUM *b, BIGNUM *c, BN_CTX *ctx)
{
int i,k;
double tm;
#define NUM_BITS (BN_BITS*2)
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
BN_CTX *ctx;
BIO *out=NULL;
/* r must be different to a and b */
/* int BN_mmul(r, a, b) */
-int BN_mul(r, a, b)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
+int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b)
{
BN_ULONG *ap,*bp,*rp;
BIGNUM *sk;
#define blbh (sk[1])
/* r must be different to a and b */
-int bn_mm(m, A, B, sk,ctx)
-BIGNUM *m,*A,*B;
-BIGNUM *sk;
-BN_CTX *ctx;
+int bn_mm(BIGNUM *m, BIGNUM *A, BIGNUM *B, BIGNUM *sk, BN_CTX *ctx)
{
int n,num,sqr=0;
int an,bn;
#undef t1
#undef t2
-int BN_mul_high(r,a,b,low,words)
-BIGNUM *r,*a,*b,*low;
-int words;
+int BN_mul_high(BIGNUM *r, BIGNUM *a, BIGNUM *b, BIGNUM *low, int words)
{
int w2,borrow=0,full=0;
BIGNUM t1,t2,t3,h,ah,al,bh,bl,m,s0,s1;
* a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
* a[1]*b[1]
*/
-void bn_mul_recursive(r,a,b,n2,t)
-BN_ULONG *r,*a,*b;
-int n2;
-BN_ULONG *t;
+void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
+ BN_ULONG *t)
{
int n=n2/2;
int neg,zero,c1,c2;
/* n+tn is the word length
* t needs to be n*4 is size, as does r */
-void bn_mul_part_recursive(r,a,b,tn,n,t)
-BN_ULONG *r,*a,*b;
-int tn,n;
-BN_ULONG *t;
+void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
+ int n, BN_ULONG *t)
{
int n2=n*2,i,j;
int c1;
* a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
* a[1]*b[1]
*/
-void bn_sqr_recursive(r,a,n2,t)
-BN_ULONG *r,*a;
-int n2;
-BN_ULONG *t;
+void bn_sqr_recursive(BN_ULONG *r, BN_ULONG *a, int n2, BN_ULONG *t)
{
int n=n2/2;
int zero,c1;
/* a and b must be the same size, which is n2.
* r needs to be n2 words and t needs to be n2*2
*/
-void bn_mul_low_recursive(r,a,b,n2,t)
-BN_ULONG *r,*a,*b;
-int n2;
-BN_ULONG *t;
+void bn_mul_low_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
+ BN_ULONG *t)
{
int n=n2/2;
* l is the low words of the output.
* t needs to be n2*3
*/
-void bn_mul_high(r,a,b,l,n2,t)
-BN_ULONG *r,*a,*b,*l;
-int n2;
-BN_ULONG *t;
+void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l, int n2,
+ BN_ULONG *t)
{
int j,i,n,c1,c2;
int neg,oneg,zero;
int BN_mul_low(BIGNUM *r, BIGNUM *a, BIGNUM *b,int words);
/* r must be different to a and b */
-int BN_mul_low(r, a, b, num)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
-int num;
+int BN_mul_low(BIGNUM *r, BIGNUM *a, BIGNUM *b, int num)
{
BN_ULONG *ap,*bp,*rp;
BIGNUM *sk;
#define t2 (sk[1])
/* r must be different to a and b */
-int bn_mm_low(m, A, B, num, sk,ctx)
-BIGNUM *m,*A,*B;
-int num;
-BIGNUM *sk;
-BN_CTX *ctx;
+int bn_mm_low(BIGNUM *m, BIGNUM *A, BIGNUM *B, int num, BIGNUM *sk,
+ BN_CTX *ctx)
{
int n; /* ,sqr=0; */
int an,bn;
#define limit_bits 5 /* 2^5, or 32 words */
#define limit_num (1<<limit_bits)
-int BN_m(r,a,b)
-BIGNUM *r,*a,*b;
+int BN_m(BIGNUM *r, BIGNUM *a, BIGNUM *b)
{
BIGNUM *sk;
int i,n;
#define blbh (sk[1])
/* r must be different to a and b */
-int BN_mm(m, A, B, sk)
-BIGNUM *m,*A,*B;
-BIGNUM *sk;
+int BN_mm(BIGNUM *m, BIGNUM *A, BIGNUM *B, BIGNUM *sk)
{
int i,num,anum,bnum;
int an,bn;
int bn_mull(BIGNUM *r,BIGNUM *a,BIGNUM *b, BN_CTX *ctx);
-int bn_mull(r,a,b,ctx)
-BIGNUM *r,*a,*b;
-BN_CTX *ctx;
+int bn_mull(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
{
int top,i,j,k,al,bl;
BIGNUM *t;
}
#endif
-void bn_mul_normal(r,a,na,b,nb)
-BN_ULONG *r,*a;
-int na;
-BN_ULONG *b;
-int nb;
+void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
{
BN_ULONG *rr;
}
#if 1
-void bn_mul_low_normal(r,a,b,n)
-BN_ULONG *r,*a,*b;
-int n;
+void bn_mul_low_normal(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
{
#ifdef BN_COUNT
printf(" bn_mul_low_normal %d * %d\n",n,n);
}
#if 0
-int bn_mul_high(r,a,b,low,words)
-BIGNUM *r,*a,*b,*low;
-int words;
+int bn_mul_high(BIGNUM *r, BIGNUM *a, BIGNUM *b, BIGNUM *low, int words)
{
int i;
BIGNUM t1,t2,t3,h,ah,al,bh,bl,m,s0,s1;
BN_free(&m); BN_free(&h);
}
-int BN_mod_mul_montgomery(r,a,b,mont,ctx)
-BIGNUM *r,*a,*b;
-BN_MONT_CTX *mont;
-BN_CTX *ctx;
+int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_MONT_CTX *mont,
+ BN_CTX *ctx)
{
BIGNUM *tmp;
return(0);
}
-int BN_from_montgomery(r,a,mont,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BN_MONT_CTX *mont;
-BN_CTX *ctx;
+int BN_from_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont, BN_CTX *ctx)
{
BIGNUM z1;
BIGNUM *t1,*t2;
return(0);
}
-int BN_MONT_CTX_set(mont,mod,ctx)
-BN_MONT_CTX *mont;
-BIGNUM *mod;
-BN_CTX *ctx;
+int BN_MONT_CTX_set(BN_MONT_CTX *mont, BIGNUM *mod, BN_CTX *ctx)
{
BIGNUM *Ri=NULL,*R=NULL;
#endif
-void ERR_load_BUF_strings()
+void ERR_load_BUF_strings(void)
{
static int init=1;
#include "cryptlib.h"
#include "buffer.h"
-BUF_MEM *BUF_MEM_new()
+BUF_MEM *BUF_MEM_new(void)
{
BUF_MEM *ret;
return(ret);
}
-void BUF_MEM_free(a)
-BUF_MEM *a;
+void BUF_MEM_free(BUF_MEM *a)
{
if(a == NULL)
return;
Free(a);
}
-int BUF_MEM_grow(str, len)
-BUF_MEM *str;
-int len;
+int BUF_MEM_grow(BUF_MEM *str, int len)
{
char *ret;
unsigned int n;
return(len);
}
-char *BUF_strdup(str)
-const char *str;
+char *BUF_strdup(const char *str)
{
char *ret;
int n;
* 64bit block we have used is contained in *num;
*/
-void CAST_cfb64_encrypt(in, out, length, schedule, ivec, num, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-CAST_KEY *schedule;
-unsigned char *ivec;
-int *num;
-int encrypt;
+void CAST_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ CAST_KEY *schedule, unsigned char *ivec, int *num, int encrypt)
{
register CAST_LONG v0,v1,t;
register int n= *num;
char *CAST_version="CAST" OPENSSL_VERSION_PTEXT;
-void CAST_ecb_encrypt(in, out, ks, encrypt)
-unsigned char *in;
-unsigned char *out;
-CAST_KEY *ks;
-int encrypt;
+void CAST_ecb_encrypt(unsigned char *in, unsigned char *out, CAST_KEY *ks,
+ int encrypt)
{
CAST_LONG l,d[2];
#include "cast.h"
#include "cast_lcl.h"
-void CAST_encrypt(data,key)
-CAST_LONG *data;
-CAST_KEY *key;
+void CAST_encrypt(CAST_LONG *data, CAST_KEY *key)
{
register CAST_LONG l,r,*k,t;
data[0]=r&0xffffffffL;
}
-void CAST_decrypt(data,key)
-CAST_LONG *data;
-CAST_KEY *key;
+void CAST_decrypt(CAST_LONG *data, CAST_KEY *key)
{
register CAST_LONG l,r,*k,t;
data[0]=r&0xffffffffL;
}
-void CAST_cbc_encrypt(in, out, length, ks, iv, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-CAST_KEY *ks;
-unsigned char *iv;
-int encrypt;
+void CAST_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+ CAST_KEY *ks, unsigned char *iv, int encrypt)
{
register CAST_LONG tin0,tin1;
register CAST_LONG tout0,tout1,xor0,xor1;
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void CAST_ofb64_encrypt(in, out, length, schedule, ivec, num)
-unsigned char *in;
-unsigned char *out;
-long length;
-CAST_KEY *schedule;
-unsigned char *ivec;
-int *num;
+void CAST_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ CAST_KEY *schedule, unsigned char *ivec, int *num)
{
register CAST_LONG v0,v1,t;
register int n= *num;
#define S6 CAST_S_table6
#define S7 CAST_S_table7
-void CAST_set_key(key,len,data)
-CAST_KEY *key;
-int len;
-unsigned char *data;
+void CAST_set_key(CAST_KEY *key, int len, unsigned char *data)
{
CAST_LONG x[16];
CAST_LONG z[16];
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
fprintf(stderr,"%s bytes per sec = %12.2f (%5.1fuS)\n",name, \
tm[index]*8,1.0e6/tm[index]);
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
};
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
#ifdef FULL_TEST
long l;
NULL,
};
-COMP_METHOD *COMP_rle()
+COMP_METHOD *COMP_rle(void)
{
return(&rle_method);
}
-static int rle_compress_block(ctx,out,olen,in,ilen)
-COMP_CTX *ctx;
-unsigned char *out;
-unsigned int olen;
-unsigned char *in;
-unsigned int ilen;
+static int rle_compress_block(COMP_CTX *ctx, unsigned char *out,
+ unsigned int olen, unsigned char *in, unsigned int ilen)
{
/* int i; */
return(ilen+1);
}
-static int rle_expand_block(ctx,out,olen,in,ilen)
-COMP_CTX *ctx;
-unsigned char *out;
-unsigned int olen;
-unsigned char *in;
-unsigned int ilen;
+static int rle_expand_block(COMP_CTX *ctx, unsigned char *out,
+ unsigned int olen, unsigned char *in, unsigned int ilen)
{
int i;
NULL,
};
-static int zlib_compress_block(ctx,out,olen,in,ilen)
-COMP_CTX *ctx;
-unsigned char *out;
-unsigned int olen;
-unsigned char *in;
-unsigned int ilen;
+static int zlib_compress_block(COMP_CTX *ctx, unsigned char *out,
+ unsigned int olen, unsigned char *in, unsigned int ilen)
{
unsigned long l;
int i;
return((int)l);
}
-static int zlib_expand_block(ctx,out,olen,in,ilen)
-COMP_CTX *ctx;
-unsigned char *out;
-unsigned int olen;
-unsigned char *in;
-unsigned int ilen;
+static int zlib_expand_block(COMP_CTX *ctx, unsigned char *out,
+ unsigned int olen, unsigned char *in, unsigned int ilen)
{
unsigned long l;
int i;
return((int)l);
}
-static int zz_uncompress (dest, destLen, source, sourceLen)
- Bytef *dest;
- uLongf *destLen;
- const Bytef *source;
- uLong sourceLen;
+static int zz_uncompress (Bytef *dest, uLongf *destLen, const Bytef *source,
+ uLong sourceLen)
{
z_stream stream;
int err;
#endif
-COMP_METHOD *COMP_zlib()
+COMP_METHOD *COMP_zlib(void)
{
return(&zlib_method);
}
#ifndef NO_ERR
#endif
-void ERR_load__strings()
+void ERR_load__strings(void)
{
static int init=1;
#include "objects.h"
#include "comp.h"
-COMP_CTX *COMP_CTX_new(meth)
-COMP_METHOD *meth;
+COMP_CTX *COMP_CTX_new(COMP_METHOD *meth)
{
COMP_CTX *ret;
return(ret);
}
-void COMP_CTX_free(ctx)
-COMP_CTX *ctx;
+void COMP_CTX_free(COMP_CTX *ctx)
{
/* CRYPTO_free_ex_data(rsa_meth,(char *)ctx,&ctx->ex_data); */
Free(ctx);
}
-int COMP_compress_block(ctx,out,olen,in,ilen)
-COMP_CTX *ctx;
-unsigned char *out;
-int olen;
-unsigned char *in;
-int ilen;
+int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
+ unsigned char *in, int ilen)
{
int ret;
if (ctx->meth->compress == NULL)
return(ret);
}
-int COMP_expand_block(ctx,out,olen,in,ilen)
-COMP_CTX *ctx;
-unsigned char *out;
-int olen;
-unsigned char *in;
-int ilen;
+int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen,
+ unsigned char *in, int ilen)
{
int ret;
}
-void print_conf(cv)
-CONF_VALUE *cv;
+void print_conf(CONF_VALUE *cv)
{
int i;
CONF_VALUE *v;
const char *CONF_version="CONF" OPENSSL_VERSION_PTEXT;
-LHASH *CONF_load(h,file,line)
-LHASH *h;
-char *file;
-long *line;
+LHASH *CONF_load(LHASH *h, char *file, long *line)
{
LHASH *ret=NULL;
FILE *in=NULL;
return(NULL);
}
-char *CONF_get_string(conf,section,name)
-LHASH *conf;
-char *section;
-char *name;
+char *CONF_get_string(LHASH *conf, char *section, char *name)
{
CONF_VALUE *v,vv;
char *p;
return(Getenv(name));
}
-static CONF_VALUE *get_section(conf,section)
-LHASH *conf;
-char *section;
+static CONF_VALUE *get_section(LHASH *conf, char *section)
{
CONF_VALUE *v,vv;
return(v);
}
-STACK *CONF_get_section(conf,section)
-LHASH *conf;
-char *section;
+STACK *CONF_get_section(LHASH *conf, char *section)
{
CONF_VALUE *v;
return(NULL);
}
-long CONF_get_number(conf,section,name)
-LHASH *conf;
-char *section;
-char *name;
+long CONF_get_number(LHASH *conf, char *section, char *name)
{
char *str;
long ret=0;
}
}
-void CONF_free(conf)
-LHASH *conf;
+void CONF_free(LHASH *conf)
{
if (conf == NULL) return;
lh_free(conf);
}
-static void value_free_hash(a,conf)
-CONF_VALUE *a;
-LHASH *conf;
+static void value_free_hash(CONF_VALUE *a, LHASH *conf)
{
if (a->name != NULL)
{
}
}
-static void value_free_stack(a,conf)
-CONF_VALUE *a;
-LHASH *conf;
+static void value_free_stack(CONF_VALUE *a, LHASH *conf)
{
CONF_VALUE *vv;
STACK *sk;
Free(a);
}
-static void clear_comments(p)
-char *p;
+static void clear_comments(char *p)
{
char *to;
}
}
-static int str_copy(conf,section,pto,from)
-LHASH *conf;
-char *section;
-char **pto,*from;
+static int str_copy(LHASH *conf, char *section, char **pto, char *from)
{
int q,r,rr=0,to=0,len=0;
char *s,*e,*rp,*p,*rrp,*np,*cp,v;
return(0);
}
-static char *eat_ws(p)
-char *p;
+static char *eat_ws(char *p)
{
while (IS_WS(*p) && (!IS_EOF(*p)))
p++;
return(p);
}
-static char *eat_alpha_numeric(p)
-char *p;
+static char *eat_alpha_numeric(char *p)
{
for (;;)
{
}
}
-static unsigned long hash(v)
-CONF_VALUE *v;
+static unsigned long hash(CONF_VALUE *v)
{
return((lh_strhash(v->section)<<2)^lh_strhash(v->name));
}
-static int cmp(a,b)
-CONF_VALUE *a,*b;
+static int cmp(CONF_VALUE *a, CONF_VALUE *b)
{
int i;
return((a->name == NULL)?-1:1);
}
-static char *scan_quote(p)
-char *p;
+static char *scan_quote(char *p)
{
int q= *p;
return(p);
}
-static CONF_VALUE *new_section(conf,section)
-LHASH *conf;
-char *section;
+static CONF_VALUE *new_section(LHASH *conf, char *section)
{
STACK *sk=NULL;
int ok=0,i;
#endif
-void ERR_load_CONF_strings()
+void ERR_load_CONF_strings(void)
{
static int init=1;
#endif
-void ERR_load_CRYPTO_strings()
+void ERR_load_CRYPTO_strings(void)
{
static int init=1;
static unsigned long (MS_FAR *id_callback)()=NULL;
#endif
-int CRYPTO_get_new_lockid(name)
-char *name;
+int CRYPTO_get_new_lockid(char *name)
{
char *str;
int i;
return(id_callback);
}
-void CRYPTO_set_id_callback(func)
-unsigned long (*func)(P_V);
+void CRYPTO_set_id_callback(func) unsigned long (*func)(P_V);
{
id_callback=func;
}
-unsigned long CRYPTO_thread_id()
+unsigned long CRYPTO_thread_id(void)
{
unsigned long ret=0;
return(ret);
}
-void CRYPTO_lock(mode,type,file,line)
-int mode;
-int type;
-const char *file;
-int line;
+void CRYPTO_lock(int mode, int type, const char *file, int line)
{
#ifdef LOCK_DEBUG
{
locking_callback(mode,type,file,line);
}
-int CRYPTO_add_lock(pointer,amount,type,file,line)
-int *pointer;
-int amount;
-int type;
-const char *file;
-int line;
+int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
+ int line)
{
int ret;
return(ret);
}
-const char *CRYPTO_get_lock_name(type)
-int type;
+const char *CRYPTO_get_lock_name(int type)
{
if (type < 0)
return("ERROR");
/* All we really need to do is remove the 'error' state when a thread
* detaches */
-BOOL WINAPI DLLEntryPoint(hinstDLL,fdwReason,lpvReserved)
-HINSTANCE hinstDLL;
-DWORD fdwReason;
-LPVOID lpvReserved;
+BOOL WINAPI DLLEntryPoint(HINSTANCE hinstDLL, DWORD fdwReason,
+ LPVOID lpvReserved)
{
switch(fdwReason)
{
#include "crypto.h"
#include "date.h"
-const char *SSLeay_version(t)
-int t;
+const char *SSLeay_version(int t)
{
if (t == SSLEAY_VERSION)
return OPENSSL_VERSION_TEXT;
return("not available");
}
-unsigned long SSLeay()
+unsigned long SSLeay(void)
{
return(SSLEAY_VERSION_NUMBER);
}
#include "des_locl.h"
/* HAS BUGS? DON'T USE - this is only present for use in des.c */
-void des_3cbc_encrypt(input, output, length, ks1, ks2, iv1, iv2, enc)
-des_cblock (*input);
-des_cblock (*output);
-long length;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_cblock (*iv1);
-des_cblock (*iv2);
-int enc;
+void des_3cbc_encrypt(des_cblock (*input), des_cblock (*output), long length,
+ des_key_schedule ks1, des_key_schedule ks2, des_cblock (*iv1),
+ des_cblock (*iv2), int enc)
{
int off=((int)length-1)/8;
long l8=((length+7)/8)*8;
#include "des_locl.h"
-DES_LONG des_cbc_cksum(in, out, length, schedule, iv)
-const unsigned char *in;
-des_cblock out;
-long length;
-des_key_schedule schedule;
-const des_cblock iv;
+DES_LONG des_cbc_cksum(const unsigned char *in, des_cblock out, long length,
+ des_key_schedule schedule, const des_cblock iv)
{
register DES_LONG tout0,tout1,tin0,tin1;
register long l=length;
/* Note that this is inconsistent with other DES functions, in that it doesn't
update ivec */
-void des_cbc_encrypt(in, out, length, schedule, ivec, enc)
-const unsigned char *in;
-unsigned char *out;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
-int enc;
+void des_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
+ des_key_schedule schedule, des_cblock ivec, int enc)
{
register DES_LONG tin0,tin1;
register DES_LONG tout0,tout1,xor0,xor1;
* 64bit block we have used is contained in *num;
*/
-void des_ede3_cfb64_encrypt(in, out, length, ks1,ks2,ks3, ivec, num, enc)
-const unsigned char *in;
-unsigned char *out;
-long length;
-des_key_schedule ks1,ks2,ks3;
-des_cblock ivec;
-int *num;
-int enc;
+void des_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, des_key_schedule ks1, des_key_schedule ks2,
+ des_key_schedule ks3, des_cblock ivec, int *num, int enc)
{
register DES_LONG v0,v1;
register long l=length;
}
#ifdef undef /* MACRO */
-void des_ede2_cfb64_encrypt(in, out, length, ks1,ks2, ivec, num, enc)
-unsigned char *in;
-unsigned char *out;
-long length;
-des_key_schedule ks1,ks2;
-des_cblock (*ivec);
-int *num;
-int enc;
+void des_ede2_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ des_key_schedule ks1, des_key_schedule ks2, des_cblock (*ivec),
+ int *num, int enc)
{
des_ede3_cfb64_encrypt(in,out,length,ks1,ks2,ks1,ivec,num,enc);
}
* 64bit block we have used is contained in *num;
*/
-void des_cfb64_encrypt(in, out, length, schedule, ivec, num, enc)
-const unsigned char *in;
-unsigned char *out;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
-int *num;
-int enc;
+void des_cfb64_encrypt(const unsigned char *in, unsigned char *out,
+ long length, des_key_schedule schedule, des_cblock ivec, int *num,
+ int enc)
{
register DES_LONG v0,v1;
register long l=length;
* the second. The second 12 bits will come from the 3rd and half the 4th
* byte.
*/
-void des_cfb_encrypt(in, out, numbits, length, schedule, ivec, enc)
-const unsigned char *in;
-unsigned char *out;
-int numbits;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
-int enc;
+void des_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
+ long length, des_key_schedule schedule, des_cblock ivec, int enc)
{
register DES_LONG d0,d1,v0,v1,n=(numbits+7)/8;
register DES_LONG mask0,mask1;
int vflag,cflag,eflag,dflag,kflag,bflag,fflag,sflag,uflag,flag3,hflag,error;
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
int i;
struct stat ins,outs;
EXIT(0);
}
-void usage()
+void usage(void)
{
char **u;
static const char *Usage[]={
EXIT(1);
}
-void doencryption()
+void doencryption(void)
{
#ifdef _LIBC
extern int srandom();
if (Exit) EXIT(Exit);
}
-int uufwrite(data, size, num, fp)
-unsigned char *data;
-int size;
-unsigned int num;
-FILE *fp;
-
- /* We ignore this parameter but it should be > ~50 I believe */
-
-
+/* We ignore this parameter but it should be > ~50 I believe */
+int uufwrite(unsigned char *data, int size, unsigned int num, FILE *fp)
{
int i,j,left,rem,ret=num;
static int start=1;
return(ret);
}
-void uufwriteEnd(fp)
-FILE *fp;
+void uufwriteEnd(FILE *fp)
{
int j;
static const char *end=" \nend\n";
fwrite(end,1,strlen(end),fp);
}
-int uufread(out, size, num, fp)
-unsigned char *out;
-int size; /* should always be > ~ 60; I actually ignore this parameter :-) */
-unsigned int num;
-FILE *fp;
+/* int size: should always be > ~ 60; I actually ignore this parameter :-) */
+int uufread(unsigned char *out, int size, unsigned int num, FILE *fp)
{
int i,j,tot;
static int done=0;
*((c)++)=(unsigned char)(((l) )&0xff))
-int uuencode(in, num, out)
-unsigned char *in;
-int num;
-unsigned char *out;
+int uuencode(unsigned char *in, int num, unsigned char *out)
{
int j,i,n,tot=0;
DES_LONG l;
return(tot);
}
-int uudecode(in, num, out)
-unsigned char *in;
-int num;
-unsigned char *out;
+int uudecode(unsigned char *in, int num, unsigned char *out)
{
int j,i,k;
unsigned int n=0,space=0;
#include "des_locl.h"
-void des_encrypt(data, ks, enc)
-DES_LONG *data;
-des_key_schedule ks;
-int enc;
+void des_encrypt(DES_LONG *data, des_key_schedule ks, int enc)
{
register DES_LONG l,r,t,u;
#ifdef DES_PTR
l=r=t=u=0;
}
-void des_encrypt2(data, ks, enc)
-DES_LONG *data;
-des_key_schedule ks;
-int enc;
+void des_encrypt2(DES_LONG *data, des_key_schedule ks, int enc)
{
register DES_LONG l,r,t,u;
#ifdef DES_PTR
l=r=t=u=0;
}
-void des_encrypt3(data,ks1,ks2,ks3)
-DES_LONG *data;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
+void des_encrypt3(DES_LONG *data, des_key_schedule ks1, des_key_schedule ks2,
+ des_key_schedule ks3)
{
register DES_LONG l,r;
data[1]=r;
}
-void des_decrypt3(data,ks1,ks2,ks3)
-DES_LONG *data;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
+void des_decrypt3(DES_LONG *data, des_key_schedule ks1, des_key_schedule ks2,
+ des_key_schedule ks3)
{
register DES_LONG l,r;
#ifndef DES_DEFAULT_OPTIONS
-void des_ncbc_encrypt(in, out, length, schedule, ivec, enc)
-const unsigned char *in;
-unsigned char *out;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
-int enc;
+void des_ncbc_encrypt(const unsigned char *in, unsigned char *out, long length,
+ des_key_schedule schedule, des_cblock ivec, int enc)
{
register DES_LONG tin0,tin1;
register DES_LONG tout0,tout1,xor0,xor1;
tin[0]=tin[1]=0;
}
-void des_ede3_cbc_encrypt(input, output, length, ks1, ks2, ks3, ivec, enc)
-const unsigned char *input;
-unsigned char *output;
-long length;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
-des_cblock ivec;
-int enc;
+void des_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
+ long length, des_key_schedule ks1, des_key_schedule ks2,
+ des_key_schedule ks3, des_cblock ivec, int enc)
{
register DES_LONG tin0,tin1;
register DES_LONG tout0,tout1,xor0,xor1;
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
fprintf(stderr,"%s bytes per sec = %12.2f (%5.1fuS)\n",name, \
tm[index]*8,1.0e6/tm[index]);
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
static int ede_cfb64_test();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,j,err=0;
des_cblock in,out,outin,iv3,iv2;
return(0);
}
-static char *pt(p)
-unsigned char *p;
+static char *pt(unsigned char *p)
{
static char bufs[10][20];
static int bnum=0;
#ifndef LIBDES_LIT
-static int cfb_test(bits, cfb_cipher)
-int bits;
-unsigned char *cfb_cipher;
+static int cfb_test(int bits, unsigned char *cfb_cipher)
{
des_key_schedule ks;
int i,err=0;
return(err);
}
-static int cfb64_test(cfb_cipher)
-unsigned char *cfb_cipher;
+static int cfb64_test(unsigned char *cfb_cipher)
{
des_key_schedule ks;
int err=0,i,n;
return(err);
}
-static int ede_cfb64_test(cfb_cipher)
-unsigned char *cfb_cipher;
+static int ede_cfb64_test(unsigned char *cfb_cipher)
{
des_key_schedule ks;
int err=0,i,n;
#include "des_locl.h"
-void des_ecb3_encrypt(in, out, ks1, ks2, ks3, enc)
-const unsigned char *in;
-unsigned char *out;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
-int enc;
+void des_ecb3_encrypt(const unsigned char *in, unsigned char *out,
+ des_key_schedule ks1, des_key_schedule ks2, des_key_schedule ks3,
+ int enc)
{
register DES_LONG l0,l1;
DES_LONG ll[2];
}
-void des_ecb_encrypt(in, out, ks, enc)
-const des_cblock in;
-des_cblock out;
-des_key_schedule ks;
-int enc;
+void des_ecb_encrypt(const des_cblock in, des_cblock out, des_key_schedule ks,
+ int enc)
{
register DES_LONG l;
DES_LONG ll[2];
#include "des_locl.h"
-void des_ede3_cbcm_encrypt(in, out, length, ks1, ks2, ks3, ivec1, ivec2, enc)
-const unsigned char *in;
-unsigned char *out;
-long length;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
-des_cblock ivec1;
-des_cblock ivec2;
-int enc;
+void des_ede3_cbcm_encrypt(const unsigned char *in, unsigned char *out,
+ long length, des_key_schedule ks1, des_key_schedule ks2,
+ des_key_schedule ks3, des_cblock ivec1, des_cblock ivec2, int enc)
{
register DES_LONG tin0,tin1;
register DES_LONG tout0,tout1,xor0,xor1,m0,m1;
#include "des_locl.h"
-void des_ede3_cbc_encrypt(input, output, length, ks1, ks2, ks3, ivec, enc)
-des_cblock (*input);
-des_cblock (*output);
-long length;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_key_schedule ks3;
-des_cblock (*ivec);
-int enc;
+void des_ede3_cbc_encrypt(des_cblock (*input), des_cblock (*output),
+ long length, des_key_schedule ks1, des_key_schedule ks2,
+ des_key_schedule ks3, des_cblock (*ivec), int enc)
{
register DES_LONG tin0,tin1;
register DES_LONG tout0,tout1,xor0,xor1;
}
#ifdef undef /* MACRO */
-void des_ede2_cbc_encrypt(input, output, length, ks1, ks2, ivec, enc)
-des_cblock (*input);
-des_cblock (*output);
-long length;
-des_key_schedule ks1;
-des_key_schedule ks2;
-des_cblock (*ivec);
-int enc;
+void des_ede2_cbc_encrypt(des_cblock (*input), des_cblock (*output),
+ long length, des_key_schedule ks1, des_key_schedule ks2,
+ des_cblock (*ivec), int enc)
{
des_ede3_cbc_encrypt(input,output,length,ks1,ks2,ks1,ivec,enc);
}
*/
-int des_enc_read(fd, buf, len, sched, iv)
-int fd;
-char *buf;
-int len;
-des_key_schedule sched;
-des_cblock iv;
+int des_enc_read(int fd, char *buf, int len, des_key_schedule sched,
+ des_cblock iv)
{
/* data to be unencrypted */
int net_num=0;
* - This code cannot handle non-blocking sockets.
*/
-int des_enc_write(fd, buf, len, sched, iv)
-int fd;
-const char *buf;
-int len;
-des_key_schedule sched;
-des_cblock iv;
+int des_enc_write(int fd, const char *buf, int len, des_key_schedule sched,
+ des_cblock iv)
{
#ifdef _LIBC
extern int srandom();
#endif
#if defined(PERL5) || defined(__FreeBSD__)
-char *des_crypt(buf,salt)
+char *des_crypt(const char *buf, const char *salt)
#else
-char *crypt(buf,salt)
-#endif
-const char *buf;
-const char *salt;
+char *crypt(const char *buf, const char *salt)
{
static char buff[14];
}
-char *des_fcrypt(buf,salt,ret)
-const char *buf;
-const char *salt;
-char *ret;
+char *des_fcrypt(const char *buf, const char *salt, char *ret)
{
unsigned int i,j,x,y;
DES_LONG Eswap0,Eswap1;
#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
(a)=(a)^(t)^(t>>(16-(n))))\
-void fcrypt_body(out, ks, Eswap0, Eswap1)
-DES_LONG *out;
-des_key_schedule ks;
-DES_LONG Eswap0;
-DES_LONG Eswap1;
+void fcrypt_body(DES_LONG *out, des_key_schedule ks, DES_LONG Eswap0,
+ DES_LONG Eswap1)
{
register DES_LONG l,r,t,u;
#ifdef DES_PTR
#include "des_locl.h"
-void des_ncbc_encrypt(input, output, length, schedule, ivec, enc)
-des_cblock (*input);
-des_cblock (*output);
-long length;
-des_key_schedule schedule;
-des_cblock (*ivec);
-int enc;
+void des_ncbc_encrypt(des_cblock (*input), des_cblock (*output), long length,
+ des_key_schedule schedule, des_cblock (*ivec), int enc)
{
register DES_LONG tin0,tin1;
register DES_LONG tout0,tout1,xor0,xor1;
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void des_ede3_ofb64_encrypt(in, out, length, k1,k2,k3, ivec, num)
-register const unsigned char *in;
-register unsigned char *out;
-long length;
-des_key_schedule k1,k2,k3;
-des_cblock ivec;
-int *num;
+void des_ede3_ofb64_encrypt(register const unsigned char *in,
+ register unsigned char *out, long length, des_key_schedule k1,
+ des_key_schedule k2, des_key_schedule k3, des_cblock ivec, int *num)
{
register DES_LONG v0,v1;
register int n= *num;
}
#ifdef undef /* MACRO */
-void des_ede2_ofb64_encrypt(in, out, length, k1,k2, ivec, num)
-register unsigned char *in;
-register unsigned char *out;
-long length;
-des_key_schedule k1,k2;
-des_cblock (*ivec);
-int *num;
+void des_ede2_ofb64_encrypt(register unsigned char *in,
+ register unsigned char *out, long length, des_key_schedule k1,
+ des_key_schedule k2, des_cblock (*ivec), int *num)
{
des_ede3_ofb64_encrypt(in, out, length, k1,k2,k1, ivec, num);
}
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void des_ofb64_encrypt(in, out, length, schedule, ivec, num)
-register const unsigned char *in;
-register unsigned char *out;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
-int *num;
+void des_ofb64_encrypt(register const unsigned char *in,
+ register unsigned char *out, long length, des_key_schedule schedule,
+ des_cblock ivec, int *num)
{
register DES_LONG v0,v1,t;
register int n= *num;
* the second. The second 12 bits will come from the 3rd and half the 4th
* byte.
*/
-void des_ofb_encrypt(in, out, numbits, length, schedule, ivec)
-const unsigned char *in;
-unsigned char *out;
-int numbits;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
+void des_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits,
+ long length, des_key_schedule schedule, des_cblock ivec)
{
register DES_LONG d0,d1,vv0,vv1,v0,v1,n=(numbits+7)/8;
register DES_LONG mask0,mask1;
#include "des_locl.h"
-void des_pcbc_encrypt(input, output, length, schedule, ivec, enc)
-const unsigned char *input;
-unsigned char *output;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
-int enc;
+void des_pcbc_encrypt(const unsigned char *input, unsigned char *output,
+ long length, des_key_schedule schedule, des_cblock ivec, int enc)
{
register DES_LONG sin0,sin1,xor0,xor1,tout0,tout1;
DES_LONG tin[2];
/* Got the value MIT uses via brute force :-) 2/10/90 eay */
#define NOISE ((DES_LONG)83653421L)
-DES_LONG des_quad_cksum(input, output, length, out_count, seed)
-const unsigned char *input;
-des_cblocks output;
-long length;
-int out_count;
-des_cblock seed;
+DES_LONG des_quad_cksum(const unsigned char *input, des_cblocks output,
+ long length, int out_count, des_cblock seed)
{
DES_LONG z0,z1,t0,t1;
int i;
static int seed=0;
static des_cblock init;
-void des_random_seed(key)
-des_cblock key;
+void des_random_seed(des_cblock key)
{
memcpy(init,key,sizeof(des_cblock));
seed=1;
}
-void des_random_key(ret)
-unsigned char *ret;
+void des_random_key(unsigned char *ret)
{
des_key_schedule ks;
static DES_LONG c=0;
#include "des_locl.h"
-int des_read_password(key, prompt, verify)
-des_cblock key;
-const char *prompt;
-int verify;
+int des_read_password(des_cblock key, const char *prompt, int verify)
{
int ok;
char buf[BUFSIZ],buff[BUFSIZ];
return(ok);
}
-int des_read_2passwords(key1, key2, prompt, verify)
-des_cblock key1;
-des_cblock key2;
-const char *prompt;
-int verify;
+int des_read_2passwords(des_cblock key1, des_cblock key2, const char *prompt,
+ int verify)
{
int ok;
char buf[BUFSIZ],buff[BUFSIZ];
#endif
static jmp_buf save;
-int des_read_pw_string(buf, length, prompt, verify)
-char *buf;
-int length;
-const char *prompt;
-int verify;
+int des_read_pw_string(char *buf, int length, const char *prompt,
+ int verify)
{
char buff[BUFSIZ];
int ret;
#ifndef WIN16
-static void read_till_nl(in)
-FILE *in;
+static void read_till_nl(FILE *in)
{
#define SIZE 4
char buf[SIZE+1];
/* return 0 if ok, 1 (or -1) otherwise */
-int des_read_pw(buf, buff, size, prompt, verify)
-char *buf;
-char *buff;
-int size;
-const char *prompt;
-int verify;
+int des_read_pw(char *buf, char *buff, int size, const char *prompt,
+ int verify)
{
#ifdef VMS
struct IOSB iosb;
#else /* WIN16 */
-int des_read_pw(buf, buff, size, prompt, verify)
-char *buf;
-char *buff;
-int size;
-char *prompt;
-int verify;
+int des_read_pw(char *buf, char *buff, int size, char *prompt, int verify)
{
memset(buf,0,size);
memset(buff,0,size);
#endif
-static void pushsig()
+static void pushsig(void)
{
int i;
#ifdef SIGACTION
#endif
}
-static void popsig()
+static void popsig(void)
{
int i;
}
}
-static void recsig(i)
-int i;
+static void recsig(int i)
{
longjmp(save,1);
#ifdef LINT
}
#if defined(MSDOS) && !defined(WIN16)
-static int noecho_fgets(buf,size,tty)
-char *buf;
-int size;
-FILE *tty;
+static int noecho_fgets(char *buf, int size, FILE *tty)
{
int i;
char *p;
int _des_crypt();
#endif
-int _des_crypt(buf, len, desp)
-char *buf;
-int len;
-struct desparams *desp;
+int _des_crypt(char *buf, int len, struct desparams *desp)
{
des_key_schedule ks;
int enc;
#include <stdio.h>
#include "des.h"
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
des_cblock k,k1;
int i;
int des_check_key=0;
-void des_set_odd_parity(key)
-des_cblock key;
+void des_set_odd_parity(des_cblock key)
{
int i;
key[i]=odd_parity[key[i]];
}
-static int check_parity(key)
-const des_cblock key;
+static int check_parity(const des_cblock key)
{
int i;
{0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE},
{0xFE,0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1}};
-int des_is_weak_key(key)
-const des_cblock key;
+int des_is_weak_key(const des_cblock key)
{
int i;
* return -1 if key parity error,
* return -2 if illegal weak key.
*/
-int des_set_key(key, schedule)
-const des_cblock key;
-des_key_schedule schedule;
+int des_set_key(const des_cblock key, des_key_schedule schedule)
{
static int shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
register DES_LONG c,d,t,s,t2;
return(0);
}
-int des_key_sched(key, schedule)
-const des_cblock key;
-des_key_schedule schedule;
+int des_key_sched(const des_cblock key, des_key_schedule schedule)
{
return(des_set_key(key,schedule));
}
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
extern int des_check_key;
-void des_string_to_key(str, key)
-const char *str;
-des_cblock key;
+void des_string_to_key(const char *str, des_cblock key)
{
des_key_schedule ks;
int i,length;
des_set_odd_parity(key);
}
-void des_string_to_2keys(str, key1, key2)
-const char *str;
-des_cblock key1;
-des_cblock key2;
+void des_string_to_2keys(const char *str, des_cblock key1, des_cblock key2)
{
des_key_schedule ks;
int i,length;
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
- * $Id: supp.c,v 1.3 1999/04/17 21:25:00 ben Exp $
+ * $Id: supp.c,v 1.4 1999/04/19 21:28:07 ulf Exp $
*/
#include <stdio.h>
#include "des_locl.h"
-void des_cblock_print_file(cb, fp)
- const des_cblock cb;
- FILE *fp;
+void des_cblock_print_file(const des_cblock cb, FILE *fp)
{
int i;
const unsigned int *p = (const unsigned int *)cb;
0xA7,0x1C,0xC9,0x09,0x69,0x9A,0x83,0xCF,0x29,0x39,0xB9,0xE9,0x4C,0xFF,0x43,0xAB,
};
-void des_xwhite_in2out(key,in,out)
-const des_cblock key;
-const des_cblock in;
-des_cblock out;
+void des_xwhite_in2out(const des_cblock key, const des_cblock in,
+ des_cblock out)
{
int out0,out1;
int i;
}
}
-void des_xcbc_encrypt(in, out, length, schedule, ivec, inw,outw,enc)
-const unsigned char *in;
-unsigned char *out;
-long length;
-des_key_schedule schedule;
-des_cblock ivec;
-const des_cblock inw;
-const des_cblock outw;
-int enc;
+void des_xcbc_encrypt(const unsigned char *in, unsigned char *out, long length,
+ des_key_schedule schedule, des_cblock ivec, const des_cblock inw,
+ const des_cblock outw, int enc)
{
register DES_LONG tin0,tin1;
register DES_LONG tout0,tout1,xor0,xor1;
* should hold.
*/
-int DH_check(dh,ret)
-DH *dh;
-int *ret;
+int DH_check(DH *dh, int *ret)
{
int ok=0;
BN_CTX *ctx=NULL;
#endif
-void ERR_load_DH_strings()
+void ERR_load_DH_strings(void)
{
static int init=1;
* this generator function can take a very very long time to run.
*/
-DH *DH_generate_parameters(prime_len,generator,callback,cb_arg)
-int prime_len;
-int generator;
-void (*callback)(P_I_I_P);
-char *cb_arg;
+DH *DH_generate_parameters(int prime_len, int generator,
+ void (*callback)(P_I_I_P), char *cb_arg)
{
BIGNUM *p=NULL,*t1,*t2;
DH *ret=NULL;
#include "rand.h"
#include "dh.h"
-int DH_generate_key(dh)
-DH *dh;
+int DH_generate_key(DH *dh)
{
int ok=0;
unsigned int i;
return(ok);
}
-int DH_compute_key(key,pub_key,dh)
-unsigned char *key;
-BIGNUM *pub_key;
-DH *dh;
+int DH_compute_key(unsigned char *key, BIGNUM *pub_key, DH *dh)
{
BN_CTX ctx;
BN_MONT_CTX *mont;
const char *DH_version="Diffie-Hellman" OPENSSL_VERSION_PTEXT;
-DH *DH_new()
+DH *DH_new(void)
{
DH *ret;
return(ret);
}
-void DH_free(r)
-DH *r;
+void DH_free(DH *r)
{
if(r == NULL) return;
if (r->p != NULL) BN_clear_free(r->p);
Free(r);
}
-int DH_size(dh)
-DH *dh;
+int DH_size(DH *dh)
{
return(BN_num_bytes(dh->p));
}
BIO *out=NULL;
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
DH *a,*b;
char buf[12];
return(ret);
}
-static void MS_CALLBACK cb(p, n,arg)
-int p;
-int n;
-char *arg;
+static void MS_CALLBACK cb(int p, int n, char *arg)
{
char c='*';
return(ret);
}
-void DSA_SIG_free(r)
-DSA_SIG *r;
+void DSA_SIG_free(DSA_SIG *r)
{
if (r == NULL) return;
if (r->r) BN_clear_free(r->r);
Free(r);
}
-int i2d_DSA_SIG(v,pp)
-DSA_SIG *v;
-unsigned char **pp;
+int i2d_DSA_SIG(DSA_SIG *v, unsigned char **pp)
{
int t=0,len;
ASN1_INTEGER rbs,sbs;
return(t);
}
-DSA_SIG *d2i_DSA_SIG(a,pp,length)
-DSA_SIG **a;
-unsigned char **pp;
-long length;
+DSA_SIG *d2i_DSA_SIG(DSA_SIG **a, unsigned char **pp, long length)
{
int i=ERR_R_NESTED_ASN1_ERROR;
ASN1_INTEGER *bs=NULL;
#endif
-void ERR_load_DSA_strings()
+void ERR_load_DSA_strings(void)
{
static int init=1;
#include "dsa.h"
#include "rand.h"
-DSA *DSA_generate_parameters(bits,seed_in,seed_len,counter_ret,h_ret,callback,
- cb_arg)
-int bits;
-unsigned char *seed_in;
-int seed_len;
-int *counter_ret;
-unsigned long *h_ret;
-void (*callback)();
-char *cb_arg;
+DSA *DSA_generate_parameters(int bits, unsigned char *seed_in, int seed_len,
+ int *counter_ret, unsigned long *h_ret, void (*callback)(),
+ char *cb_arg)
{
int ok=0;
unsigned char seed[SHA_DIGEST_LENGTH];
return(ok?ret:NULL);
}
-int DSA_is_prime(w, callback,cb_arg)
-BIGNUM *w;
-void (*callback)();
-char *cb_arg;
+int DSA_is_prime(BIGNUM *w, void (*callback)(), char *cb_arg)
{
int ok= -1,j,i,n;
BN_CTX *ctx=NULL,*ctx2=NULL;
#include "dsa.h"
#include "rand.h"
-int DSA_generate_key(dsa)
-DSA *dsa;
+int DSA_generate_key(DSA *dsa)
{
int ok=0;
unsigned int i;
const char *DSA_version="DSA" OPENSSL_VERSION_PTEXT;
-DSA *DSA_new()
+DSA *DSA_new(void)
{
DSA *ret;
return(ret);
}
-void DSA_free(r)
-DSA *r;
+void DSA_free(DSA *r)
{
int i;
Free(r);
}
-int DSA_size(r)
-DSA *r;
+int DSA_size(DSA *r)
{
int ret,i;
ASN1_INTEGER bs;
#include "rand.h"
#include "asn1.h"
-DSA_SIG * DSA_do_sign(dgst,dlen,dsa)
-unsigned char *dgst;
-int dlen;
-DSA *dsa;
+DSA_SIG * DSA_do_sign(unsigned char *dgst, int dlen, DSA *dsa)
{
BIGNUM *kinv=NULL,*r=NULL,*s=NULL;
BIGNUM m;
/* data has already been hashed (probably with SHA or SHA-1). */
-int DSA_sign(type,dgst,dlen,sig,siglen,dsa)
-int type;
-unsigned char *dgst;
-int dlen;
-unsigned char *sig; /* out */
-unsigned int *siglen; /* out */
-DSA *dsa;
+/* unsigned char *sig: out */
+/* unsigned int *siglen: out */
+int DSA_sign(int type, unsigned char *dgst, int dlen, unsigned char *sig,
+ unsigned int *siglen, DSA *dsa)
{
DSA_SIG *s;
s=DSA_do_sign(dgst,dlen,dsa);
return(1);
}
-int DSA_sign_setup(dsa,ctx_in,kinvp,rp)
-DSA *dsa;
-BN_CTX *ctx_in;
-BIGNUM **kinvp;
-BIGNUM **rp;
+int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
{
BN_CTX *ctx;
BIGNUM k,*kinv=NULL,*r=NULL;
#include "asn1.h"
#include "asn1_mac.h"
-int DSA_do_verify(dgst,dgst_len,sig,dsa)
-unsigned char *dgst;
-int dgst_len;
-DSA_SIG *sig;
-DSA *dsa;
+int DSA_do_verify(unsigned char *dgst, int dgst_len, DSA_SIG *sig, DSA *dsa)
{
BN_CTX *ctx;
BIGNUM u1,u2,t1;
* 0: incorrect signature
* -1: error
*/
-int DSA_verify(type,dgst,dgst_len,sigbuf,siglen,dsa)
-int type;
-unsigned char *dgst;
-int dgst_len;
-unsigned char *sigbuf;
-int siglen;
-DSA *dsa;
+int DSA_verify(int type, unsigned char *dgst, int dgst_len,
+ unsigned char *sigbuf, int siglen, DSA *dsa)
{
DSA_SIG *s;
int ret=-1;
0xe0,0x42,0x7d,LAST_VALUE};
#endif
-int cb(p,n)
-int p,n;
+int cb(int p, int n)
{
char c='*';
static BIO *bio_err=NULL;
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
DSA *dsa=NULL;
int counter,ret=0,i,j;
return(0);
}
-static void MS_CALLBACK dsa_cb(p, n, arg)
-int p;
-int n;
-char *arg;
+static void MS_CALLBACK dsa_cb(int p, int n, char *arg)
{
char c='*';
static int ok=0,num=0;
} \
(p)->err_data_flags[i]=0;
-static void ERR_STATE_free(s)
-ERR_STATE *s;
+static void ERR_STATE_free(ERR_STATE *s)
{
int i;
Free(s);
}
-void ERR_load_ERR_strings()
+void ERR_load_ERR_strings(void)
{
static int init=1;
}
}
-void ERR_load_strings(lib,str)
-int lib;
-ERR_STRING_DATA *str;
+void ERR_load_strings(int lib, ERR_STRING_DATA *str)
{
if (error_hash == NULL)
{
CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
}
-void ERR_free_strings()
+void ERR_free_strings(void)
{
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
/********************************************************/
-void ERR_put_error(lib,func,reason,file,line)
-int lib,func,reason;
-const char *file;
-int line;
+void ERR_put_error(int lib, int func, int reason, const char *file,
+ int line)
{
ERR_STATE *es;
err_clear_data(es,es->top);
}
-void ERR_clear_error()
+void ERR_clear_error(void)
{
ERR_STATE *es;
}
-unsigned long ERR_get_error()
+unsigned long ERR_get_error(void)
{ return(get_error_values(1,NULL,NULL,NULL,NULL)); }
-unsigned long ERR_get_error_line(file,line)
-const char **file;
-int *line;
+unsigned long ERR_get_error_line(const char **file,
+ int *line)
{ return(get_error_values(1,file,line,NULL,NULL)); }
-unsigned long ERR_get_error_line_data(file,line,data,flags)
-const char **file;
-int *line;
-const char **data;
-int *flags;
- { return(get_error_values(1,file,line,data,flags)); }
+unsigned long ERR_get_error_line_data(const char **file, int *line,
+ const char **data, int *flags)
+ { return(get_error_values(1,file,line,
+ data,flags)); }
-unsigned long ERR_peek_error()
+unsigned long ERR_peek_error(void)
{ return(get_error_values(0,NULL,NULL,NULL,NULL)); }
-unsigned long ERR_peek_error_line(file,line)
-const char **file;
-int *line;
+unsigned long ERR_peek_error_line(const char **file,
+ int *line)
{ return(get_error_values(0,file,line,NULL,NULL)); }
-unsigned long ERR_peek_error_line_data(file,line,data,flags)
-const char **file;
-int *line;
-const char **data;
-int *flags;
- { return(get_error_values(0,file,line,data,flags)); }
-
-static unsigned long get_error_values(inc,file,line,data,flags)
-int inc;
-const char **file;
-int *line;
-const char **data;
-int *flags;
+unsigned long ERR_peek_error_line_data(const char **file, int *line,
+ const char **data, int *flags)
+ { return(get_error_values(0,file,line,
+ data,flags)); }
+
+static unsigned long get_error_values(int inc, const char **file, int *line,
+ const char **data, int *flags)
{
int i=0;
ERR_STATE *es;
}
/* BAD for multi-threaded, uses a local buffer if ret == NULL */
-char *ERR_error_string(e,ret)
-unsigned long e;
-char *ret;
+char *ERR_error_string(unsigned long e, char *ret)
{
static char buf[256];
const char *ls,*fs,*rs;
return(ret);
}
-LHASH *ERR_get_string_table()
+LHASH *ERR_get_string_table(void)
{
return(error_hash);
}
-LHASH *ERR_get_err_state_table()
+LHASH *ERR_get_err_state_table(void)
{
return(thread_hash);
}
-const char *ERR_lib_error_string(e)
-unsigned long e;
+const char *ERR_lib_error_string(unsigned long e)
{
ERR_STRING_DATA d,*p=NULL;
unsigned long l;
return((p == NULL)?NULL:p->string);
}
-const char *ERR_func_error_string(e)
-unsigned long e;
+const char *ERR_func_error_string(unsigned long e)
{
ERR_STRING_DATA d,*p=NULL;
unsigned long l,f;
return((p == NULL)?NULL:p->string);
}
-const char *ERR_reason_error_string(e)
-unsigned long e;
+const char *ERR_reason_error_string(unsigned long e)
{
ERR_STRING_DATA d,*p=NULL;
unsigned long l,r;
return((p == NULL)?NULL:p->string);
}
-static unsigned long err_hash(a)
-ERR_STRING_DATA *a;
+static unsigned long err_hash(ERR_STRING_DATA *a)
{
unsigned long ret,l;
return(ret^ret%19*13);
}
-static int err_cmp(a,b)
-ERR_STRING_DATA *a,*b;
+static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b)
{
return((int)(a->error-b->error));
}
-static unsigned long pid_hash(a)
-ERR_STATE *a;
+static unsigned long pid_hash(ERR_STATE *a)
{
return(a->pid*13);
}
-static int pid_cmp(a,b)
-ERR_STATE *a,*b;
+static int pid_cmp(ERR_STATE *a, ERR_STATE *b)
{
return((int)((long)a->pid - (long)b->pid));
}
-void ERR_remove_state(pid)
-unsigned long pid;
+void ERR_remove_state(unsigned long pid)
{
ERR_STATE *p,tmp;
if (p != NULL) ERR_STATE_free(p);
}
-ERR_STATE *ERR_get_state()
+ERR_STATE *ERR_get_state(void)
{
static ERR_STATE fallback;
ERR_STATE *ret=NULL,tmp,*tmpp;
return(ret);
}
-int ERR_get_next_error_library()
+int ERR_get_next_error_library(void)
{
static int value=ERR_LIB_USER;
return(value++);
}
-void ERR_set_error_data(data,flags)
-char *data;
-int flags;
+void ERR_set_error_data(char *data, int flags)
{
ERR_STATE *es;
int i;
#include "pkcs12.h"
#include "err.h"
-void ERR_load_crypto_strings()
+void ERR_load_crypto_strings(void)
{
static int done=0;
#include "crypto.h"
#ifndef NO_FP_API
-void ERR_print_errors_fp(fp)
-FILE *fp;
+void ERR_print_errors_fp(FILE *fp)
{
unsigned long l;
char buf[200];
}
#endif
-void ERR_print_errors(bp)
-BIO *bp;
+void ERR_print_errors(BIO *bp)
{
unsigned long l;
char buf[256];
b64_free,
};
-BIO_METHOD *BIO_f_base64()
+BIO_METHOD *BIO_f_base64(void)
{
return(&methods_b64);
}
-static int b64_new(bi)
-BIO *bi;
+static int b64_new(BIO *bi)
{
BIO_B64_CTX *ctx;
return(1);
}
-static int b64_free(a)
-BIO *a;
+static int b64_free(BIO *a)
{
if (a == NULL) return(0);
Free(a->ptr);
return(1);
}
-static int b64_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int b64_read(BIO *b, char *out, int outl)
{
int ret=0,i,ii,j,k,x,n,num,ret_code=0;
BIO_B64_CTX *ctx;
return((ret == 0)?ret_code:ret);
}
-static int b64_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int b64_write(BIO *b, char *in, int inl)
{
int ret=inl,n,i;
BIO_B64_CTX *ctx;
return(ret);
}
-static long b64_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long b64_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO_B64_CTX *ctx;
long ret=1;
enc_free,
};
-BIO_METHOD *BIO_f_cipher()
+BIO_METHOD *BIO_f_cipher(void)
{
return(&methods_enc);
}
-static int enc_new(bi)
-BIO *bi;
+static int enc_new(BIO *bi)
{
BIO_ENC_CTX *ctx;
return(1);
}
-static int enc_free(a)
-BIO *a;
+static int enc_free(BIO *a)
{
BIO_ENC_CTX *b;
return(1);
}
-static int enc_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int enc_read(BIO *b, char *out, int outl)
{
int ret=0,i;
BIO_ENC_CTX *ctx;
return((ret == 0)?ctx->cont:ret);
}
-static int enc_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int enc_write(BIO *b, char *in, int inl)
{
int ret=0,n,i;
BIO_ENC_CTX *ctx;
return(ret);
}
-static long enc_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long enc_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO *dbio;
BIO_ENC_CTX *ctx,*dctx;
}
*/
-void BIO_set_cipher(b,c,k,i,e)
-BIO *b;
-const EVP_CIPHER *c;
-unsigned char *k;
-unsigned char *i;
-int e;
+void BIO_set_cipher(BIO *b, const EVP_CIPHER *c, unsigned char *k,
+ unsigned char *i, int e)
{
BIO_ENC_CTX *ctx;
md_free,
};
-BIO_METHOD *BIO_f_md()
+BIO_METHOD *BIO_f_md(void)
{
return(&methods_md);
}
-static int md_new(bi)
-BIO *bi;
+static int md_new(BIO *bi)
{
EVP_MD_CTX *ctx;
return(1);
}
-static int md_free(a)
-BIO *a;
+static int md_free(BIO *a)
{
if (a == NULL) return(0);
Free(a->ptr);
return(1);
}
-static int md_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int md_read(BIO *b, char *out, int outl)
{
int ret=0;
EVP_MD_CTX *ctx;
return(ret);
}
-static int md_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int md_write(BIO *b, char *in, int inl)
{
int ret=0;
EVP_MD_CTX *ctx;
return(ret);
}
-static long md_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long md_ctrl(BIO *b, int cmd, long num, char *ptr)
{
EVP_MD_CTX *ctx,*dctx,**pctx;
const EVP_MD **ppmd;
return(ret);
}
-static int md_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int md_gets(BIO *bp, char *buf, int size)
{
EVP_MD_CTX *ctx;
unsigned int ret;
ok_free,
};
-BIO_METHOD *BIO_f_reliable()
+BIO_METHOD *BIO_f_reliable(void)
{
return(&methods_ok);
}
-static int ok_new(bi)
-BIO *bi;
+static int ok_new(BIO *bi)
{
BIO_OK_CTX *ctx;
return(1);
}
-static int ok_free(a)
-BIO *a;
+static int ok_free(BIO *a)
{
if (a == NULL) return(0);
memset(a->ptr,0,sizeof(BIO_OK_CTX));
return(1);
}
-static int ok_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int ok_read(BIO *b, char *out, int outl)
{
int ret=0,i,n;
BIO_OK_CTX *ctx;
return(ret);
}
-static int ok_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int ok_write(BIO *b, char *in, int inl)
{
int ret=0,n,i;
BIO_OK_CTX *ctx;
return(ret);
}
-static long ok_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long ok_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO_OK_CTX *ctx;
EVP_MD *md;
#include "pkcs12.h"
#include "objects.h"
-void SSLeay_add_all_algorithms()
+void SSLeay_add_all_algorithms(void)
{
SSLeay_add_all_ciphers();
SSLeay_add_all_digests();
}
-void SSLeay_add_all_ciphers()
+void SSLeay_add_all_ciphers(void)
{
#ifndef NO_DES
EVP_add_cipher(EVP_des_cfb());
}
-void SSLeay_add_all_digests()
+void SSLeay_add_all_digests(void)
{
#ifndef NO_MD2
EVP_add_digest(EVP_md2());
#include "objects.h"
#include "evp.h"
-void EVP_DigestInit(ctx,type)
-EVP_MD_CTX *ctx;
-const EVP_MD *type;
+void EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type)
{
ctx->digest=type;
type->init(&(ctx->md));
}
-void EVP_DigestUpdate(ctx,data,count)
-EVP_MD_CTX *ctx;
-const unsigned char *data;
-unsigned int count;
+void EVP_DigestUpdate(EVP_MD_CTX *ctx, const unsigned char *data,
+ unsigned int count)
{
ctx->digest->update(&(ctx->md.base[0]),data,(unsigned long)count);
}
-void EVP_DigestFinal(ctx,md,size)
-EVP_MD_CTX *ctx;
-unsigned char *md;
-unsigned int *size;
+void EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *size)
{
ctx->digest->final(md,&(ctx->md.base[0]));
if (size != NULL)
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_des_ede_cbc()
+EVP_CIPHER *EVP_des_ede_cbc(void)
{
return(&d_cbc_ede_cipher2);
}
-EVP_CIPHER *EVP_des_ede3_cbc()
+EVP_CIPHER *EVP_des_ede3_cbc(void)
{
return(&d_cbc_ede_cipher3);
}
-static void des_cbc_ede_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_cbc_ede_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
}
}
-static void des_cbc_ede3_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_cbc_ede3_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
}
}
-static void des_cbc_ede_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_cbc_ede_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
des_ede3_cbc_encrypt(in,out,inl, ctx->c.des_ede.ks1,
ctx->c.des_ede.ks2,ctx->c.des_ede.ks3,
EVP_CIPHER_set_asn1_iv,
};
-EVP_CIPHER *EVP_bf_cbc()
+EVP_CIPHER *EVP_bf_cbc(void)
{
return(&bfish_cbc_cipher);
}
-static void bf_cbc_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void bf_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
BF_set_key(&(ctx->c.bf_ks),EVP_BLOWFISH_KEY_SIZE,key);
}
-static void bf_cbc_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void bf_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
BF_cbc_encrypt(
in,out,(long)inl,
EVP_CIPHER_set_asn1_iv,
};
-EVP_CIPHER *EVP_cast5_cbc()
+EVP_CIPHER *EVP_cast5_cbc(void)
{
return(&cast5_cbc_cipher);
}
-static void cast_cbc_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void cast_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
CAST_set_key(&(ctx->c.cast_ks),EVP_CAST5_KEY_SIZE,key);
}
-static void cast_cbc_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void cast_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
CAST_cbc_encrypt(
in,out,(long)inl,
EVP_CIPHER_set_asn1_iv,
};
-EVP_CIPHER *EVP_des_cbc()
+EVP_CIPHER *EVP_des_cbc(void)
{
return(&d_cbc_cipher);
}
-static void des_cbc_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
des_set_key(key,ctx->c.des_ks);
}
-static void des_cbc_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
des_ncbc_encrypt(in,out,inl,ctx->c.des_ks,&(ctx->iv[0]),ctx->encrypt);
}
EVP_CIPHER_set_asn1_iv,
};
-EVP_CIPHER *EVP_idea_cbc()
+EVP_CIPHER *EVP_idea_cbc(void)
{
return(&i_cbc_cipher);
}
-static void idea_cbc_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void idea_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
}
}
-static void idea_cbc_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void idea_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
idea_cbc_encrypt(
in,out,(long)inl,
rc2_get_asn1_type_and_iv,
};
-EVP_CIPHER *EVP_rc2_cbc()
+EVP_CIPHER *EVP_rc2_cbc(void)
{
return(&r2_cbc_cipher);
}
-EVP_CIPHER *EVP_rc2_64_cbc()
+EVP_CIPHER *EVP_rc2_64_cbc(void)
{
return(&r2_64_cbc_cipher);
}
-EVP_CIPHER *EVP_rc2_40_cbc()
+EVP_CIPHER *EVP_rc2_40_cbc(void)
{
return(&r2_40_cbc_cipher);
}
-static void rc2_cbc_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc2_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
key,EVP_CIPHER_CTX_key_length(ctx)*8);
}
-static void rc2_cbc_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc2_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
RC2_cbc_encrypt(
in,out,(long)inl,
ctx->encrypt);
}
-static int rc2_meth_to_magic(e)
-const EVP_CIPHER *e;
+static int rc2_meth_to_magic(const EVP_CIPHER *e)
{
int i;
else return(0);
}
-static EVP_CIPHER *rc2_magic_to_meth(i)
-int i;
+static EVP_CIPHER *rc2_magic_to_meth(int i)
{
if (i == RC2_128_MAGIC) return(EVP_rc2_cbc());
else if (i == RC2_64_MAGIC) return(EVP_rc2_64_cbc());
}
}
-static int rc2_get_asn1_type_and_iv(c,type)
-EVP_CIPHER_CTX *c;
-ASN1_TYPE *type;
+static int rc2_get_asn1_type_and_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
long num=0;
int i=0,l;
return(i);
}
-static int rc2_set_asn1_type_and_iv(c,type)
-EVP_CIPHER_CTX *c;
-ASN1_TYPE *type;
+static int rc2_set_asn1_type_and_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
long num;
int i=0,j;
NULL,
};
-EVP_CIPHER *EVP_rc5_32_12_16_cbc()
+EVP_CIPHER *EVP_rc5_32_12_16_cbc(void)
{
return(&rc5_32_12_16_cbc_cipher);
}
-static void r_32_12_16_cbc_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void r_32_12_16_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
key,RC5_12_ROUNDS);
}
-static void r_32_12_16_cbc_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void r_32_12_16_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
RC5_32_cbc_encrypt(
in,out,(long)inl,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_des_ede_cfb()
+EVP_CIPHER *EVP_des_ede_cfb(void)
{
return(&d_ede_cfb_cipher2);
}
-EVP_CIPHER *EVP_des_ede3_cfb()
+EVP_CIPHER *EVP_des_ede3_cfb(void)
{
return(&d_ede3_cfb_cipher3);
}
-static void des_ede_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ede_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
}
}
-static void des_ede3_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ede3_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
}
}
-static void des_ede_cfb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_ede_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
des_ede3_cfb64_encrypt(in,out,(long)inl,
ctx->c.des_ede.ks1,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_bf_cfb()
+EVP_CIPHER *EVP_bf_cfb(void)
{
return(&bfish_cfb_cipher);
}
-static void bf_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void bf_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
BF_set_key(&(ctx->c.bf_ks),EVP_BLOWFISH_KEY_SIZE,key);
}
-static void bf_cfb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void bf_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
BF_cfb64_encrypt(
in,out,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_cast5_cfb()
+EVP_CIPHER *EVP_cast5_cfb(void)
{
return(&cast5_cfb_cipher);
}
-static void cast_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void cast_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
CAST_set_key(&(ctx->c.cast_ks),EVP_CAST5_KEY_SIZE,key);
}
-static void cast_cfb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void cast_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
CAST_cfb64_encrypt(
in,out,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_des_cfb()
+EVP_CIPHER *EVP_des_cfb(void)
{
return(&d_cfb_cipher);
}
-static void des_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
des_set_key(key,ctx->c.des_ks);
}
-static void des_cfb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
des_cfb64_encrypt(
in,out,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_idea_cfb()
+EVP_CIPHER *EVP_idea_cfb(void)
{
return(&i_cfb_cipher);
}
-static void idea_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void idea_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
idea_set_encrypt_key(key,&(ctx->c.idea_ks));
}
-static void idea_cfb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void idea_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
idea_cfb64_encrypt(
in,out,(long)inl,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_rc2_cfb()
+EVP_CIPHER *EVP_rc2_cfb(void)
{
return(&r2_cfb_cipher);
}
-static void rc2_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc2_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
key,EVP_CIPHER_CTX_key_length(ctx)*8);
}
-static void rc2_cfb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc2_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
RC2_cfb64_encrypt(
in,out,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_rc5_32_12_16_cfb()
+EVP_CIPHER *EVP_rc5_32_12_16_cfb(void)
{
return(&rc5_cfb_cipher);
}
-static void rc5_32_12_16_cfb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc5_32_12_16_cfb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
RC5_12_ROUNDS);
}
-static void rc5_32_12_16_cfb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc5_32_12_16_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
RC5_32_cfb64_encrypt(
in,out,
NULL,
};
-EVP_CIPHER *EVP_des_ede()
+EVP_CIPHER *EVP_des_ede(void)
{
return(&d_ede_cipher2);
}
-EVP_CIPHER *EVP_des_ede3()
+EVP_CIPHER *EVP_des_ede3(void)
{
return(&d_ede3_cipher3);
}
-static void des_ede_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ede_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
{
}
}
-static void des_ede3_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ede3_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
{
}
}
-static void des_ede_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_ede_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
unsigned int i;
NULL,
};
-EVP_CIPHER *EVP_bf_ecb()
+EVP_CIPHER *EVP_bf_ecb(void)
{
return(&bfish_ecb_cipher);
}
-static void bf_ecb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void bf_ecb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
BF_set_key(&(ctx->c.bf_ks),EVP_BLOWFISH_KEY_SIZE,key);
}
-static void bf_ecb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void bf_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
unsigned int i;
NULL,
};
-EVP_CIPHER *EVP_cast5_ecb()
+EVP_CIPHER *EVP_cast5_ecb(void)
{
return(&cast5_ecb_cipher);
}
-static void cast_ecb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void cast_ecb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
CAST_set_key(&(ctx->c.cast_ks),EVP_CAST5_KEY_SIZE,key);
}
-static void cast_ecb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void cast_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
unsigned int i;
NULL,
};
-EVP_CIPHER *EVP_des_ecb()
+EVP_CIPHER *EVP_des_ecb(void)
{
return(&d_ecb_cipher);
}
-static void des_ecb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ecb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
des_set_key(key,ctx->c.des_ks);
}
-static void des_ecb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
unsigned int i;
NULL,
};
-EVP_CIPHER *EVP_idea_ecb()
+EVP_CIPHER *EVP_idea_ecb(void)
{
return(&i_ecb_cipher);
}
-static void idea_ecb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void idea_ecb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
{
}
}
-static void idea_ecb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void idea_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
unsigned int i;
NULL,
};
-EVP_CIPHER *EVP_rc2_ecb()
+EVP_CIPHER *EVP_rc2_ecb(void)
{
return(&r2_ecb_cipher);
}
-static void rc2_ecb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc2_ecb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
RC2_set_key(&(ctx->c.rc2_ks),EVP_CIPHER_CTX_key_length(ctx),
key,EVP_CIPHER_CTX_key_length(ctx)*8);
}
-static void rc2_ecb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc2_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
unsigned int i;
NULL,
};
-EVP_CIPHER *EVP_rc5_32_12_16_ecb()
+EVP_CIPHER *EVP_rc5_32_12_16_ecb(void)
{
return(&rc5_ecb_cipher);
}
-static void rc5_32_12_16_ecb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc5_32_12_16_ecb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
RC5_32_set_key(&(ctx->c.rc5_ks),EVP_RC5_32_12_16_KEY_SIZE,key,
RC5_12_ROUNDS);
}
-static void rc5_32_12_16_ecb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc5_32_12_16_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
unsigned int i;
NULL,
};
-EVP_CIPHER *EVP_enc_null()
+EVP_CIPHER *EVP_enc_null(void)
{
return(&n_cipher);
}
-static void null_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void null_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
memset(&(ctx->c),0,sizeof(ctx->c));
}
-static void null_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void null_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
if (in != out)
memcpy((char *)out,(char *)in,(int)inl);
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_des_ede_ofb()
+EVP_CIPHER *EVP_des_ede_ofb(void)
{
return(&d_ede_ofb_cipher2);
}
-EVP_CIPHER *EVP_des_ede3_ofb()
+EVP_CIPHER *EVP_des_ede3_ofb(void)
{
return(&d_ede3_ofb_cipher3);
}
-static void des_ede_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ede_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
}
}
-static void des_ede3_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ede3_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
}
}
-static void des_ede_ofb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_ede_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
des_ede3_ofb64_encrypt(in,out,inl,ctx->c.des_ede.ks1,
ctx->c.des_ede.ks2, ctx->c.des_ede.ks3,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_bf_ofb()
+EVP_CIPHER *EVP_bf_ofb(void)
{
return(&bfish_ofb_cipher);
}
-static void bf_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void bf_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
BF_set_key(&(ctx->c.bf_ks),EVP_BLOWFISH_KEY_SIZE,key);
}
-static void bf_ofb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void bf_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
BF_ofb64_encrypt(
in,out,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_cast5_ofb()
+EVP_CIPHER *EVP_cast5_ofb(void)
{
return(&cast5_ofb_cipher);
}
-static void cast_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void cast_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
CAST_set_key(&(ctx->c.cast_ks),EVP_CAST5_KEY_SIZE,key);
}
-static void cast_ofb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void cast_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
CAST_ofb64_encrypt(
in,out,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_des_ofb()
+EVP_CIPHER *EVP_des_ofb(void)
{
return(&d_ofb_cipher);
}
-static void des_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void des_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
des_set_key(key,ctx->c.des_ks);
}
-static void des_ofb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void des_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
des_ofb64_encrypt(in,out,inl,ctx->c.des_ks,&(ctx->iv[0]),&ctx->num);
}
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_idea_ofb()
+EVP_CIPHER *EVP_idea_ofb(void)
{
return(&i_ofb_cipher);
}
-static void idea_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void idea_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
idea_set_encrypt_key(key,&(ctx->c.idea_ks));
}
-static void idea_ofb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void idea_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
idea_ofb64_encrypt(
in,out,(long)inl,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_rc2_ofb()
+EVP_CIPHER *EVP_rc2_ofb(void)
{
return(&r2_ofb_cipher);
}
-static void rc2_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc2_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
key,EVP_CIPHER_CTX_key_length(ctx)*8);
}
-static void rc2_ofb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc2_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
RC2_ofb64_encrypt(
in,out,
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_rc5_32_12_16_ofb()
+EVP_CIPHER *EVP_rc5_32_12_16_ofb(void)
{
return(&rc5_ofb_cipher);
}
-static void rc5_32_12_16_ofb_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc5_32_12_16_ofb_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
ctx->num=0;
RC5_12_ROUNDS);
}
-static void rc5_32_12_16_ofb_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc5_32_12_16_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
RC5_32_ofb64_encrypt(
in,out,
rc4_cipher,
};
-EVP_CIPHER *EVP_rc4()
+EVP_CIPHER *EVP_rc4(void)
{
return(&r4_cipher);
}
-EVP_CIPHER *EVP_rc4_40()
+EVP_CIPHER *EVP_rc4_40(void)
{
return(&r4_40_cipher);
}
-static void rc4_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void rc4_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (key != NULL)
memcpy(&(ctx->c.rc4.key[0]),key,EVP_CIPHER_CTX_key_length(ctx));
ctx->c.rc4.key);
}
-static void rc4_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
RC4(&(ctx->c.rc4.ks),inl,in,out);
}
EVP_CIPHER_get_asn1_iv,
};
-EVP_CIPHER *EVP_desx_cbc()
+EVP_CIPHER *EVP_desx_cbc(void)
{
return(&d_xcbc_cipher);
}
-static void desx_cbc_init_key(ctx,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+static void desx_cbc_init_key(EVP_CIPHER_CTX *ctx, unsigned char *key,
+ unsigned char *iv, int enc)
{
if (iv != NULL)
memcpy(&(ctx->oiv[0]),iv,8);
}
}
-static void desx_cbc_cipher(ctx,out,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-unsigned char *in;
-unsigned int inl;
+static void desx_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+ unsigned char *in, unsigned int inl)
{
des_xcbc_encrypt(in,out,inl,ctx->c.desx_cbc.ks,
&(ctx->iv[0]),
0x31,0x32,0x33,0xFF,0xFF,0xFF,0xFF,0xFF,
};
-void EVP_EncodeInit(ctx)
-EVP_ENCODE_CTX *ctx;
+void EVP_EncodeInit(EVP_ENCODE_CTX *ctx)
{
ctx->length=48;
ctx->num=0;
ctx->line_num=0;
}
-void EVP_EncodeUpdate(ctx,out,outl,in,inl)
-EVP_ENCODE_CTX *ctx;
-unsigned char *out;
-int *outl;
-unsigned char *in;
-int inl;
+void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
+ unsigned char *in, int inl)
{
int i,j;
unsigned int total=0;
*outl=total;
}
-void EVP_EncodeFinal(ctx,out,outl)
-EVP_ENCODE_CTX *ctx;
-unsigned char *out;
-int *outl;
+void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
{
unsigned int ret=0;
*outl=ret;
}
-int EVP_EncodeBlock(t,f,dlen)
-unsigned char *t,*f;
-int dlen;
+int EVP_EncodeBlock(unsigned char *t, unsigned char *f, int dlen)
{
int i,ret=0;
unsigned long l;
return(ret);
}
-void EVP_DecodeInit(ctx)
-EVP_ENCODE_CTX *ctx;
+void EVP_DecodeInit(EVP_ENCODE_CTX *ctx)
{
ctx->length=30;
ctx->num=0;
* 0 for last line
* 1 for full line
*/
-int EVP_DecodeUpdate(ctx,out,outl,in,inl)
-EVP_ENCODE_CTX *ctx;
-unsigned char *out;
-int *outl;
-unsigned char *in;
-int inl;
+int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
+ unsigned char *in, int inl)
{
int seof= -1,eof=0,rv= -1,ret=0,i,v,tmp,n,ln,tmp2,exp_nl;
unsigned char *d;
return(rv);
}
-int EVP_DecodeBlock(t,f,n)
-unsigned char *t,*f;
-int n;
+int EVP_DecodeBlock(unsigned char *t, unsigned char *f, int n)
{
int i,ret=0,a,b,c,d;
unsigned long l;
return(ret);
}
-int EVP_DecodeFinal(ctx,out,outl)
-EVP_ENCODE_CTX *ctx;
-unsigned char *out;
-int *outl;
+int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
{
int i;
}
#ifdef undef
-int EVP_DecodeValid(buf,len)
-unsigned char *buf;
-int len;
+int EVP_DecodeValid(unsigned char *buf, int len)
{
int i,num=0,bad=0;
const char *EVP_version="EVP" OPENSSL_VERSION_PTEXT;
-void EVP_CIPHER_CTX_init(ctx)
-EVP_CIPHER_CTX *ctx;
+void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)
{
memset(ctx,0,sizeof(EVP_CIPHER_CTX));
/* ctx->cipher=NULL; */
}
-void EVP_CipherInit(ctx,data,key,iv,enc)
-EVP_CIPHER_CTX *ctx;
-const EVP_CIPHER *data;
-unsigned char *key;
-unsigned char *iv;
-int enc;
+void EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *data,
+ unsigned char *key, unsigned char *iv, int enc)
{
if (enc)
EVP_EncryptInit(ctx,data,key,iv);
EVP_DecryptInit(ctx,data,key,iv);
}
-void EVP_CipherUpdate(ctx,out,outl,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
-unsigned char *in;
-int inl;
+void EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
+ unsigned char *in, int inl)
{
if (ctx->encrypt)
EVP_EncryptUpdate(ctx,out,outl,in,inl);
else EVP_DecryptUpdate(ctx,out,outl,in,inl);
}
-int EVP_CipherFinal(ctx,out,outl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
+int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
{
if (ctx->encrypt)
{
else return(EVP_DecryptFinal(ctx,out,outl));
}
-void EVP_EncryptInit(ctx,cipher,key,iv)
-EVP_CIPHER_CTX *ctx;
-const EVP_CIPHER *cipher;
-unsigned char *key;
-unsigned char *iv;
+void EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+ unsigned char *key, unsigned char *iv)
{
if (cipher != NULL)
ctx->cipher=cipher;
ctx->buf_len=0;
}
-void EVP_DecryptInit(ctx,cipher,key,iv)
-EVP_CIPHER_CTX *ctx;
-const EVP_CIPHER *cipher;
-unsigned char *key;
-unsigned char *iv;
+void EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+ unsigned char *key, unsigned char *iv)
{
if (cipher != NULL)
ctx->cipher=cipher;
}
-void EVP_EncryptUpdate(ctx,out,outl,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
-unsigned char *in;
-int inl;
+void EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
+ unsigned char *in, int inl)
{
int i,j,bl;
ctx->buf_len=i;
}
-void EVP_EncryptFinal(ctx,out,outl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
+void EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
{
int i,n,b,bl;
*outl=b;
}
-void EVP_DecryptUpdate(ctx,out,outl,in,inl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
-unsigned char *in;
-int inl;
+void EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
+ unsigned char *in, int inl)
{
int b,bl,n;
int keep_last=0;
}
}
-int EVP_DecryptFinal(ctx,out,outl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
+int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
{
int i,b;
int n;
return(1);
}
-void EVP_CIPHER_CTX_cleanup(c)
-EVP_CIPHER_CTX *c;
+void EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
{
if ((c->cipher != NULL) && (c->cipher->cleanup != NULL))
c->cipher->cleanup(c);
#endif
-void ERR_load_EVP_strings()
+void ERR_load_EVP_strings(void)
{
static int init=1;
/* should be init to zeros. */
static char prompt_string[80];
-void EVP_set_pw_prompt(prompt)
-char *prompt;
+void EVP_set_pw_prompt(char *prompt)
{
if (prompt == NULL)
prompt_string[0]='\0';
strncpy(prompt_string,prompt,79);
}
-char *EVP_get_pw_prompt()
+char *EVP_get_pw_prompt(void)
{
if (prompt_string[0] == '\0')
return(NULL);
int des_read_pw_string(char *buf,int len,char *prompt,int verify);
#endif
-int EVP_read_pw_string(buf,len,prompt,verify)
-char *buf;
-int len;
-const char *prompt;
-int verify;
+int EVP_read_pw_string(char *buf, int len, const char *prompt, int verify)
{
if ((prompt == NULL) && (prompt_string[0] != '\0'))
prompt=prompt_string;
return(des_read_pw_string(buf,len,prompt,verify));
}
-int EVP_BytesToKey(type,md,salt,data,datal,count,key,iv)
-const EVP_CIPHER *type;
-EVP_MD *md;
-unsigned char *salt;
-unsigned char *data;
-int datal;
-int count;
-unsigned char *key;
-unsigned char *iv;
+int EVP_BytesToKey(const EVP_CIPHER *type, EVP_MD *md, unsigned char *salt,
+ unsigned char *data, int datal, int count, unsigned char *key,
+ unsigned char *iv)
{
EVP_MD_CTX c;
unsigned char md_buf[EVP_MAX_MD_SIZE];
#include "evp.h"
#include "objects.h"
-int EVP_CIPHER_param_to_asn1(c,type)
-EVP_CIPHER_CTX *c;
-ASN1_TYPE *type;
+int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
int ret;
return(ret);
}
-int EVP_CIPHER_asn1_to_param(c,type)
-EVP_CIPHER_CTX *c;
-ASN1_TYPE *type;
+int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
int ret;
return(ret);
}
-int EVP_CIPHER_get_asn1_iv(c,type)
-EVP_CIPHER_CTX *c;
-ASN1_TYPE *type;
+int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
int i=0,l;
return(i);
}
-int EVP_CIPHER_set_asn1_iv(c,type)
-EVP_CIPHER_CTX *c;
-ASN1_TYPE *type;
+int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
{
int i=0,j;
EVP_PBE_KEYGEN *keygen;
} EVP_PBE_CTL;
-int EVP_PBE_CipherInit (pbe_obj, pass, passlen, salt, saltlen, iter, ctx, en_de)
-ASN1_OBJECT *pbe_obj;
-int passlen, saltlen, iter;
-unsigned char *pass, *salt;
-EVP_CIPHER_CTX *ctx;
-int en_de;
+int EVP_PBE_CipherInit (ASN1_OBJECT *pbe_obj, unsigned char *pass, int passlen,
+ unsigned char *salt, int saltlen, int iter, EVP_CIPHER_CTX *ctx,
+ int en_de)
{
EVP_PBE_CTL *pbetmp, pbelu;
/* Setup a PBE algorithm but take most parameters from AlgorithmIdentifier */
-int EVP_PBE_ALGOR_CipherInit (algor, pass, passlen, ctx, en_de)
-X509_ALGOR *algor;
-unsigned char *pass;
-int passlen;
-EVP_CIPHER_CTX *ctx;
-int en_de;
+int EVP_PBE_ALGOR_CipherInit (X509_ALGOR *algor, unsigned char *pass,
+ int passlen, EVP_CIPHER_CTX *ctx, int en_de)
{
PBEPARAM *pbe;
int saltlen, iter;
}
-static int pbe_cmp (pbe1, pbe2)
-EVP_PBE_CTL **pbe1, **pbe2;
+static int pbe_cmp (EVP_PBE_CTL **pbe1, EVP_PBE_CTL **pbe2)
{
return ((*pbe1)->pbe_nid - (*pbe2)->pbe_nid);
}
/* Add a PBE algorithm */
-int EVP_PBE_alg_add (nid, cipher, md, keygen)
-int nid;
-EVP_CIPHER *cipher;
-EVP_MD *md;
-EVP_PBE_KEYGEN *keygen;
+int EVP_PBE_alg_add (int nid, EVP_CIPHER *cipher, EVP_MD *md,
+ EVP_PBE_KEYGEN *keygen)
{
EVP_PBE_CTL *pbe_tmp;
if (!pbe_algs) pbe_algs = sk_new (pbe_cmp);
return 1;
}
-void EVP_PBE_cleanup()
+void EVP_PBE_cleanup(void)
{
sk_pop_free(pbe_algs, FreeFunc);
}
/* Extract a private key from a PKCS8 structure */
-EVP_PKEY *EVP_PKCS82PKEY (p8)
-PKCS8_PRIV_KEY_INFO *p8;
+EVP_PKEY *EVP_PKCS82PKEY (PKCS8_PRIV_KEY_INFO *p8)
{
EVP_PKEY *pkey;
RSA *rsa;
/* Turn a private key into a PKCS8 structure */
-PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(pkey)
-EVP_PKEY *pkey;
+PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey)
{
PKCS8_PRIV_KEY_INFO *p8;
ASN1_INTEGER *dpkey;
return p8;
}
-PKCS8_PRIV_KEY_INFO *PKCS8_set_broken(p8, broken)
-PKCS8_PRIV_KEY_INFO *p8;
-int broken;
+PKCS8_PRIV_KEY_INFO *PKCS8_set_broken(PKCS8_PRIV_KEY_INFO *p8, int broken)
{
switch (broken) {
sizeof(EVP_MD *)+sizeof(SHA_CTX),
};
-EVP_MD *EVP_dss()
+EVP_MD *EVP_dss(void)
{
return(&dsa_md);
}
sizeof(EVP_MD *)+sizeof(SHA_CTX),
};
-EVP_MD *EVP_dss1()
+EVP_MD *EVP_dss1(void)
{
return(&dss1_md);
}
sizeof(EVP_MD *)+sizeof(MD2_CTX),
};
-EVP_MD *EVP_md2()
+EVP_MD *EVP_md2(void)
{
return(&md2_md);
}
sizeof(EVP_MD *)+sizeof(MD5_CTX),
};
-EVP_MD *EVP_md5()
+EVP_MD *EVP_md5(void)
{
return(&md5_md);
}
sizeof(EVP_MD *)+sizeof(MDC2_CTX),
};
-EVP_MD *EVP_mdc2()
+EVP_MD *EVP_mdc2(void)
{
return(&mdc2_md);
}
#include "objects.h"
#include "x509.h"
-static void function()
+static void function(void)
{
}
sizeof(EVP_MD *),
};
-EVP_MD *EVP_md_null()
+EVP_MD *EVP_md_null(void)
{
return(&null_md);
}
sizeof(EVP_MD *)+sizeof(RIPEMD160_CTX),
};
-EVP_MD *EVP_ripemd160()
+EVP_MD *EVP_ripemd160(void)
{
return(&ripemd160_md);
}
sizeof(EVP_MD *)+sizeof(SHA_CTX),
};
-EVP_MD *EVP_sha()
+EVP_MD *EVP_sha(void)
{
return(&sha_md);
}
sizeof(EVP_MD *)+sizeof(SHA_CTX),
};
-EVP_MD *EVP_sha1()
+EVP_MD *EVP_sha1(void)
{
return(&sha1_md);
}
#include "objects.h"
#include "x509.h"
-int EVP_add_cipher(c)
-EVP_CIPHER *c;
+int EVP_add_cipher(EVP_CIPHER *c)
{
int r;
return(r);
}
-int EVP_add_digest(md)
-EVP_MD *md;
+int EVP_add_digest(EVP_MD *md)
{
int r;
const char *name;
return(r);
}
-const EVP_CIPHER *EVP_get_cipherbyname(name)
-const char *name;
+const EVP_CIPHER *EVP_get_cipherbyname(const char *name)
{
const EVP_CIPHER *cp;
return(cp);
}
-const EVP_MD *EVP_get_digestbyname(name)
-const char *name;
+const EVP_MD *EVP_get_digestbyname(const char *name)
{
const EVP_MD *cp;
return(cp);
}
-void EVP_cleanup()
+void EVP_cleanup(void)
{
OBJ_NAME_cleanup(OBJ_NAME_TYPE_CIPHER_METH);
OBJ_NAME_cleanup(OBJ_NAME_TYPE_MD_METH);
#include "objects.h"
#include "x509.h"
-int EVP_PKEY_decrypt(key,ek,ekl,priv)
-unsigned char *key;
-unsigned char *ek;
-int ekl;
-EVP_PKEY *priv;
+int EVP_PKEY_decrypt(unsigned char *key, unsigned char *ek, int ekl,
+ EVP_PKEY *priv)
{
int ret= -1;
#include "objects.h"
#include "x509.h"
-int EVP_PKEY_encrypt(ek,key,key_len,pubk)
-unsigned char *ek;
-unsigned char *key;
-int key_len;
-EVP_PKEY *pubk;
+int EVP_PKEY_encrypt(unsigned char *ek, unsigned char *key, int key_len,
+ EVP_PKEY *pubk)
{
int ret=0;
static void EVP_PKEY_free_it();
#endif
-int EVP_PKEY_bits(pkey)
-EVP_PKEY *pkey;
+int EVP_PKEY_bits(EVP_PKEY *pkey)
{
#ifndef NO_RSA
if (pkey->type == EVP_PKEY_RSA)
return(0);
}
-int EVP_PKEY_size(pkey)
-EVP_PKEY *pkey;
+int EVP_PKEY_size(EVP_PKEY *pkey)
{
if (pkey == NULL)
return(0);
return(0);
}
-int EVP_PKEY_save_parameters(pkey,mode)
-EVP_PKEY *pkey;
-int mode;
+int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode)
{
#ifndef NO_DSA
if (pkey->type == EVP_PKEY_DSA)
return(0);
}
-int EVP_PKEY_copy_parameters(to,from)
-EVP_PKEY *to,*from;
+int EVP_PKEY_copy_parameters(EVP_PKEY *to, EVP_PKEY *from)
{
if (to->type != from->type)
{
return(0);
}
-int EVP_PKEY_missing_parameters(pkey)
-EVP_PKEY *pkey;
+int EVP_PKEY_missing_parameters(EVP_PKEY *pkey)
{
#ifndef NO_DSA
if (pkey->type == EVP_PKEY_DSA)
return(0);
}
-int EVP_PKEY_cmp_parameters(a,b)
-EVP_PKEY *a,*b;
+int EVP_PKEY_cmp_parameters(EVP_PKEY *a, EVP_PKEY *b)
{
#ifndef NO_DSA
if ((a->type == EVP_PKEY_DSA) && (b->type == EVP_PKEY_DSA))
return(-1);
}
-EVP_PKEY *EVP_PKEY_new()
+EVP_PKEY *EVP_PKEY_new(void)
{
EVP_PKEY *ret;
return(ret);
}
-int EVP_PKEY_assign(pkey,type,key)
-EVP_PKEY *pkey;
-int type;
-char *key;
+int EVP_PKEY_assign(EVP_PKEY *pkey, int type, char *key)
{
if (pkey == NULL) return(0);
if (pkey->pkey.ptr != NULL)
return(1);
}
-int EVP_PKEY_type(type)
-int type;
+int EVP_PKEY_type(int type)
{
switch (type)
{
}
}
-void EVP_PKEY_free(x)
-EVP_PKEY *x;
+void EVP_PKEY_free(EVP_PKEY *x)
{
int i;
Free((char *)x);
}
-static void EVP_PKEY_free_it(x)
-EVP_PKEY *x;
+static void EVP_PKEY_free_it(EVP_PKEY *x)
{
switch (x->type)
{
#include "objects.h"
#include "x509.h"
-int EVP_OpenInit(ctx,type,ek,ekl,iv,priv)
-EVP_CIPHER_CTX *ctx;
-EVP_CIPHER *type;
-unsigned char *ek;
-int ekl;
-unsigned char *iv;
-EVP_PKEY *priv;
+int EVP_OpenInit(EVP_CIPHER_CTX *ctx, EVP_CIPHER *type, unsigned char *ek,
+ int ekl, unsigned char *iv, EVP_PKEY *priv)
{
unsigned char *key=NULL;
int i,size=0,ret=0;
return(ret);
}
-int EVP_OpenFinal(ctx,out,outl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
+int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
{
int i;
#include "objects.h"
#include "x509.h"
-int EVP_SealInit(ctx,type,ek,ekl,iv,pubk,npubk)
-EVP_CIPHER_CTX *ctx;
-EVP_CIPHER *type;
-unsigned char **ek;
-int *ekl;
-unsigned char *iv;
-EVP_PKEY **pubk;
-int npubk;
+int EVP_SealInit(EVP_CIPHER_CTX *ctx, EVP_CIPHER *type, unsigned char **ek,
+ int *ekl, unsigned char *iv, EVP_PKEY **pubk, int npubk)
{
unsigned char key[EVP_MAX_KEY_LENGTH];
int i;
}
*/
-void EVP_SealFinal(ctx,out,outl)
-EVP_CIPHER_CTX *ctx;
-unsigned char *out;
-int *outl;
+void EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
{
EVP_EncryptFinal(ctx,out,outl);
EVP_EncryptInit(ctx,NULL,NULL,NULL);
#include "x509.h"
#ifdef undef
-void EVP_SignInit(ctx,type)
-EVP_MD_CTX *ctx;
-EVP_MD *type;
+void EVP_SignInit(EVP_MD_CTX *ctx, EVP_MD *type)
{
EVP_DigestInit(ctx,type);
}
-void EVP_SignUpdate(ctx,data,count)
-EVP_MD_CTX *ctx;
-unsigned char *data;
-unsigned int count;
+void EVP_SignUpdate(EVP_MD_CTX *ctx, unsigned char *data,
+ unsigned int count)
{
EVP_DigestUpdate(ctx,data,count);
}
#endif
-int EVP_SignFinal(ctx,sigret,siglen,pkey)
-EVP_MD_CTX *ctx;
-unsigned char *sigret;
-unsigned int *siglen;
-EVP_PKEY *pkey;
+int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, unsigned int *siglen,
+ EVP_PKEY *pkey)
{
unsigned char m[EVP_MAX_MD_SIZE];
unsigned int m_len;
#include "objects.h"
#include "x509.h"
-int EVP_VerifyFinal(ctx,sigbuf,siglen,pkey)
-EVP_MD_CTX *ctx;
-unsigned char *sigbuf;
-unsigned int siglen;
-EVP_PKEY *pkey;
+int EVP_VerifyFinal(EVP_MD_CTX *ctx, unsigned char *sigbuf,
+ unsigned int siglen, EVP_PKEY *pkey)
{
unsigned char m[EVP_MAX_MD_SIZE];
unsigned int m_len;
#include "lhash.h"
#include "cryptlib.h"
-int CRYPTO_get_ex_new_index(idx,skp,argl,argp,new_func,dup_func,free_func)
-int idx;
-STACK **skp;
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
+int CRYPTO_get_ex_new_index(int idx, STACK **skp, long argl, char *argp,
+ int (*new_func)(), int (*dup_func)(), void (*free_func)())
{
int ret= -1;
CRYPTO_EX_DATA_FUNCS *a;
return(idx);
}
-int CRYPTO_set_ex_data(ad,idx,val)
-CRYPTO_EX_DATA *ad;
-int idx;
-char *val;
+int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, char *val)
{
int i;
return(1);
}
-char *CRYPTO_get_ex_data(ad,idx)
-CRYPTO_EX_DATA *ad;
-int idx;
+char *CRYPTO_get_ex_data(CRYPTO_EX_DATA *ad, int idx)
{
if (ad->sk == NULL)
return(0);
* being duplicated, a pointer to the
* 'new' object to be inserted, the index, and the argi/argp
*/
-int CRYPTO_dup_ex_data(meth,to,from)
-STACK *meth;
-CRYPTO_EX_DATA *to,*from;
+int CRYPTO_dup_ex_data(STACK *meth, CRYPTO_EX_DATA *to,
+ CRYPTO_EX_DATA *from)
{
int i,j,m,r;
CRYPTO_EX_DATA_FUNCS *mm;
}
/* Call each free callback */
-void CRYPTO_free_ex_data(meth,obj,ad)
-STACK *meth;
-char *obj;
-CRYPTO_EX_DATA *ad;
+void CRYPTO_free_ex_data(STACK *meth, char *obj, CRYPTO_EX_DATA *ad)
{
CRYPTO_EX_DATA_FUNCS *m;
char *ptr;
}
}
-void CRYPTO_new_ex_data(meth,obj,ad)
-STACK *meth;
-char *obj;
-CRYPTO_EX_DATA *ad;
+void CRYPTO_new_ex_data(STACK *meth, char *obj, CRYPTO_EX_DATA *ad)
{
CRYPTO_EX_DATA_FUNCS *m;
char *ptr;
#include <string.h>
#include "hmac.h"
-void HMAC_Init(ctx,key,len,md)
-HMAC_CTX *ctx;
-unsigned char *key;
-int len;
-const EVP_MD *md;
+void HMAC_Init(HMAC_CTX *ctx, unsigned char *key, int len, const EVP_MD *md)
{
int i,j,reset=0;
unsigned char pad[HMAC_MAX_MD_CBLOCK];
memcpy(&ctx->md_ctx,&ctx->i_ctx,sizeof(ctx->i_ctx));
}
-void HMAC_Update(ctx,data,len)
-HMAC_CTX *ctx;
-unsigned char *data;
-int len;
+void HMAC_Update(HMAC_CTX *ctx, unsigned char *data, int len)
{
EVP_DigestUpdate(&(ctx->md_ctx),data,len);
}
-void HMAC_Final(ctx,md,len)
-HMAC_CTX *ctx;
-unsigned char *md;
-unsigned int *len;
+void HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
{
int j;
unsigned int i;
EVP_DigestFinal(&(ctx->md_ctx),md,len);
}
-void HMAC_cleanup(ctx)
-HMAC_CTX *ctx;
+void HMAC_cleanup(HMAC_CTX *ctx)
{
memset(ctx,0,sizeof(HMAC_CTX));
}
-unsigned char *HMAC(evp_md,key,key_len,d,n,md,md_len)
-EVP_MD *evp_md;
-unsigned char *key;
-int key_len;
-unsigned char *d;
-int n;
-unsigned char *md;
-unsigned int *md_len;
+unsigned char *HMAC(EVP_MD *evp_md, unsigned char *key, int key_len,
+ unsigned char *d, int n, unsigned char *md, unsigned int *md_len)
{
HMAC_CTX c;
static unsigned char m[EVP_MAX_MD_SIZE];
static char *pt();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
char *p;
return(0);
}
-static char *pt(md)
-unsigned char *md;
+static char *pt(unsigned char *md)
{
int i;
static char buf[80];
#include "idea.h"
#include "idea_lcl.h"
-void idea_cbc_encrypt(in, out, length, ks, iv, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-IDEA_KEY_SCHEDULE *ks;
-unsigned char *iv;
-int encrypt;
+void idea_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+ IDEA_KEY_SCHEDULE *ks, unsigned char *iv, int encrypt)
{
register unsigned long tin0,tin1;
register unsigned long tout0,tout1,xor0,xor1;
tin[0]=tin[1]=0;
}
-void idea_encrypt(d,key)
-unsigned long *d;
-IDEA_KEY_SCHEDULE *key;
+void idea_encrypt(unsigned long *d, IDEA_KEY_SCHEDULE *key)
{
register IDEA_INT *p;
register unsigned long x1,x2,x3,x4,t0,t1,ul;
* 64bit block we have used is contained in *num;
*/
-void idea_cfb64_encrypt(in, out, length, schedule, ivec, num, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-IDEA_KEY_SCHEDULE *schedule;
-unsigned char *ivec;
-int *num;
-int encrypt;
+void idea_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ IDEA_KEY_SCHEDULE *schedule, unsigned char *ivec, int *num,
+ int encrypt)
{
register unsigned long v0,v1,t;
register int n= *num;
const char *IDEA_version="IDEA" OPENSSL_VERSION_PTEXT;
-const char *idea_options()
+const char *idea_options(void)
{
if (sizeof(short) != sizeof(IDEA_INT))
return("idea(int)");
return("idea(short)");
}
-void idea_ecb_encrypt(in, out, ks)
-unsigned char *in;
-unsigned char *out;
-IDEA_KEY_SCHEDULE *ks;
+void idea_ecb_encrypt(unsigned char *in, unsigned char *out,
+ IDEA_KEY_SCHEDULE *ks)
{
unsigned long l0,l1,d[2];
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void idea_ofb64_encrypt(in, out, length, schedule, ivec, num)
-unsigned char *in;
-unsigned char *out;
-long length;
-IDEA_KEY_SCHEDULE *schedule;
-unsigned char *ivec;
-int *num;
+void idea_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ IDEA_KEY_SCHEDULE *schedule, unsigned char *ivec, int *num)
{
register unsigned long v0,v1,t;
register int n= *num;
static IDEA_INT inverse();
#endif
-void idea_set_encrypt_key(key, ks)
-unsigned char *key;
-IDEA_KEY_SCHEDULE *ks;
+void idea_set_encrypt_key(unsigned char *key, IDEA_KEY_SCHEDULE *ks)
{
int i;
register IDEA_INT *kt,*kf,r0,r1,r2;
}
}
-void idea_set_decrypt_key(ek, dk)
-IDEA_KEY_SCHEDULE *ek;
-IDEA_KEY_SCHEDULE *dk;
+void idea_set_decrypt_key(IDEA_KEY_SCHEDULE *ek, IDEA_KEY_SCHEDULE *dk)
{
int r;
register IDEA_INT *fp,*tp,t;
}
/* taken directly from the 'paper' I'll have a look at it later */
-static IDEA_INT inverse(xin)
-unsigned int xin;
+static IDEA_INT inverse(unsigned int xin)
{
long n1,n2,q,r,b1,b2,t;
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
static char *pt();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
IDEA_KEY_SCHEDULE key,dkey;
return(err);
}
-static int cfb64_test(cfb_cipher)
-unsigned char *cfb_cipher;
+static int cfb64_test(unsigned char *cfb_cipher)
{
IDEA_KEY_SCHEDULE eks,dks;
int err=0,i,n;
return(err);
}
-static char *pt(p)
-unsigned char *p;
+static char *pt(unsigned char *p)
{
static char bufs[10][20];
static int bnum=0;
#ifndef HEADER_BIO_H
-void lh_stats(lh, out)
-LHASH *lh;
-FILE *out;
+void lh_stats(LHASH *lh, FILE *out)
{
fprintf(out,"num_items = %lu\n",lh->num_items);
fprintf(out,"num_nodes = %u\n",lh->num_nodes);
#endif
}
-void lh_node_stats(lh, out)
-LHASH *lh;
-FILE *out;
+void lh_node_stats(LHASH *lh, FILE *out)
{
LHASH_NODE *n;
unsigned int i,num;
}
}
-void lh_node_usage_stats(lh, out)
-LHASH *lh;
-FILE *out;
+void lh_node_usage_stats(LHASH *lh, FILE *out)
{
LHASH_NODE *n;
unsigned long num;
#else
#ifndef NO_FP_API
-void lh_stats(lh,fp)
-LHASH *lh;
-FILE *fp;
+void lh_stats(LHASH *lh, FILE *fp)
{
BIO *bp;
end:;
}
-void lh_node_stats(lh,fp)
-LHASH *lh;
-FILE *fp;
+void lh_node_stats(LHASH *lh, FILE *fp)
{
BIO *bp;
end:;
}
-void lh_node_usage_stats(lh,fp)
-LHASH *lh;
-FILE *fp;
+void lh_node_usage_stats(LHASH *lh, FILE *fp)
{
BIO *bp;
#endif
-void lh_stats_bio(lh, out)
-LHASH *lh;
-BIO *out;
+void lh_stats_bio(LHASH *lh, BIO *out)
{
char buf[128];
#endif
}
-void lh_node_stats_bio(lh, out)
-LHASH *lh;
-BIO *out;
+void lh_node_stats_bio(LHASH *lh, BIO *out)
{
LHASH_NODE *n;
unsigned int i,num;
}
}
-void lh_node_usage_stats_bio(lh, out)
-LHASH *lh;
-BIO *out;
+void lh_node_usage_stats_bio(LHASH *lh, BIO *out)
{
LHASH_NODE *n;
unsigned long num;
#endif
-LHASH *lh_new(h, c)
-unsigned long (*h)();
-int (*c)();
+LHASH *lh_new(unsigned long (*h)(), int (*c)())
{
LHASH *ret;
int i;
return(NULL);
}
-void lh_free(lh)
-LHASH *lh;
+void lh_free(LHASH *lh)
{
unsigned int i;
LHASH_NODE *n,*nn;
Free((char *)lh);
}
-char *lh_insert(lh, data)
-LHASH *lh;
-char *data;
+char *lh_insert(LHASH *lh, char *data)
{
unsigned long hash;
LHASH_NODE *nn,**rn;
return(ret);
}
-char *lh_delete(lh, data)
-LHASH *lh;
-char *data;
+char *lh_delete(LHASH *lh, char *data)
{
unsigned long hash;
LHASH_NODE *nn,**rn;
return(ret);
}
-char *lh_retrieve(lh, data)
-LHASH *lh;
-char *data;
+char *lh_retrieve(LHASH *lh, char *data)
{
unsigned long hash;
LHASH_NODE **rn;
return(ret);
}
-void lh_doall(lh, func)
-LHASH *lh;
-void (*func)();
+void lh_doall(LHASH *lh, void (*func)())
{
lh_doall_arg(lh,func,NULL);
}
-void lh_doall_arg(lh, func, arg)
-LHASH *lh;
-void (*func)();
-char *arg;
+void lh_doall_arg(LHASH *lh, void (*func)(), char *arg)
{
int i;
LHASH_NODE *a,*n;
}
}
-static void expand(lh)
-LHASH *lh;
+static void expand(LHASH *lh)
{
LHASH_NODE **n,**n1,**n2,*np;
unsigned int p,i,j;
}
}
-static void contract(lh)
-LHASH *lh;
+static void contract(LHASH *lh)
{
LHASH_NODE **n,*n1,*np;
}
}
-static LHASH_NODE **getrn(lh, data, rhash)
-LHASH *lh;
-char *data;
-unsigned long *rhash;
+static LHASH_NODE **getrn(LHASH *lh, char *data, unsigned long *rhash)
{
LHASH_NODE **ret,*n1;
unsigned long hash,nn;
* no collisions on /usr/dict/words and it distributes on %2^n quite
* well, not as good as MD5, but still good.
*/
-unsigned long lh_strhash(c)
-const char *c;
+unsigned long lh_strhash(const char *c)
{
unsigned long ret=0;
long n;
void exit();
#endif
-int main(argc, argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
FILE *IN;
return(err);
}
-void do_fp(f)
-FILE *f;
+void do_fp(FILE *f)
{
MD2_CTX c;
unsigned char md[MD2_DIGEST_LENGTH];
pt(md);
}
-void pt(md)
-unsigned char *md;
+void pt(unsigned char *md)
{
int i;
0xDB, 0x99, 0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14,
};
-const char *MD2_options()
+const char *MD2_options(void)
{
if (sizeof(MD2_INT) == 1)
return("md2(char)");
return("md2(int)");
}
-void MD2_Init(c)
-MD2_CTX *c;
+void MD2_Init(MD2_CTX *c)
{
c->num=0;
memset(c->state,0,MD2_BLOCK*sizeof(MD2_INT));
memset(c->data,0,MD2_BLOCK);
}
-void MD2_Update(c, data, len)
-MD2_CTX *c;
-register unsigned char *data;
-unsigned long len;
+void MD2_Update(MD2_CTX *c, register unsigned char *data, unsigned long len)
{
register UCHAR *p;
c->num=(int)len;
}
-static void md2_block(c, d)
-MD2_CTX *c;
-unsigned char *d;
+static void md2_block(MD2_CTX *c, unsigned char *d)
{
register MD2_INT t,*sp1,*sp2;
register int i,j;
memset(state,0,48*sizeof(MD2_INT));
}
-void MD2_Final(md, c)
-unsigned char *md;
-MD2_CTX *c;
+void MD2_Final(unsigned char *md, MD2_CTX *c)
{
int i,v;
register UCHAR *cp;
/* This is a separate file so that #defines in cryptlib.h can
* map my MD functions to different names */
-unsigned char *MD2(d, n, md)
-unsigned char *d;
-unsigned long n;
-unsigned char *md;
+unsigned char *MD2(unsigned char *d, unsigned long n, unsigned char *md)
{
MD2_CTX c;
static unsigned char m[MD2_DIGEST_LENGTH];
static char *pt();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
char **P,**R;
return(0);
}
-static char *pt(md)
-unsigned char *md;
+static char *pt(unsigned char *md)
{
int i;
static char buf[80];
int read();
#endif
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
int i,err=0;
FILE *IN;
exit(err);
}
-void do_fp(f)
-FILE *f;
+void do_fp(FILE *f)
{
MD5_CTX c;
unsigned char md[MD5_DIGEST_LENGTH];
pt(md);
}
-void pt(md)
-unsigned char *md;
+void pt(unsigned char *md)
{
int i;
# endif
#endif
-void MD5_Init(c)
-MD5_CTX *c;
+void MD5_Init(MD5_CTX *c)
{
c->A=INIT_DATA_A;
c->B=INIT_DATA_B;
c->num=0;
}
-void MD5_Update(c, _data, len)
-MD5_CTX *c;
-const void *_data;
-unsigned long len;
+void MD5_Update(MD5_CTX *c, const void *_data, unsigned long len)
{
register const unsigned char *data=_data;
register ULONG *p;
}
}
-void MD5_Transform(c,b)
-MD5_CTX *c;
-unsigned char *b;
+void MD5_Transform(MD5_CTX *c, unsigned char *b)
{
ULONG p[16];
#if !defined(L_ENDIAN)
#ifndef MD5_ASM
-static void md5_block(c, X, num)
-MD5_CTX *c;
-register ULONG *X;
-int num;
+static void md5_block(MD5_CTX *c, register ULONG *X, int num)
{
register ULONG A,B,C,D;
}
#endif
-void MD5_Final(md, c)
-unsigned char *md;
-MD5_CTX *c;
+void MD5_Final(unsigned char *md, MD5_CTX *c)
{
register int i,j;
register ULONG l;
}
#ifdef undef
-int printit(l)
-unsigned long *l;
+int printit(unsigned long *l)
{
int i,ii;
#include <stdio.h>
#include "md5_locl.h"
-unsigned char *MD5(d, n, md)
-unsigned char *d;
-unsigned long n;
-unsigned char *md;
+unsigned char *MD5(unsigned char *d, unsigned long n, unsigned char *md)
{
MD5_CTX c;
static unsigned char m[MD5_DIGEST_LENGTH];
static char *pt();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
unsigned char **P,**R;
return(0);
}
-static char *pt(md)
-unsigned char *md;
+static char *pt(unsigned char *md)
{
int i;
static char buf[80];
#include "cryptlib.h"
#include "mdc2.h"
-unsigned char *MDC2(d, n, md)
-unsigned char *d;
-unsigned long n;
-unsigned char *md;
+unsigned char *MDC2(unsigned char *d, unsigned long n, unsigned char *md)
{
MDC2_CTX c;
static unsigned char m[MDC2_DIGEST_LENGTH];
static void mdc2_body();
#endif
-void MDC2_Init(c)
-MDC2_CTX *c;
+void MDC2_Init(MDC2_CTX *c)
{
c->num=0;
c->pad_type=1;
memset(&(c->hh[0]),0x25,MDC2_BLOCK);
}
-void MDC2_Update(c,in,len)
-MDC2_CTX *c;
-register unsigned char *in;
-unsigned long len;
+void MDC2_Update(MDC2_CTX *c, register unsigned char *in, unsigned long len)
{
int i,j;
}
}
-static void mdc2_body(c,in,len)
-MDC2_CTX *c;
-unsigned char *in;
-unsigned int len;
+static void mdc2_body(MDC2_CTX *c, unsigned char *in, unsigned int len)
{
register DES_LONG tin0,tin1;
register DES_LONG ttin0,ttin1;
}
}
-void MDC2_Final(md,c)
-unsigned char *md;
-MDC2_CTX *c;
+void MDC2_Final(unsigned char *md, MDC2_CTX *c)
{
int i,j;
0x35,0xD8,0x7A,0xFE,0xAB,0x33,0xBE,0xE2
};
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int ret=0;
unsigned char md[MDC2_DIGEST_LENGTH];
unsigned long order;
} MEM;
-int CRYPTO_mem_ctrl(mode)
-int mode;
+int CRYPTO_mem_ctrl(int mode)
{
int ret=mh_mode;
return(ret);
}
-static int mem_cmp(a,b)
-MEM *a,*b;
+static int mem_cmp(MEM *a, MEM *b)
{
return(a->addr - b->addr);
}
-static unsigned long mem_hash(a)
-MEM *a;
+static unsigned long mem_hash(MEM *a)
{
unsigned long ret;
static char *(*realloc_func)()= (char *(*)())realloc;
static void (*free_func)()= (void (*)())free;
-void CRYPTO_set_mem_functions(m,r,f)
-char *(*m)();
-char *(*r)();
-void (*f)();
+void CRYPTO_set_mem_functions(char *(*m)(), char *(*r)(), void (*f)())
{
if ((m == NULL) || (r == NULL) || (f == NULL)) return;
malloc_func=m;
free_locked_func=f;
}
-void CRYPTO_set_locked_mem_functions(m,f)
-char *(*m)();
-void (*f)();
+void CRYPTO_set_locked_mem_functions(char *(*m)(), void (*f)())
{
if ((m == NULL) || (f == NULL)) return;
malloc_locked_func=m;
free_locked_func=f;
}
-void CRYPTO_get_mem_functions(m,r,f)
-char *(**m)();
-char *(**r)();
-void (**f)();
+void CRYPTO_get_mem_functions(char *(**m)(), char *(**r)(), void (**f)())
{
if (m != NULL) *m=malloc_func;
if (r != NULL) *r=realloc_func;
if (f != NULL) *f=free_func;
}
-void CRYPTO_get_locked_mem_functions(m,f)
-char *(**m)();
-void (**f)();
+void CRYPTO_get_locked_mem_functions(char *(**m)(), void (**f)())
{
if (m != NULL) *m=malloc_locked_func;
if (f != NULL) *f=free_locked_func;
}
-void *CRYPTO_malloc_locked(num)
-int num;
+void *CRYPTO_malloc_locked(int num)
{
return(malloc_locked_func(num));
}
-void CRYPTO_free_locked(str)
-void *str;
+void CRYPTO_free_locked(void *str)
{
free_locked_func(str);
}
-void *CRYPTO_malloc(num)
-int num;
+void *CRYPTO_malloc(int num)
{
return(malloc_func(num));
}
-void *CRYPTO_realloc(str,num)
-void *str;
-int num;
+void *CRYPTO_realloc(void *str, int num)
{
return(realloc_func(str,num));
}
-void CRYPTO_free(str)
-void *str;
+void CRYPTO_free(void *str)
{
free_func(str);
}
static unsigned long break_order_num=0;
-void *CRYPTO_dbg_malloc(num,file,line)
-int num;
-const char *file;
-int line;
+void *CRYPTO_dbg_malloc(int num, const char *file, int line)
{
char *ret;
MEM *m,*mm;
return(ret);
}
-void CRYPTO_dbg_free(addr)
-void *addr;
+void CRYPTO_dbg_free(void *addr)
{
MEM m,*mp;
free_func(addr);
}
-void *CRYPTO_dbg_realloc(addr,num,file,line)
-void *addr;
-int num;
-const char *file;
-int line;
+void *CRYPTO_dbg_realloc(void *addr, int num, const char *file, int line)
{
char *ret;
MEM m,*mp;
return(ret);
}
-void *CRYPTO_remalloc(a,n)
-void *a;
-int n;
+void *CRYPTO_remalloc(void *a, int n)
{
if (a != NULL) Free(a);
a=(char *)Malloc(n);
return(a);
}
-void *CRYPTO_dbg_remalloc(a,n,file,line)
-void *a;
-int n;
-const char *file;
-int line;
+void *CRYPTO_dbg_remalloc(void *a, int n, const char *file, int line)
{
if (a != NULL) CRYPTO_dbg_free(a);
a=(char *)CRYPTO_dbg_malloc(n,file,line);
long bytes;
} MEM_LEAK;
-static void print_leak(m,l)
-MEM *m;
-MEM_LEAK *l;
+static void print_leak(MEM *m, MEM_LEAK *l)
{
char buf[128];
l->bytes+=m->num;
}
-void CRYPTO_mem_leaks(b)
-BIO *b;
+void CRYPTO_mem_leaks(BIO *b)
{
MEM_LEAK ml;
char buf[80];
static void (*mem_cb)()=NULL;
-static void cb_leak(m,cb)
-MEM *m;
-char *cb;
+static void cb_leak(MEM *m, char *cb)
{
void (*mem_callback)()=(void (*)())cb;
mem_callback(m->order,m->file,m->line,m->num,m->addr);
}
-void CRYPTO_mem_leaks_cb(cb)
-void (*cb)();
+void CRYPTO_mem_leaks_cb(void (*cb)())
{
if (mh == NULL) return;
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
}
#ifndef NO_FP_API
-void CRYPTO_mem_leaks_fp(fp)
-FILE *fp;
+void CRYPTO_mem_leaks_fp(FILE *fp)
{
BIO *b;
static unsigned long obj_name_hash(OBJ_NAME *a);
static int obj_name_cmp(OBJ_NAME *a,OBJ_NAME *b);
-int OBJ_NAME_init()
+int OBJ_NAME_init(void)
{
if (names_lh != NULL) return(1);
MemCheck_off();
return(names_lh != NULL);
}
-int OBJ_NAME_new_index(hash_func,cmp_func,free_func)
-unsigned long (*hash_func)();
-int (*cmp_func)();
-void (*free_func)();
+int OBJ_NAME_new_index(unsigned long (*hash_func)(), int (*cmp_func)(),
+ void (*free_func)())
{
int ret;
int i;
return(ret);
}
-static int obj_name_cmp(a,b)
-OBJ_NAME *a;
-OBJ_NAME *b;
+static int obj_name_cmp(OBJ_NAME *a, OBJ_NAME *b)
{
int ret;
int (*cmp)();
return(ret);
}
-static unsigned long obj_name_hash(a)
-OBJ_NAME *a;
+static unsigned long obj_name_hash(OBJ_NAME *a)
{
unsigned long ret;
unsigned long (*hash)();
return(ret);
}
-const char *OBJ_NAME_get(name,type)
-const char *name;
-int type;
+const char *OBJ_NAME_get(const char *name, int type)
{
OBJ_NAME on,*ret;
int num=0,alias;
}
}
-int OBJ_NAME_add(name,type,data)
-const char *name;
-int type;
-const char *data;
+int OBJ_NAME_add(const char *name, int type, const char *data)
{
void (*f)();
OBJ_NAME *onp,*ret;
return(1);
}
-int OBJ_NAME_remove(name,type)
-const char *name;
-int type;
+int OBJ_NAME_remove(const char *name, int type)
{
OBJ_NAME on,*ret;
void (*f)();
static int free_type;
-static void names_lh_free(onp,type)
-OBJ_NAME *onp;
- {
+static void names_lh_free(OBJ_NAME *onp, int type)
+{
if(onp == NULL)
return;
}
}
-void OBJ_NAME_cleanup(type)
-int type;
+void OBJ_NAME_cleanup(int type)
{
unsigned long down_load;
static int new_nid=NUM_NID;
static LHASH *added=NULL;
-static int sn_cmp(ap,bp)
-ASN1_OBJECT **ap;
-ASN1_OBJECT **bp;
+static int sn_cmp(ASN1_OBJECT **ap, ASN1_OBJECT **bp)
{ return(strcmp((*ap)->sn,(*bp)->sn)); }
-static int ln_cmp(ap,bp)
-ASN1_OBJECT **ap;
-ASN1_OBJECT **bp;
+static int ln_cmp(ASN1_OBJECT **ap, ASN1_OBJECT **bp)
{ return(strcmp((*ap)->ln,(*bp)->ln)); }
-static unsigned long add_hash(ca)
-ADDED_OBJ *ca;
+static unsigned long add_hash(ADDED_OBJ *ca)
{
ASN1_OBJECT *a;
int i;
return(ret);
}
-static int add_cmp(ca,cb)
-ADDED_OBJ *ca,*cb;
+static int add_cmp(ADDED_OBJ *ca, ADDED_OBJ *cb)
{
ASN1_OBJECT *a,*b;
int i;
return(1); /* should not get here */
}
-static int init_added()
+static int init_added(void)
{
if (added != NULL) return(1);
added=lh_new(add_hash,add_cmp);
return(added != NULL);
}
-static void cleanup1(a)
-ADDED_OBJ *a;
+static void cleanup1(ADDED_OBJ *a)
{
a->obj->nid=0;
a->obj->flags|=ASN1_OBJECT_FLAG_DYNAMIC|
ASN1_OBJECT_FLAG_DYNAMIC_DATA;
}
-static void cleanup2(a)
-ADDED_OBJ *a;
+static void cleanup2(ADDED_OBJ *a)
{ a->obj->nid++; }
-static void cleanup3(a)
-ADDED_OBJ *a;
+static void cleanup3(ADDED_OBJ *a)
{
if (--a->obj->nid == 0)
ASN1_OBJECT_free(a->obj);
Free(a);
}
-void OBJ_cleanup()
+void OBJ_cleanup(void)
{
if (added == NULL) return;
added->down_load=0;
added=NULL;
}
-int OBJ_new_nid(num)
-int num;
+int OBJ_new_nid(int num)
{
int i;
return(i);
}
-int OBJ_add_object(obj)
-ASN1_OBJECT *obj;
+int OBJ_add_object(ASN1_OBJECT *obj)
{
ASN1_OBJECT *o;
ADDED_OBJ *ao[4],*aop;
return(NID_undef);
}
-ASN1_OBJECT *OBJ_nid2obj(n)
-int n;
+ASN1_OBJECT *OBJ_nid2obj(int n)
{
ADDED_OBJ ad,*adp;
ASN1_OBJECT ob;
}
}
-const char *OBJ_nid2sn(n)
-int n;
+const char *OBJ_nid2sn(int n)
{
ADDED_OBJ ad,*adp;
ASN1_OBJECT ob;
}
}
-const char *OBJ_nid2ln(n)
-int n;
+const char *OBJ_nid2ln(int n)
{
ADDED_OBJ ad,*adp;
ASN1_OBJECT ob;
}
}
-int OBJ_obj2nid(a)
-ASN1_OBJECT *a;
+int OBJ_obj2nid(ASN1_OBJECT *a)
{
ASN1_OBJECT **op;
ADDED_OBJ ad,*adp;
* it can be used with any objects, not just registered ones.
*/
-ASN1_OBJECT *OBJ_txt2obj(s, no_name)
-const char *s;
-int no_name;
+ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name)
{
int nid = NID_undef;
ASN1_OBJECT *op=NULL;
return op;
}
-int OBJ_txt2nid(s)
-char *s;
+int OBJ_txt2nid(char *s)
{
ASN1_OBJECT *obj;
int nid;
return nid;
}
-int OBJ_ln2nid(s)
-const char *s;
+int OBJ_ln2nid(const char *s)
{
ASN1_OBJECT o,*oo= &o,**op;
ADDED_OBJ ad,*adp;
return((*op)->nid);
}
-int OBJ_sn2nid(s)
-const char *s;
+int OBJ_sn2nid(const char *s)
{
ASN1_OBJECT o,*oo= &o,**op;
ADDED_OBJ ad,*adp;
return((*op)->nid);
}
-static int obj_cmp(ap, bp)
-ASN1_OBJECT **ap;
-ASN1_OBJECT **bp;
+static int obj_cmp(ASN1_OBJECT **ap, ASN1_OBJECT **bp)
{
int j;
ASN1_OBJECT *a= *ap;
return(memcmp(a->data,b->data,a->length));
}
-char *OBJ_bsearch(key,base,num,size,cmp)
-char *key;
-char *base;
-int num;
-int size;
-int (*cmp)();
+char *OBJ_bsearch(char *key, char *base, int num, int size, int (*cmp)())
{
int l,h,i,c;
char *p;
return(NULL);
}
-int OBJ_create_objects(in)
-BIO *in;
+int OBJ_create_objects(BIO *in)
{
MS_STATIC char buf[512];
int i,num=0;
/* return(num); */
}
-int OBJ_create(oid,sn,ln)
-char *oid;
-char *sn;
-char *ln;
+int OBJ_create(char *oid, char *sn, char *ln)
{
int ok=0;
ASN1_OBJECT *op=NULL;
#endif
-void ERR_load_OBJ_strings()
+void ERR_load_OBJ_strings(void)
{
static int init=1;
#include "objects.h"
#include "buffer.h"
-ASN1_OBJECT *OBJ_dup(o)
-ASN1_OBJECT *o;
+ASN1_OBJECT *OBJ_dup(ASN1_OBJECT *o)
{
ASN1_OBJECT *r;
int i;
return(NULL);
}
-int OBJ_cmp(a,b)
-ASN1_OBJECT *a;
-ASN1_OBJECT *b;
+int OBJ_cmp(ASN1_OBJECT *a, ASN1_OBJECT *b)
{
int ret;
#ifndef NO_FP_API
/* The X509 functions */
-X509 *PEM_read_X509(fp,x,cb)
-FILE *fp;
-X509 **x;
-int (*cb)();
+X509 *PEM_read_X509(FILE *fp, X509 **x, int (*cb)())
{
return((X509 *)PEM_ASN1_read((char *(*)())d2i_X509,
PEM_STRING_X509,fp,(char **)x,cb));
}
#endif
-X509 *PEM_read_bio_X509(bp,x,cb)
-BIO *bp;
-X509 **x;
-int (*cb)();
+X509 *PEM_read_bio_X509(BIO *bp, X509 **x, int (*cb)())
{
return((X509 *)PEM_ASN1_read_bio((char *(*)())d2i_X509,
PEM_STRING_X509,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_X509(fp,x)
-FILE *fp;
-X509 *x;
+int PEM_write_X509(FILE *fp, X509 *x)
{
return(PEM_ASN1_write((int (*)())i2d_X509,PEM_STRING_X509,fp,
(char *)x, NULL,NULL,0,NULL));
}
#endif
-int PEM_write_bio_X509(bp,x)
-BIO *bp;
-X509 *x;
+int PEM_write_bio_X509(BIO *bp, X509 *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_X509,PEM_STRING_X509,bp,
(char *)x, NULL,NULL,0,NULL));
#ifndef NO_FP_API
/* The X509_REQ functions */
-X509_REQ *PEM_read_X509_REQ(fp,x,cb)
-FILE *fp;
-X509_REQ **x;
-int (*cb)();
+X509_REQ *PEM_read_X509_REQ(FILE *fp, X509_REQ **x, int (*cb)())
{
return((X509_REQ *)PEM_ASN1_read((char *(*)())d2i_X509_REQ,
PEM_STRING_X509_REQ,fp,(char **)x,cb));
}
#endif
-X509_REQ *PEM_read_bio_X509_REQ(bp,x,cb)
-BIO *bp;
-X509_REQ **x;
-int (*cb)();
+X509_REQ *PEM_read_bio_X509_REQ(BIO *bp, X509_REQ **x, int (*cb)())
{
return((X509_REQ *)PEM_ASN1_read_bio((char *(*)())d2i_X509_REQ,
PEM_STRING_X509_REQ,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_X509_REQ(fp,x)
-FILE *fp;
-X509_REQ *x;
+int PEM_write_X509_REQ(FILE *fp, X509_REQ *x)
{
return(PEM_ASN1_write((int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,fp,
(char *)x, NULL,NULL,0,NULL));
}
#endif
-int PEM_write_bio_X509_REQ(bp,x)
-BIO *bp;
-X509_REQ *x;
+int PEM_write_bio_X509_REQ(BIO *bp, X509_REQ *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,
bp,(char *)x, NULL,NULL,0,NULL));
#ifndef NO_FP_API
/* The X509_CRL functions */
-X509_CRL *PEM_read_X509_CRL(fp,x,cb)
-FILE *fp;
-X509_CRL **x;
-int (*cb)();
+X509_CRL *PEM_read_X509_CRL(FILE *fp, X509_CRL **x, int (*cb)())
{
return((X509_CRL *)PEM_ASN1_read((char *(*)())d2i_X509_CRL,
PEM_STRING_X509_CRL,fp,(char **)x,cb));
}
#endif
-X509_CRL *PEM_read_bio_X509_CRL(bp,x,cb)
-BIO *bp;
-X509_CRL **x;
-int (*cb)();
+X509_CRL *PEM_read_bio_X509_CRL(BIO *bp, X509_CRL **x, int (*cb)())
{
return((X509_CRL *)PEM_ASN1_read_bio((char *(*)())d2i_X509_CRL,
PEM_STRING_X509_CRL,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_X509_CRL(fp,x)
-FILE *fp;
-X509_CRL *x;
+int PEM_write_X509_CRL(FILE *fp, X509_CRL *x)
{
return(PEM_ASN1_write((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL,fp,
(char *)x, NULL,NULL,0,NULL));
}
#endif
-int PEM_write_bio_X509_CRL(bp,x)
-BIO *bp;
-X509_CRL *x;
+int PEM_write_bio_X509_CRL(BIO *bp, X509_CRL *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL,
bp,(char *)x, NULL,NULL,0,NULL));
#ifndef NO_RSA
#ifndef NO_FP_API
/* The RSAPrivateKey functions */
-RSA *PEM_read_RSAPrivateKey(fp,x,cb)
-FILE *fp;
-RSA **x;
-int (*cb)();
+RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **x, int (*cb)())
{
return((RSA *)PEM_ASN1_read((char *(*)())d2i_RSAPrivateKey,
PEM_STRING_RSA,fp,(char **)x,cb));
}
-RSA *PEM_read_RSAPublicKey(fp,x,cb)
-FILE *fp;
-RSA **x;
-int (*cb)();
+RSA *PEM_read_RSAPublicKey(FILE *fp, RSA **x, int (*cb)())
{
return((RSA *)PEM_ASN1_read((char *(*)())d2i_RSAPublicKey,
PEM_STRING_RSA_PUBLIC,fp,(char **)x,cb));
}
#endif
-RSA *PEM_read_bio_RSAPrivateKey(bp,x,cb)
-BIO *bp;
-RSA **x;
-int (*cb)();
+RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **x, int (*cb)())
{
return((RSA *)PEM_ASN1_read_bio((char *(*)())d2i_RSAPrivateKey,
PEM_STRING_RSA,bp,(char **)x,cb));
}
-RSA *PEM_read_bio_RSAPublicKey(bp,x,cb)
-BIO *bp;
-RSA **x;
-int (*cb)();
+RSA *PEM_read_bio_RSAPublicKey(BIO *bp, RSA **x, int (*cb)())
{
return((RSA *)PEM_ASN1_read_bio((char *(*)())d2i_RSAPublicKey,
PEM_STRING_RSA_PUBLIC,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_RSAPrivateKey(fp,x,enc,kstr,klen,cb)
-FILE *fp;
-RSA *x;
-EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*cb)();
+int PEM_write_RSAPrivateKey(FILE *fp, RSA *x, EVP_CIPHER *enc,
+ unsigned char *kstr, int klen, int (*cb)())
{
return(PEM_ASN1_write((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,fp,
(char *)x,enc,kstr,klen,cb));
}
-int PEM_write_RSAPublicKey(fp,x)
-FILE *fp;
-RSA *x;
+int PEM_write_RSAPublicKey(FILE *fp, RSA *x)
{
return(PEM_ASN1_write((int (*)())i2d_RSAPublicKey,
PEM_STRING_RSA_PUBLIC,fp,
}
#endif
-int PEM_write_bio_RSAPrivateKey(bp,x,enc,kstr,klen,cb)
-BIO *bp;
-RSA *x;
-const EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*cb)();
+int PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x, const EVP_CIPHER *enc,
+ unsigned char *kstr, int klen, int (*cb)())
{
return(PEM_ASN1_write_bio((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,
bp,(char *)x,enc,kstr,klen,cb));
}
-int PEM_write_bio_RSAPublicKey(bp,x)
-BIO *bp;
-RSA *x;
+int PEM_write_bio_RSAPublicKey(BIO *bp, RSA *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_RSAPublicKey,
PEM_STRING_RSA_PUBLIC,
#ifndef NO_DSA
#ifndef NO_FP_API
/* The DSAPrivateKey functions */
-DSA *PEM_read_DSAPrivateKey(fp,x,cb)
-FILE *fp;
-DSA **x;
-int (*cb)();
+DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **x, int (*cb)())
{
return((DSA *)PEM_ASN1_read((char *(*)())d2i_DSAPrivateKey,
PEM_STRING_DSA,fp,(char **)x,cb));
}
#endif
-DSA *PEM_read_bio_DSAPrivateKey(bp,x,cb)
-BIO *bp;
-DSA **x;
-int (*cb)();
+DSA *PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **x, int (*cb)())
{
return((DSA *)PEM_ASN1_read_bio((char *(*)())d2i_DSAPrivateKey,
PEM_STRING_DSA,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_DSAPrivateKey(fp,x,enc,kstr,klen,cb)
-FILE *fp;
-DSA *x;
-const EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*cb)();
+int PEM_write_DSAPrivateKey(FILE *fp, DSA *x, const EVP_CIPHER *enc,
+ unsigned char *kstr, int klen, int (*cb)())
{
return(PEM_ASN1_write((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,fp,
(char *)x,enc,kstr,klen,cb));
}
#endif
-int PEM_write_bio_DSAPrivateKey(bp,x,enc,kstr,klen,cb)
-BIO *bp;
-DSA *x;
-const EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*cb)();
+int PEM_write_bio_DSAPrivateKey(BIO *bp, DSA *x, const EVP_CIPHER *enc,
+ unsigned char *kstr, int klen, int (*cb)())
{
return(PEM_ASN1_write_bio((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,
bp,(char *)x,enc,kstr,klen,cb));
#ifndef NO_FP_API
/* The PrivateKey functions */
-EVP_PKEY *PEM_read_PrivateKey(fp,x,cb)
-FILE *fp;
-EVP_PKEY **x;
-int (*cb)();
+EVP_PKEY *PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x, int (*cb)())
{
return((EVP_PKEY *)PEM_ASN1_read((char *(*)())d2i_PrivateKey,
PEM_STRING_EVP_PKEY,fp,(char **)x,cb));
}
#endif
-EVP_PKEY *PEM_read_bio_PrivateKey(bp,x,cb)
-BIO *bp;
-EVP_PKEY **x;
-int (*cb)();
+EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x, int (*cb)())
{
return((EVP_PKEY *)PEM_ASN1_read_bio((char *(*)())d2i_PrivateKey,
PEM_STRING_EVP_PKEY,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_PrivateKey(fp,x,enc,kstr,klen,cb)
-FILE *fp;
-EVP_PKEY *x;
-EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*cb)();
+int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, EVP_CIPHER *enc,
+ unsigned char *kstr, int klen, int (*cb)())
{
return(PEM_ASN1_write((int (*)())i2d_PrivateKey,
((x->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),
}
#endif
-int PEM_write_bio_PrivateKey(bp,x,enc,kstr,klen,cb)
-BIO *bp;
-EVP_PKEY *x;
-EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*cb)();
+int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, EVP_CIPHER *enc,
+ unsigned char *kstr, int klen, int (*cb)())
{
return(PEM_ASN1_write_bio((int (*)())i2d_PrivateKey,
((x->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),
#ifndef NO_FP_API
/* The PKCS7 functions */
-PKCS7 *PEM_read_PKCS7(fp,x,cb)
-FILE *fp;
-PKCS7 **x;
-int (*cb)();
+PKCS7 *PEM_read_PKCS7(FILE *fp, PKCS7 **x, int (*cb)())
{
return((PKCS7 *)PEM_ASN1_read((char *(*)())d2i_PKCS7,
PEM_STRING_PKCS7,fp,(char **)x,cb));
}
#endif
-PKCS7 *PEM_read_bio_PKCS7(bp,x,cb)
-BIO *bp;
-PKCS7 **x;
-int (*cb)();
+PKCS7 *PEM_read_bio_PKCS7(BIO *bp, PKCS7 **x, int (*cb)())
{
return((PKCS7 *)PEM_ASN1_read_bio((char *(*)())d2i_PKCS7,
PEM_STRING_PKCS7,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_PKCS7(fp,x)
-FILE *fp;
-PKCS7 *x;
+int PEM_write_PKCS7(FILE *fp, PKCS7 *x)
{
return(PEM_ASN1_write((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,fp,
(char *)x, NULL,NULL,0,NULL));
}
#endif
-int PEM_write_bio_PKCS7(bp,x)
-BIO *bp;
-PKCS7 *x;
+int PEM_write_bio_PKCS7(BIO *bp, PKCS7 *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,bp,
(char *)x, NULL,NULL,0,NULL));
#ifndef NO_DH
#ifndef NO_FP_API
/* The DHparams functions */
-DH *PEM_read_DHparams(fp,x,cb)
-FILE *fp;
-DH **x;
-int (*cb)();
+DH *PEM_read_DHparams(FILE *fp, DH **x, int (*cb)())
{
return((DH *)PEM_ASN1_read((char *(*)())d2i_DHparams,
PEM_STRING_DHPARAMS,fp,(char **)x,cb));
}
#endif
-DH *PEM_read_bio_DHparams(bp,x,cb)
-BIO *bp;
-DH **x;
-int (*cb)();
+DH *PEM_read_bio_DHparams(BIO *bp, DH **x, int (*cb)())
{
return((DH *)PEM_ASN1_read_bio((char *(*)())d2i_DHparams,
PEM_STRING_DHPARAMS,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_DHparams(fp,x)
-FILE *fp;
-DH *x;
+int PEM_write_DHparams(FILE *fp, DH *x)
{
return(PEM_ASN1_write((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,fp,
(char *)x, NULL,NULL,0,NULL));
}
#endif
-int PEM_write_bio_DHparams(bp,x)
-BIO *bp;
-DH *x;
+int PEM_write_bio_DHparams(BIO *bp, DH *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,
bp,(char *)x, NULL,NULL,0,NULL));
#ifndef NO_DSA
#ifndef NO_FP_API
/* The DSAparams functions */
-DSA *PEM_read_DSAparams(fp,x,cb)
-FILE *fp;
-DSA **x;
-int (*cb)();
+DSA *PEM_read_DSAparams(FILE *fp, DSA **x, int (*cb)())
{
return((DSA *)PEM_ASN1_read((char *(*)())d2i_DSAparams,
PEM_STRING_DSAPARAMS,fp,(char **)x,cb));
}
#endif
-DSA *PEM_read_bio_DSAparams(bp,x,cb)
-BIO *bp;
-DSA **x;
-int (*cb)();
+DSA *PEM_read_bio_DSAparams(BIO *bp, DSA **x, int (*cb)())
{
return((DSA *)PEM_ASN1_read_bio((char *(*)())d2i_DSAparams,
PEM_STRING_DSAPARAMS,bp,(char **)x,cb));
}
#ifndef NO_FP_API
-int PEM_write_DSAparams(fp,x)
-FILE *fp;
-DSA *x;
+int PEM_write_DSAparams(FILE *fp, DSA *x)
{
return(PEM_ASN1_write((int (*)())i2d_DSAparams,PEM_STRING_DSAPARAMS,fp,
(char *)x, NULL,NULL,0,NULL));
}
#endif
-int PEM_write_bio_DSAparams(bp,x)
-BIO *bp;
-DSA *x;
+int PEM_write_bio_DSAparams(BIO *bp, DSA *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_DSAparams,PEM_STRING_DSAPARAMS,
bp,(char *)x, NULL,NULL,0,NULL));
/* The Netscape Certificate sequence functions */
#ifndef NO_FP_API
-NETSCAPE_CERT_SEQUENCE *PEM_read_NETSCAPE_CERT_SEQUENCE(fp,x,cb)
-FILE *fp;
-NETSCAPE_CERT_SEQUENCE **x;
-int (*cb)();
+NETSCAPE_CERT_SEQUENCE *PEM_read_NETSCAPE_CERT_SEQUENCE(FILE *fp,
+ NETSCAPE_CERT_SEQUENCE **x, int (*cb)())
{
return((NETSCAPE_CERT_SEQUENCE *)
PEM_ASN1_read((char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,
}
#endif
-NETSCAPE_CERT_SEQUENCE *PEM_read_bio_NETSCAPE_CERT_SEQUENCE(bp,x,cb)
-BIO *bp;
-NETSCAPE_CERT_SEQUENCE **x;
-int (*cb)();
+NETSCAPE_CERT_SEQUENCE *PEM_read_bio_NETSCAPE_CERT_SEQUENCE(BIO *bp,
+ NETSCAPE_CERT_SEQUENCE **x, int (*cb)())
{
return((NETSCAPE_CERT_SEQUENCE *)
PEM_ASN1_read_bio((char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,
}
#ifndef NO_FP_API
-int PEM_write_NETSCAPE_CERT_SEQUENCE(fp,x)
-FILE *fp;
-NETSCAPE_CERT_SEQUENCE *x;
+int PEM_write_NETSCAPE_CERT_SEQUENCE(FILE *fp, NETSCAPE_CERT_SEQUENCE *x)
{
return(PEM_ASN1_write((int (*)())i2d_NETSCAPE_CERT_SEQUENCE,
PEM_STRING_X509,fp, (char *)x, NULL,NULL,0,NULL));
}
#endif
-int PEM_write_bio_NETSCAPE_CERT_SEQUENCE(bp,x)
-BIO *bp;
-NETSCAPE_CERT_SEQUENCE *x;
+int PEM_write_bio_NETSCAPE_CERT_SEQUENCE(BIO *bp, NETSCAPE_CERT_SEQUENCE *x)
{
return(PEM_ASN1_write_bio((int (*)())i2d_NETSCAPE_CERT_SEQUENCE,
PEM_STRING_X509,bp, (char *)x, NULL,NULL,0,NULL));
#endif
-void ERR_load_PEM_strings()
+void ERR_load_PEM_strings(void)
{
static int init=1;
#include "pem.h"
#ifndef NO_FP_API
-STACK *PEM_X509_INFO_read(fp,sk,cb)
-FILE *fp;
-STACK *sk;
-int (*cb)();
+STACK *PEM_X509_INFO_read(FILE *fp, STACK *sk, int (*cb)())
{
BIO *b;
STACK *ret;
}
#endif
-STACK *PEM_X509_INFO_read_bio(bp,sk,cb)
-BIO *bp;
-STACK *sk;
-int (*cb)();
+STACK *PEM_X509_INFO_read_bio(BIO *bp, STACK *sk, int (*cb)())
{
X509_INFO *xi=NULL;
char *name=NULL,*header=NULL,**pp;
/* A TJH addition */
-int PEM_X509_INFO_write_bio(bp,xi,enc,kstr,klen,cb)
-BIO *bp;
-X509_INFO *xi;
-EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*cb)();
+int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc,
+ unsigned char *kstr, int klen, int (*cb)())
{
EVP_CIPHER_CTX ctx;
int i,ret=0;
static int load_iv();
#endif
-static int def_callback(buf, num, w)
-char *buf;
-int num;
-int w;
+static int def_callback(char *buf, int num, int w)
{
#ifdef NO_FP_API
/* We should not ever call the default callback routine from
#endif
}
-void PEM_proc_type(buf, type)
-char *buf;
-int type;
+void PEM_proc_type(char *buf, int type)
{
const char *str;
strcat(buf,"\n");
}
-void PEM_dek_info(buf, type, len, str)
-char *buf;
-const char *type;
-int len;
-char *str;
+void PEM_dek_info(char *buf, const char *type, int len, char *str)
{
static unsigned char map[17]="0123456789ABCDEF";
long i;
}
#ifndef NO_FP_API
-char *PEM_ASN1_read(d2i,name,fp, x, cb)
-char *(*d2i)();
-const char *name;
-FILE *fp;
-char **x;
-int (*cb)();
+char *PEM_ASN1_read(char *(*d2i)(), const char *name, FILE *fp, char **x,
+ int (*cb)())
{
BIO *b;
char *ret;
}
#endif
-char *PEM_ASN1_read_bio(d2i,name,bp, x, cb)
-char *(*d2i)();
-const char *name;
-BIO *bp;
-char **x;
-int (*cb)();
+char *PEM_ASN1_read_bio(char *(*d2i)(), const char *name, BIO *bp, char **x,
+ int (*cb)())
{
EVP_CIPHER_INFO cipher;
char *nm=NULL,*header=NULL;
}
#ifndef NO_FP_API
-int PEM_ASN1_write(i2d,name,fp, x, enc, kstr, klen, callback)
-int (*i2d)();
-const char *name;
-FILE *fp;
-char *x;
-const EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*callback)();
+int PEM_ASN1_write(int (*i2d)(), const char *name, FILE *fp, char *x,
+ const EVP_CIPHER *enc, unsigned char *kstr, int klen,
+ int (*callback)())
{
BIO *b;
int ret;
}
#endif
-int PEM_ASN1_write_bio(i2d,name,bp, x, enc, kstr, klen, callback)
-int (*i2d)();
-const char *name;
-BIO *bp;
-char *x;
-const EVP_CIPHER *enc;
-unsigned char *kstr;
-int klen;
-int (*callback)();
+int PEM_ASN1_write_bio(int (*i2d)(), const char *name, BIO *bp, char *x,
+ const EVP_CIPHER *enc, unsigned char *kstr, int klen,
+ int (*callback)())
{
EVP_CIPHER_CTX ctx;
int dsize=0,i,j,ret=0;
return(ret);
}
-int PEM_do_header(cipher, data, plen, callback)
-EVP_CIPHER_INFO *cipher;
-unsigned char *data;
-long *plen;
-int (*callback)();
+int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *plen,
+ int (*callback)())
{
int i,j,o,klen;
long len;
return(1);
}
-int PEM_get_EVP_CIPHER_INFO(header,cipher)
-char *header;
-EVP_CIPHER_INFO *cipher;
+int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher)
{
int o;
const EVP_CIPHER *enc=NULL;
return(1);
}
-static int load_iv(fromp,to,num)
-unsigned char **fromp,*to;
-int num;
+static int load_iv(unsigned char **fromp, unsigned char *to, int num)
{
int v,i;
unsigned char *from;
}
#ifndef NO_FP_API
-int PEM_write(fp, name, header, data,len)
-FILE *fp;
-char *name;
-char *header;
-unsigned char *data;
-long len;
+int PEM_write(FILE *fp, char *name, char *header, unsigned char *data,
+ long len)
{
BIO *b;
int ret;
}
#endif
-int PEM_write_bio(bp, name, header, data,len)
-BIO *bp;
-const char *name;
-char *header;
-unsigned char *data;
-long len;
+int PEM_write_bio(BIO *bp, const char *name, char *header, unsigned char *data,
+ long len)
{
int nlen,n,i,j,outl;
unsigned char *buf;
}
#ifndef NO_FP_API
-int PEM_read(fp, name, header, data,len)
-FILE *fp;
-char **name;
-char **header;
-unsigned char **data;
-long *len;
+int PEM_read(FILE *fp, char **name, char **header, unsigned char **data,
+ long *len)
{
BIO *b;
int ret;
}
#endif
-int PEM_read_bio(bp, name, header, data, len)
-BIO *bp;
-char **name;
-char **header;
-unsigned char **data;
-long *len;
+int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
+ long *len)
{
EVP_ENCODE_CTX ctx;
int end=0,i,k,bl=0,hl=0,nohead=0;
#include "x509.h"
#include "pem.h"
-int PEM_SealInit(ctx,type,md_type,ek,ekl,iv,pubk,npubk)
-PEM_ENCODE_SEAL_CTX *ctx;
-EVP_CIPHER *type;
-EVP_MD *md_type;
-unsigned char **ek;
-int *ekl;
-unsigned char *iv;
-EVP_PKEY **pubk;
-int npubk;
+int PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type, EVP_MD *md_type,
+ unsigned char **ek, int *ekl, unsigned char *iv, EVP_PKEY **pubk,
+ int npubk)
{
unsigned char key[EVP_MAX_KEY_LENGTH];
int ret= -1;
return(ret);
}
-void PEM_SealUpdate(ctx,out,outl,in,inl)
-PEM_ENCODE_SEAL_CTX *ctx;
-unsigned char *out;
-int *outl;
-unsigned char *in;
-int inl;
+void PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl,
+ unsigned char *in, int inl)
{
unsigned char buffer[1600];
int i,j;
}
}
-int PEM_SealFinal(ctx,sig,sigl,out,outl,priv)
-PEM_ENCODE_SEAL_CTX *ctx;
-unsigned char *sig;
-int *sigl;
-unsigned char *out;
-int *outl;
-EVP_PKEY *priv;
+int PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig, int *sigl,
+ unsigned char *out, int *outl, EVP_PKEY *priv)
{
unsigned char *s=NULL;
int ret=0,j;
#include "x509.h"
#include "pem.h"
-void PEM_SignInit(ctx,type)
-EVP_MD_CTX *ctx;
-EVP_MD *type;
+void PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type)
{
EVP_DigestInit(ctx,type);
}
-void PEM_SignUpdate(ctx,data,count)
-EVP_MD_CTX *ctx;
-unsigned char *data;
-unsigned int count;
+void PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *data,
+ unsigned int count)
{
EVP_DigestUpdate(ctx,data,count);
}
-int PEM_SignFinal(ctx,sigret,siglen,pkey)
-EVP_MD_CTX *ctx;
-unsigned char *sigret;
-unsigned int *siglen;
-EVP_PKEY *pkey;
+int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, unsigned int *siglen,
+ EVP_PKEY *pkey)
{
unsigned char *m;
int i,ret=0;
/* Pack an object into an OCTET STRING and turn into a safebag */
-PKCS12_SAFEBAG *PKCS12_pack_safebag (obj, i2d, nid1, nid2)
-char *obj;
-int (*i2d)();
-int nid1;
-int nid2;
-
+PKCS12_SAFEBAG *PKCS12_pack_safebag (char *obj, int (*i2d)(), int nid1,
+ int nid2)
{
PKCS12_BAGS *bag;
PKCS12_SAFEBAG *safebag;
/* Turn PKCS8 object into a keybag */
-PKCS12_SAFEBAG *PKCS12_MAKE_KEYBAG (p8)
-PKCS8_PRIV_KEY_INFO *p8;
+PKCS12_SAFEBAG *PKCS12_MAKE_KEYBAG (PKCS8_PRIV_KEY_INFO *p8)
{
PKCS12_SAFEBAG *bag;
if (!(bag = PKCS12_SAFEBAG_new())) {
/* Turn PKCS8 object into a shrouded keybag */
-PKCS12_SAFEBAG
- *PKCS12_MAKE_SHKEYBAG (pbe_nid, pass, passlen, salt, saltlen, iter, p8)int pbe_nid;
+PKCS12_SAFEBAG *PKCS12_MAKE_SHKEYBAG (pbe_nid, pass, passlen, salt, saltlen, iter, p8)int pbe_nid;
unsigned char *pass;
int passlen;
unsigned char *salt;
}
/* Turn a stack of SAFEBAGS into a PKCS#7 data Contentinfo */
-PKCS7 *PKCS12_pack_p7data (sk)
-STACK *sk;
+PKCS7 *PKCS12_pack_p7data (STACK *sk)
{
PKCS7 *p7;
if (!(p7 = PKCS7_new())) {
/* Turn a stack of SAFEBAGS into a PKCS#7 encrypted data ContentInfo */
-PKCS7 *PKCS12_pack_p7encdata (pbe_nid, pass, passlen, salt, saltlen, iter,
- bags)
-int pbe_nid;
-unsigned char *pass;
-int passlen;
-unsigned char *salt;
-int saltlen;
-int iter;
-STACK *bags;
+PKCS7 *PKCS12_pack_p7encdata (int pbe_nid, unsigned char *pass, int passlen,
+ unsigned char *salt, int saltlen, int iter, STACK *bags)
{
PKCS7 *p7;
X509_ALGOR *pbe;
return p7;
}
-X509_SIG *PKCS8_encrypt (pbe_nid, pass, passlen, salt, saltlen, iter, p8inf)
-int pbe_nid;
-unsigned char *pass;
-int passlen;
-unsigned char *salt;
-int saltlen;
-int iter;
-PKCS8_PRIV_KEY_INFO *p8inf;
+X509_SIG *PKCS8_encrypt (int pbe_nid, unsigned char *pass, int passlen,
+ unsigned char *salt, int saltlen, int iter,
+ PKCS8_PRIV_KEY_INFO *p8inf)
{
X509_SIG *p8;
X509_ALGOR *pbe;
/* Add a local keyid to a safebag */
-int PKCS12_add_localkeyid (bag, name, namelen)
-PKCS12_SAFEBAG *bag;
-unsigned char *name;
-int namelen;
+int PKCS12_add_localkeyid (PKCS12_SAFEBAG *bag, unsigned char *name,
+ int namelen)
{
X509_ATTRIBUTE *attrib;
ASN1_BMPSTRING *oct;
/* Add key usage to PKCS#8 structure */
-int PKCS8_add_keyusage (p8, usage)
-PKCS8_PRIV_KEY_INFO *p8;
-int usage;
+int PKCS8_add_keyusage (PKCS8_PRIV_KEY_INFO *p8, int usage)
{
X509_ATTRIBUTE *attrib;
ASN1_BIT_STRING *bstr;
/* Add a friendlyname to a safebag */
-int PKCS12_add_friendlyname_asc (bag, name, namelen)
-PKCS12_SAFEBAG *bag;
-unsigned char *name;
-int namelen;
+int PKCS12_add_friendlyname_asc (PKCS12_SAFEBAG *bag, unsigned char *name,
+ int namelen)
{
unsigned char *uniname;
int ret, unilen;
}
-int PKCS12_add_friendlyname_uni (bag, name, namelen)
-PKCS12_SAFEBAG *bag;
-unsigned char *name;
-int namelen;
+int PKCS12_add_friendlyname_uni (PKCS12_SAFEBAG *bag, unsigned char *name,
+ int namelen)
{
X509_ATTRIBUTE *attrib;
ASN1_BMPSTRING *bmp;
return PKCS12_OK;
}
-ASN1_TYPE *PKCS12_get_attr_gen (attrs, attr_nid)
-STACK *attrs;
-int attr_nid;
+ASN1_TYPE *PKCS12_get_attr_gen (STACK *attrs, int attr_nid)
{
X509_ATTRIBUTE *attrib;
int i;
return NULL;
}
-char *PKCS12_get_friendlyname(bag)
-PKCS12_SAFEBAG *bag;
+char *PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag)
{
ASN1_TYPE *atype;
if (!(atype = PKCS12_get_attr(bag, NID_friendlyName))) return NULL;
*ASN1err(ASN1_F_D2I_PKCS12_BAGS,ASN1_R_DECODE_ERROR)
*/
-int i2d_PKCS12_BAGS(a,pp)
-PKCS12_BAGS *a;
-unsigned char **pp;
+int i2d_PKCS12_BAGS(PKCS12_BAGS *a, unsigned char **pp)
{
int bagnid, v = 0;
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-PKCS12_BAGS *PKCS12_BAGS_new()
+PKCS12_BAGS *PKCS12_BAGS_new(void)
{
PKCS12_BAGS *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_PKCS12_BAGS_NEW);
}
-PKCS12_BAGS *d2i_PKCS12_BAGS(a,pp,length)
-PKCS12_BAGS **a;
-unsigned char **pp;
-long length;
+PKCS12_BAGS *d2i_PKCS12_BAGS(PKCS12_BAGS **a, unsigned char **pp,
+ long length)
{
int bagnid;
M_ASN1_D2I_vars(a,PKCS12_BAGS *,PKCS12_BAGS_new);
M_ASN1_D2I_Finish(a, PKCS12_BAGS_free, ASN1_F_D2I_PKCS12_BAGS);
}
-void PKCS12_BAGS_free (a)
-PKCS12_BAGS *a;
+void PKCS12_BAGS_free (PKCS12_BAGS *a)
{
if (a == NULL) return;
switch (OBJ_obj2nid(a->type)) {
/* PKCS#12 specific PBE functions */
-void PKCS12_PBE_add()
+void PKCS12_PBE_add(void)
{
EVP_PBE_alg_add(NID_pbe_WithSHA1And128BitRC4, EVP_rc4(), EVP_sha1(),
PKCS12_PBE_keyivgen);
EVP_sha1(), PKCS12_PBE_keyivgen);
}
-int PKCS12_PBE_keyivgen (pass, passlen, salt, saltlen, iter, cipher,
- md, key, iv)
-unsigned char *pass;
-int passlen;
-unsigned char *salt;
-int saltlen;
-int iter;
-EVP_CIPHER *cipher;
-EVP_MD *md;
-unsigned char *key, *iv;
+int PKCS12_PBE_keyivgen (unsigned char *pass, int passlen, unsigned char *salt,
+ int saltlen, int iter, EVP_CIPHER *cipher, EVP_MD *md,
+ unsigned char *key, unsigned char *iv)
{
if (!PKCS12_key_gen (pass, passlen, salt, saltlen, PKCS12_KEY_ID,
iter, EVP_CIPHER_key_length(cipher), key, md)) {
#include "cryptlib.h"
#include "pkcs12.h"
-PKCS12 *PKCS12_create(pass, name, pkey, cert, ca, nid_key, nid_cert, iter,
- mac_iter, keytype)
-char *pass;
-char *name;
-EVP_PKEY *pkey;
-X509 *cert;
-STACK *ca;
-int nid_key;
-int nid_cert;
-int iter;
-int mac_iter;
-int keytype;
+PKCS12 *PKCS12_create(char *pass, char *name, EVP_PKEY *pkey, X509 *cert,
+ STACK *ca, int nid_key, int nid_cert, int iter, int mac_iter,
+ int keytype)
{
PKCS12 *p12;
STACK *bags, *safes;
* Malloc'ed buffer
*/
-unsigned char * PKCS12_pbe_crypt (algor, pass, passlen, in, inlen,
- data, datalen, en_de)
-X509_ALGOR *algor;
-unsigned char *pass;
-int passlen;
-unsigned char *in;
-int inlen;
-unsigned char **data;
-int *datalen;
-int en_de;
+unsigned char * PKCS12_pbe_crypt (X509_ALGOR *algor, unsigned char *pass,
+ int passlen, unsigned char *in, int inlen, unsigned char **data,
+ int *datalen, int en_de)
{
unsigned char *out;
int outlen, i;
* as a sequence.
*/
-char * PKCS12_decrypt_d2i (algor, d2i, free_func, pass, passlen, oct, seq)
-X509_ALGOR *algor;
-char * (*d2i)();
-void (*free_func)();
-unsigned char *pass;
-int passlen;
-ASN1_OCTET_STRING *oct;
-int seq;
+char * PKCS12_decrypt_d2i (X509_ALGOR *algor, char * (*d2i)(),
+ void (*free_func)(), unsigned char *pass, int passlen,
+ ASN1_OCTET_STRING *oct, int seq)
{
unsigned char *out, *p;
char *ret;
* as a sequence
*/
-ASN1_OCTET_STRING *PKCS12_i2d_encrypt (algor, i2d, pass, passlen, obj, seq)
-X509_ALGOR *algor;
-int (*i2d)();
-unsigned char *pass;
-int passlen;
-char *obj;
-int seq;
+ASN1_OCTET_STRING *PKCS12_i2d_encrypt (X509_ALGOR *algor, int (*i2d)(),
+ unsigned char *pass, int passlen, char *obj, int seq)
{
ASN1_OCTET_STRING *oct;
unsigned char *in, *p;
/* Initialise a PKCS12 structure to take data */
-PKCS12 *PKCS12_init (mode)
-int mode;
+PKCS12 *PKCS12_init (int mode)
{
PKCS12 *pkcs12;
if (!(pkcs12 = PKCS12_new())) {
#define min(a,b) ((a) < (b) ? (a) : (b))
#endif
-int PKCS12_key_gen_asc (pass, passlen, salt, saltlen, id, iter, n, out, md_type)
-unsigned char *pass, *salt, *out;
-int passlen, saltlen, id, iter, n;
-const EVP_MD *md_type;
+int PKCS12_key_gen_asc (unsigned char *pass, int passlen, unsigned char *salt,
+ int saltlen, int id, int iter, int n, unsigned char *out,
+ const EVP_MD *md_type)
{
int ret;
unsigned char *unipass;
return ret;
}
-int PKCS12_key_gen_uni (pass, passlen, salt, saltlen, id, iter, n, out, md_type)
-unsigned char *pass, *salt, *out;
-int passlen, saltlen, id, iter, n;
-const EVP_MD *md_type;
+int PKCS12_key_gen_uni (unsigned char *pass, int passlen, unsigned char *salt,
+ int saltlen, int id, int iter, int n, unsigned char *out,
+ const EVP_MD *md_type)
{
unsigned char *B, *D, *I, *p, *Ai;
int Slen, Plen, Ilen;
return 0; /* This can't happen */
}
#ifdef DEBUG_KEYGEN
-void h__dump (p, len)
-unsigned char *p;
-int len;
+void h__dump (unsigned char *p, int len)
{
for (; len --; p++) BIO_printf (bio_err, "%02X", *p);
BIO_printf (bio_err, "\n");
* passed unitialised.
*/
-int PKCS12_parse (p12, pass, pkey, cert, ca)
-PKCS12 *p12;
-char *pass;
-EVP_PKEY **pkey;
-X509 **cert;
-STACK **ca;
+int PKCS12_parse (PKCS12 *p12, char *pass, EVP_PKEY **pkey, X509 **cert,
+ STACK **ca)
{
/* Check for NULL PKCS12 structure */
/* Parse the outer PKCS#12 structure */
-static int parse_pk12 (p12, pass, passlen, pkey, cert, ca)
-PKCS12 *p12;
-unsigned char *pass;
-int passlen;
-EVP_PKEY **pkey;
-X509 **cert;
-STACK **ca;
+static int parse_pk12 (PKCS12 *p12, unsigned char *pass, int passlen,
+ EVP_PKEY **pkey, X509 **cert, STACK **ca)
{
STACK *asafes, *bags;
int i, bagnid;
}
-static int parse_bags (bags, pass, passlen, pkey, cert, ca, keyid, keymatch)
-STACK *bags;
-unsigned char *pass;
-int passlen;
-EVP_PKEY **pkey;
-X509 **cert;
-STACK **ca;
-ASN1_OCTET_STRING **keyid;
-char *keymatch;
+static int parse_bags (STACK *bags, unsigned char *pass, int passlen,
+ EVP_PKEY **pkey, X509 **cert, STACK **ca, ASN1_OCTET_STRING **keyid,
+ char *keymatch)
{
int i;
for (i = 0; i < sk_num (bags); i++) {
#define MATCH_CERT 0x2
#define MATCH_ALL 0x3
-static int parse_bag (bag, pass, passlen, pkey, cert, ca, keyid, keymatch)
-PKCS12_SAFEBAG *bag;
-unsigned char *pass;
-int passlen;
-EVP_PKEY **pkey;
-X509 **cert;
-STACK **ca;
-ASN1_OCTET_STRING **keyid;
-char *keymatch;
+static int parse_bag (PKCS12_SAFEBAG *bag, unsigned char *pass, int passlen,
+ EVP_PKEY **pkey, X509 **cert, STACK **ca, ASN1_OCTET_STRING **keyid,
+ char *keymatch)
{
PKCS8_PRIV_KEY_INFO *p8;
X509 *x509;
*ASN1err(ASN1_F_D2I_PKCS12,ASN1_R_DECODE_ERROR)
*/
-int i2d_PKCS12(a,pp)
-PKCS12 *a;
-unsigned char **pp;
+int i2d_PKCS12(PKCS12 *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-PKCS12 *d2i_PKCS12(a,pp,length)
-PKCS12 **a;
-unsigned char **pp;
-long length;
+PKCS12 *d2i_PKCS12(PKCS12 **a, unsigned char **pp, long length)
{
M_ASN1_D2I_vars(a,PKCS12 *,PKCS12_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, PKCS12_free, ASN1_F_D2I_PKCS12);
}
-PKCS12 *PKCS12_new()
+PKCS12 *PKCS12_new(void)
{
PKCS12 *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_PKCS12_NEW);
}
-void PKCS12_free (a)
-PKCS12 *a;
+void PKCS12_free (PKCS12 *a)
{
if (a == NULL) return;
ASN1_INTEGER_free (a->version);
*ASN1err(ASN1_F_D2I_PKCS12_MAC_DATA,ASN1_R_DECODE_ERROR)
*/
-int i2d_PKCS12_MAC_DATA(a,pp)
-PKCS12_MAC_DATA *a;
-unsigned char **pp;
+int i2d_PKCS12_MAC_DATA(PKCS12_MAC_DATA *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_len (a->dinfo, i2d_X509_SIG);
M_ASN1_I2D_finish();
}
-PKCS12_MAC_DATA *PKCS12_MAC_DATA_new()
+PKCS12_MAC_DATA *PKCS12_MAC_DATA_new(void)
{
PKCS12_MAC_DATA *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_PKCS12_MAC_DATA_NEW);
}
-PKCS12_MAC_DATA *d2i_PKCS12_MAC_DATA(a,pp,length)
-PKCS12_MAC_DATA **a;
-unsigned char **pp;
-long length;
+PKCS12_MAC_DATA *d2i_PKCS12_MAC_DATA(PKCS12_MAC_DATA **a, unsigned char **pp,
+ long length)
{
M_ASN1_D2I_vars(a,PKCS12_MAC_DATA *,PKCS12_MAC_DATA_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, PKCS12_MAC_DATA_free, ASN1_F_D2I_PKCS12_MAC_DATA);
}
-void PKCS12_MAC_DATA_free (a)
-PKCS12_MAC_DATA *a;
+void PKCS12_MAC_DATA_free (PKCS12_MAC_DATA *a)
{
if (a == NULL) return;
X509_SIG_free (a->dinfo);
#include "pkcs12.h"
/* Generate a MAC */
-int PKCS12_gen_mac (p12, pass, passlen, mac, maclen)
-PKCS12 *p12;
-unsigned char *pass;
-int passlen;
-unsigned char *mac;
-unsigned int *maclen;
+int PKCS12_gen_mac (PKCS12 *p12, unsigned char *pass, int passlen,
+ unsigned char *mac, unsigned int *maclen)
{
const EVP_MD *md_type;
HMAC_CTX hmac;
}
/* Verify the mac */
-int PKCS12_verify_mac (p12, pass, passlen)
-PKCS12 *p12;
-unsigned char *pass;
-int passlen;
+int PKCS12_verify_mac (PKCS12 *p12, unsigned char *pass, int passlen)
{
unsigned char mac[EVP_MAX_MD_SIZE];
unsigned int maclen;
/* Set a mac */
-int PKCS12_set_mac (p12, pass, passlen, salt, saltlen, iter, md_type)
-PKCS12 *p12;
-unsigned char *pass;
-int passlen;
-unsigned char *salt;
-int saltlen;
-int iter;
-EVP_MD *md_type;
+int PKCS12_set_mac (PKCS12 *p12, unsigned char *pass, int passlen,
+ unsigned char *salt, int saltlen, int iter, EVP_MD *md_type)
{
unsigned char mac[EVP_MAX_MD_SIZE];
int maclen;
}
/* Set up a mac structure */
-int PKCS12_setup_mac (p12, iter, salt, saltlen, md_type)
-PKCS12 *p12;
-int iter;
-unsigned char *salt;
-int saltlen;
-EVP_MD *md_type;
+int PKCS12_setup_mac (PKCS12 *p12, int iter, unsigned char *salt, int saltlen,
+ EVP_MD *md_type)
{
if (!(p12->mac = PKCS12_MAC_DATA_new ())) return PKCS12_ERROR;
if (iter > 1) {
*ASN1err(ASN1_F_D2I_PKCS12_SAFEBAG,ASN1_R_DECODE_ERROR)
*/
-int i2d_PKCS12_SAFEBAG(a,pp)
-PKCS12_SAFEBAG *a;
-unsigned char **pp;
+int i2d_PKCS12_SAFEBAG(PKCS12_SAFEBAG *a, unsigned char **pp)
{
int bagnid, v = 0;
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-PKCS12_SAFEBAG *PKCS12_SAFEBAG_new()
+PKCS12_SAFEBAG *PKCS12_SAFEBAG_new(void)
{
PKCS12_SAFEBAG *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_PKCS12_SAFEBAG_NEW);
}
-PKCS12_SAFEBAG *d2i_PKCS12_SAFEBAG(a,pp,length)
-PKCS12_SAFEBAG **a;
-unsigned char **pp;
-long length;
+PKCS12_SAFEBAG *d2i_PKCS12_SAFEBAG(PKCS12_SAFEBAG **a, unsigned char **pp,
+ long length)
{
int bagnid;
M_ASN1_D2I_vars(a,PKCS12_SAFEBAG *,PKCS12_SAFEBAG_new);
M_ASN1_D2I_Finish(a, PKCS12_SAFEBAG_free, ASN1_F_D2I_PKCS12_SAFEBAG);
}
-void PKCS12_SAFEBAG_free (a)
-PKCS12_SAFEBAG *a;
+void PKCS12_SAFEBAG_free (PKCS12_SAFEBAG *a)
{
if (a == NULL) return;
switch (OBJ_obj2nid(a->type)) {
/* Cheap and nasty Unicode stuff */
-unsigned char *asc2uni (asc, uni, unilen)
-unsigned char *asc, **uni;
-int *unilen;
+unsigned char *asc2uni (unsigned char *asc, unsigned char **uni, int *unilen)
{
int ulen, i;
unsigned char *unitmp;
return unitmp;
}
-char *uni2asc (uni, unilen)
-unsigned char *uni;
-int unilen;
+char *uni2asc (unsigned char *uni, int unilen)
{
int asclen, i;
char *asctmp;
return asctmp;
}
-int i2d_PKCS12_bio(bp, p12)
-BIO *bp;
-PKCS12 *p12;
+int i2d_PKCS12_bio(BIO *bp, PKCS12 *p12)
{
return ASN1_i2d_bio((int(*)())i2d_PKCS12, bp, (unsigned char *)p12);
}
-int i2d_PKCS12_fp(fp, p12)
-FILE *fp;
-PKCS12 *p12;
+int i2d_PKCS12_fp(FILE *fp, PKCS12 *p12)
{
return ASN1_i2d_fp((int(*)())i2d_PKCS12, fp, (unsigned char *)p12);
}
-PKCS12 *d2i_PKCS12_bio(bp, p12)
-BIO *bp;
-PKCS12 **p12;
+PKCS12 *d2i_PKCS12_bio(BIO *bp, PKCS12 **p12)
{
return (PKCS12 *)ASN1_d2i_bio((char *(*)())PKCS12_new,
(char *(*)())d2i_PKCS12, bp, (unsigned char **)p12);
}
-PKCS12 *d2i_PKCS12_fp(fp, p12)
-FILE *fp;
-PKCS12 **p12;
+PKCS12 *d2i_PKCS12_fp(FILE *fp, PKCS12 **p12)
{
return (PKCS12 *)ASN1_d2i_fp((char *(*)())PKCS12_new,
(char *(*)())d2i_PKCS12, fp, (unsigned char **)(p12));
#endif
-void ERR_load_PKCS12_strings()
+void ERR_load_PKCS12_strings(void)
{
static int init=1;
ber_free,
};
-BIO_METHOD *BIO_f_ber()
+BIO_METHOD *BIO_f_ber(void)
{
return(&methods_ber);
}
-static int ber_new(bi)
-BIO *bi;
+static int ber_new(BIO *bi)
{
BIO_BER_CTX *ctx;
return(1);
}
-static int ber_free(a)
-BIO *a;
+static int ber_free(BIO *a)
{
BIO_BER_CTX *b;
return(1);
}
-int bio_ber_get_header(bio,ctx)
-BIO *bio;
-BIO_BER_CTX *ctx;
+int bio_ber_get_header(BIO *bio, BIO_BER_CTX *ctx)
{
char buf[64];
int i,j,n;
if (ret & V_ASN1_CONSTRUCTED)
}
-static int ber_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int ber_read(BIO *b, char *out, int outl)
{
int ret=0,i,n;
BIO_BER_CTX *ctx;
}
}
-static int ber_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int ber_write(BIO *b, char *in, int inl)
{
int ret=0,n,i;
BIO_ENC_CTX *ctx;
return(ret);
}
-static long ber_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long ber_ctrl(BIO *b, int cmd, long num, char *ptr)
{
BIO *dbio;
BIO_ENC_CTX *ctx,*dctx;
}
*/
-void BIO_set_cipher(b,c,k,i,e)
-BIO *b;
-EVP_CIPHER *c;
-unsigned char *k;
-unsigned char *i;
-int e;
+void BIO_set_cipher(BIO *b, EVP_CIPHER *c, unsigned char *k, unsigned char *i,
+ int e)
{
BIO_ENC_CTX *ctx;
}
/* should be X509 * but we can just have them as char *. */
-int verify_callback(ok, ctx)
-int ok;
-X509_STORE_CTX *ctx;
+int verify_callback(int ok, X509_STORE_CTX *ctx)
{
char buf[256];
X509 *err_cert;
#include <malloc.h>
#include "pkcs7.h"
-int add_signed_time(si)
-PKCS7_SIGNER_INFO *si;
+int add_signed_time(PKCS7_SIGNER_INFO *si)
{
ASN1_UTCTIME *sign_time;
return(1);
}
-ASN1_UTCTIME *get_signed_time(si)
-PKCS7_SIGNER_INFO *si;
+ASN1_UTCTIME *get_signed_time(PKCS7_SIGNER_INFO *si)
{
ASN1_TYPE *so;
ASN1_UTCTIME *ut;
static int signed_string_nid= -1;
-int add_signed_string(si,str)
-PKCS7_SIGNER_INFO *si;
-char *str;
+int add_signed_string(PKCS7_SIGNER_INFO *si, char *str)
{
ASN1_OCTET_STRING *os;
V_ASN1_OCTET_STRING,(char *)os);
}
-int get_signed_string(si,buf,len)
-PKCS7_SIGNER_INFO *si;
-char *buf;
-int len;
+int get_signed_string(PKCS7_SIGNER_INFO *si, char *buf, int len)
{
ASN1_TYPE *so;
ASN1_OCTET_STRING *os;
static signed_seq2string_nid= -1;
/* ########################################### */
-int add_signed_seq2string(si,str1,str2)
-PKCS7_SIGNER_INFO *si;
-char *str1;
-char *str2;
+int add_signed_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2)
+ {
/* To add an object of OID 1.9.999, which is a sequence containing
* 2 octet strings */
- {
unsigned char *p;
ASN1_OCTET_STRING *os1,*os2;
ASN1_STRING *seq;
}
/* For this case, I will malloc the return strings */
-int get_signed_seq2string(si,str1,str2)
-PKCS7_SIGNER_INFO *si;
-char **str1;
-char **str2;
+int get_signed_seq2string(PKCS7_SIGNER_INFO *si, char **str1, char **str2)
{
ASN1_TYPE *so;
* THE OTHER WAY TO DO THINGS
* #######################################
*/
-X509_ATTRIBUTE *create_time()
+X509_ATTRIBUTE *create_time(void)
{
ASN1_UTCTIME *sign_time;
X509_ATTRIBUTE *ret;
return(ret);
}
-ASN1_UTCTIME *sk_get_time(sk)
-STACK *sk;
+ASN1_UTCTIME *sk_get_time(STACK *sk)
{
ASN1_TYPE *so;
ASN1_UTCTIME *ut;
return(ut);
}
-X509_ATTRIBUTE *create_string(si,str)
-char *str;
+X509_ATTRIBUTE *create_string(char *str)
{
ASN1_OCTET_STRING *os;
X509_ATTRIBUTE *ret;
return(ret);
}
-int sk_get_string(sk,buf,len)
-STACK *sk;
-char *buf;
-int len;
+int sk_get_string(STACK *sk, char *buf, int len)
{
ASN1_TYPE *so;
ASN1_OCTET_STRING *os;
return(0);
}
-X509_ATTRIBUTE *add_seq2string(si,str1,str2)
-PKCS7_SIGNER_INFO *si;
-char *str1;
-char *str2;
+X509_ATTRIBUTE *add_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2)
+ {
/* To add an object of OID 1.9.999, which is a sequence containing
* 2 octet strings */
- {
unsigned char *p;
ASN1_OCTET_STRING *os1,*os2;
ASN1_STRING *seq;
}
/* For this case, I will malloc the return strings */
-int sk_get_seq2string(sk,str1,str2)
-STACK *sk;
-char **str1;
-char **str2;
+int sk_get_seq2string(STACK *sk, char **str1, char **str2)
{
ASN1_TYPE *so;
PKCS7_SIGNER_INFO si;
static ASN1_TYPE *get_attribute(STACK *sk, int nid);
#if 1
-BIO *PKCS7_dataInit(p7,bio)
-PKCS7 *p7;
-BIO *bio;
+BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio)
{
int i,j;
BIO *out=NULL,*btmp=NULL;
}
/* int */
-BIO *PKCS7_dataDecode(p7,pkey,in_bio,xs)
-PKCS7 *p7;
-EVP_PKEY *pkey;
-BIO *in_bio;
-X509_STORE *xs;
+BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio,
+ X509_STORE *xs)
{
int i,j;
BIO *out=NULL,*btmp=NULL,*etmp=NULL,*bio=NULL;
}
#endif
-int PKCS7_dataFinal(p7,bio)
-PKCS7 *p7;
-BIO *bio;
+int PKCS7_dataFinal(PKCS7 *p7, BIO *bio)
{
int ret=0;
int i,j;
return(ret);
}
-int PKCS7_dataVerify(cert_store,ctx,bio,p7,si)
-X509_STORE *cert_store;
-X509_STORE_CTX *ctx;
-BIO *bio;
-PKCS7 *p7;
-PKCS7_SIGNER_INFO *si;
+int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio,
+ PKCS7 *p7, PKCS7_SIGNER_INFO *si)
{
/* PKCS7_SIGNED *s; */
ASN1_OCTET_STRING *os;
return(ret);
}
-PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(p7,idx)
-PKCS7 *p7;
-int idx;
+PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx)
{
STACK *rsk;
PKCS7_RECIP_INFO *ri;
return(ri->issuer_and_serial);
}
-ASN1_TYPE *PKCS7_get_signed_attribute(si,nid)
-PKCS7_SIGNER_INFO *si;
-int nid;
+ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid)
{
return(get_attribute(si->auth_attr,nid));
}
-ASN1_TYPE *PKCS7_get_attribute(si,nid)
-PKCS7_SIGNER_INFO *si;
-int nid;
+ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid)
{
return(get_attribute(si->unauth_attr,nid));
}
-static ASN1_TYPE *get_attribute(sk,nid)
-STACK *sk;
-int nid;
+static ASN1_TYPE *get_attribute(STACK *sk, int nid)
{
int i;
X509_ATTRIBUTE *xa;
return(NULL);
}
-ASN1_OCTET_STRING *PKCS7_digest_from_attributes(sk)
-STACK *sk;
+ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK *sk)
{
X509_ATTRIBUTE *attr;
ASN1_TYPE *astype;
return NULL;
}
-int PKCS7_set_signed_attributes(p7si,sk)
-PKCS7_SIGNER_INFO *p7si;
-STACK *sk;
+int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, STACK *sk)
{
int i;
return(1);
}
-int PKCS7_set_attributes(p7si,sk)
-PKCS7_SIGNER_INFO *p7si;
-STACK *sk;
+int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, STACK *sk)
{
int i;
return(1);
}
-int PKCS7_add_signed_attribute(p7si,nid,atrtype,value)
-PKCS7_SIGNER_INFO *p7si;
-int nid;
-int atrtype;
-char *value;
+int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
+ char *value)
{
return(add_attribute(&(p7si->auth_attr),nid,atrtype,value));
}
-int PKCS7_add_attribute(p7si,nid,atrtype,value)
-PKCS7_SIGNER_INFO *p7si;
-int nid;
-int atrtype;
-char *value;
+int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
+ char *value)
{
return(add_attribute(&(p7si->unauth_attr),nid,atrtype,value));
}
-static int add_attribute(sk, nid, atrtype, value)
-STACK **sk;
-int nid;
-int atrtype;
-char *value;
+static int add_attribute(STACK **sk, int nid, int atrtype, char *value)
{
X509_ATTRIBUTE *attr=NULL;
#include "objects.h"
#include "x509.h"
-long PKCS7_ctrl(p7,cmd,larg,parg)
-PKCS7 *p7;
-int cmd;
-long larg;
-char *parg;
+long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg)
{
int nid;
long ret;
return(ret);
}
-int PKCS7_content_new(p7,type)
-PKCS7 *p7;
-int type;
+int PKCS7_content_new(PKCS7 *p7, int type)
{
PKCS7 *ret=NULL;
return(0);
}
-int PKCS7_set_content(p7,p7_data)
-PKCS7 *p7;
-PKCS7 *p7_data;
+int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data)
{
int i;
return(0);
}
-int PKCS7_set_type(p7,type)
-PKCS7 *p7;
-int type;
+int PKCS7_set_type(PKCS7 *p7, int type)
{
ASN1_OBJECT *obj;
return(0);
}
-int PKCS7_add_signer(p7,psi)
-PKCS7 *p7;
-PKCS7_SIGNER_INFO *psi;
+int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi)
{
int i,j,nid;
X509_ALGOR *alg;
return(1);
}
-int PKCS7_add_certificate(p7,x509)
-PKCS7 *p7;
-X509 *x509;
+int PKCS7_add_certificate(PKCS7 *p7, X509 *x509)
{
int i;
STACK_OF(X509) **sk;
return(1);
}
-int PKCS7_add_crl(p7,crl)
-PKCS7 *p7;
-X509_CRL *crl;
+int PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl)
{
int i;
STACK **sk;
return(1);
}
-int PKCS7_SIGNER_INFO_set(p7i,x509,pkey,dgst)
-PKCS7_SIGNER_INFO *p7i;
-X509 *x509;
-EVP_PKEY *pkey;
-EVP_MD *dgst;
+int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
+ EVP_MD *dgst)
{
/* We now need to add another PKCS7_SIGNER_INFO entry */
ASN1_INTEGER_set(p7i->version,1);
return(0);
}
-PKCS7_SIGNER_INFO *PKCS7_add_signature(p7,x509,pkey,dgst)
-PKCS7 *p7;
-X509 *x509;
-EVP_PKEY *pkey;
-EVP_MD *dgst;
+PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey,
+ EVP_MD *dgst)
{
PKCS7_SIGNER_INFO *si;
return(NULL);
}
-STACK *PKCS7_get_signer_info(p7)
-PKCS7 *p7;
+STACK *PKCS7_get_signer_info(PKCS7 *p7)
{
if (PKCS7_type_is_signed(p7))
{
return(NULL);
}
-PKCS7_RECIP_INFO *PKCS7_add_recipient(p7,x509)
-PKCS7 *p7;
-X509 *x509;
+PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509)
{
PKCS7_RECIP_INFO *ri;
return(NULL);
}
-int PKCS7_add_recipient_info(p7,ri)
-PKCS7 *p7;
-PKCS7_RECIP_INFO *ri;
+int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri)
{
int i;
STACK *sk;
return(1);
}
-int PKCS7_RECIP_INFO_set(p7i,x509)
-PKCS7_RECIP_INFO *p7i;
-X509 *x509;
+int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509)
{
ASN1_INTEGER_set(p7i->version,0);
X509_NAME_set(&p7i->issuer_and_serial->issuer,
return(1);
}
-X509 *PKCS7_cert_from_signer_info(p7,si)
-PKCS7 *p7;
-PKCS7_SIGNER_INFO *si;
+X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
{
if (PKCS7_type_is_signed(p7))
return(X509_find_by_issuer_and_serial(p7->d.sign->cert,
return(NULL);
}
-int PKCS7_set_cipher(p7,cipher)
-PKCS7 *p7;
-EVP_CIPHER *cipher;
+int PKCS7_set_cipher(PKCS7 *p7, EVP_CIPHER *cipher)
{
int i;
PKCS7_ENC_CONTENT *ec;
#endif
-void ERR_load_PKCS7_strings()
+void ERR_load_PKCS7_strings(void)
{
static int init=1;
}
/* should be X509 * but we can just have them as char *. */
-int verify_callback(ok, ctx)
-int ok;
-X509_STORE_CTX *ctx;
+int verify_callback(int ok, X509_STORE_CTX *ctx)
{
char buf[256];
X509 *err_cert;
ssleay_rand_cleanup,
};
-RAND_METHOD *RAND_SSLeay()
+RAND_METHOD *RAND_SSLeay(void)
{
return(&rand_ssleay_meth);
}
-static void ssleay_rand_cleanup()
+static void ssleay_rand_cleanup(void)
{
memset(state,0,sizeof(state));
state_num=0;
md_count[1]=0;
}
-static void ssleay_rand_seed(buf,num)
-const void *buf;
-int num;
+static void ssleay_rand_seed(const void *buf, int num)
{
int i,j,k,st_idx,st_num;
MD_CTX m;
memset((char *)&m,0,sizeof(m));
}
-static void ssleay_rand_bytes(buf,num)
-unsigned char *buf;
-int num;
+static void ssleay_rand_bytes(unsigned char *buf, int num)
{
int i,j,k,st_num,st_idx;
MD_CTX m;
static RAND_METHOD *rand_meth= &rand_ssleay_meth;
#endif
-void RAND_set_rand_method(meth)
-RAND_METHOD *meth;
+void RAND_set_rand_method(RAND_METHOD *meth)
{
rand_meth=meth;
}
-RAND_METHOD *RAND_get_rand_method()
+RAND_METHOD *RAND_get_rand_method(void)
{
return(rand_meth);
}
-void RAND_cleanup()
+void RAND_cleanup(void)
{
if (rand_meth != NULL)
rand_meth->cleanup();
}
-void RAND_seed(buf,num)
-const void *buf;
-int num;
+void RAND_seed(const void *buf, int num)
{
if (rand_meth != NULL)
rand_meth->seed(buf,num);
}
-void RAND_bytes(buf,num)
-unsigned char *buf;
-int num;
+void RAND_bytes(unsigned char *buf, int num)
{
if (rand_meth != NULL)
rand_meth->bytes(buf,num);
/* #define RFILE ".rand" - defined in ../../e_os.h */
-int RAND_load_file(file,bytes)
-const char *file;
-long bytes;
+int RAND_load_file(const char *file, long bytes)
{
MS_STATIC unsigned char buf[BUFSIZE];
struct stat sb;
return(ret);
}
-int RAND_write_file(file)
-const char *file;
+int RAND_write_file(const char *file)
{
unsigned char buf[BUFSIZE];
int i,ret=0;
return(ret);
}
-char *RAND_file_name(buf,size)
-char *buf;
-int size;
+char *RAND_file_name(char *buf, int size)
{
char *s;
char *ret=NULL;
#include "rc2.h"
#include "rc2_locl.h"
-void RC2_cbc_encrypt(in, out, length, ks, iv, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-RC2_KEY *ks;
-unsigned char *iv;
-int encrypt;
+void RC2_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+ RC2_KEY *ks, unsigned char *iv, int encrypt)
{
register unsigned long tin0,tin1;
register unsigned long tout0,tout1,xor0,xor1;
tin[0]=tin[1]=0;
}
-void RC2_encrypt(d,key)
-unsigned long *d;
-RC2_KEY *key;
+void RC2_encrypt(unsigned long *d, RC2_KEY *key)
{
int i,n;
register RC2_INT *p0,*p1;
d[1]=(unsigned long)(x2&0xffff)|((unsigned long)(x3&0xffff)<<16L);
}
-void RC2_decrypt(d,key)
-unsigned long *d;
-RC2_KEY *key;
+void RC2_decrypt(unsigned long *d, RC2_KEY *key)
{
int i,n;
register RC2_INT *p0,*p1;
* Date: 11 Feb 1996 06:45:03 GMT
*/
-void RC2_ecb_encrypt(in, out, ks, encrypt)
-unsigned char *in;
-unsigned char *out;
-RC2_KEY *ks;
-int encrypt;
+void RC2_ecb_encrypt(unsigned char *in, unsigned char *out, RC2_KEY *ks,
+ int encrypt)
{
unsigned long l,d[2];
* BSAFE uses the 'retarded' version. What I previously shipped is
* the same as specifying 1024 for the 'bits' parameter. Bsafe uses
* a version where the bits parameter is the same as len*8 */
-void RC2_set_key(key,len,data,bits)
-RC2_KEY *key;
-int len;
-unsigned char *data;
-int bits;
+void RC2_set_key(RC2_KEY *key, int len, unsigned char *data, int bits)
{
int i,j;
unsigned char *k;
* 64bit block we have used is contained in *num;
*/
-void RC2_cfb64_encrypt(in, out, length, schedule, ivec, num, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-RC2_KEY *schedule;
-unsigned char *ivec;
-int *num;
-int encrypt;
+void RC2_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ RC2_KEY *schedule, unsigned char *ivec, int *num, int encrypt)
{
register unsigned long v0,v1,t;
register int n= *num;
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void RC2_ofb64_encrypt(in, out, length, schedule, ivec, num)
-unsigned char *in;
-unsigned char *out;
-long length;
-RC2_KEY *schedule;
-unsigned char *ivec;
-int *num;
+void RC2_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ RC2_KEY *schedule, unsigned char *ivec, int *num)
{
register unsigned long v0,v1,t;
register int n= *num;
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,n,err=0;
RC2_KEY key;
}
#ifdef undef
-static int cfb64_test(cfb_cipher)
-unsigned char *cfb_cipher;
+static int cfb64_test(unsigned char *cfb_cipher)
{
IDEA_KEY_SCHEDULE eks,dks;
int err=0,i,n;
return(err);
}
-static char *pt(p)
-unsigned char *p;
+static char *pt(unsigned char *p)
{
static char bufs[10][20];
static int bnum=0;
NULL
};
-int main(argc, argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
FILE *in=NULL,*out=NULL;
char *infile=NULL,*outfile=NULL,*keystr=NULL;
* Date: Wed, 14 Sep 1994 06:35:31 GMT
*/
-void RC4(key, len, indata, outdata)
-RC4_KEY *key;
-unsigned long len;
-unsigned char *indata;
-unsigned char *outdata;
+void RC4(RC4_KEY *key, unsigned long len, unsigned char *indata,
+ unsigned char *outdata)
{
register RC4_INT *d;
register RC4_INT x,y,tx,ty;
const char *RC4_version="RC4" OPENSSL_VERSION_PTEXT;
-const char *RC4_options()
+const char *RC4_options(void)
{
#ifdef RC4_INDEX
if (sizeof(RC4_INT) == 1)
* Date: Wed, 14 Sep 1994 06:35:31 GMT
*/
-void RC4_set_key(key, len, data)
-RC4_KEY *key;
-int len;
-register unsigned char *data;
+void RC4_set_key(RC4_KEY *key, int len, register unsigned char *data)
{
register RC4_INT tmp;
register int id1,id2;
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
{0},
};
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
int j;
char *RC5_version="RC5" OPENSSL_VERSION_PTEXT;
-void RC5_32_ecb_encrypt(in, out, ks, encrypt)
-unsigned char *in;
-unsigned char *out;
-RC5_32_KEY *ks;
-int encrypt;
+void RC5_32_ecb_encrypt(unsigned char *in, unsigned char *out, RC5_32_KEY *ks,
+ int encrypt)
{
unsigned long l,d[2];
#include "rc5.h"
#include "rc5_locl.h"
-void RC5_32_cbc_encrypt(in, out, length, ks, iv, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-RC5_32_KEY *ks;
-unsigned char *iv;
-int encrypt;
+void RC5_32_cbc_encrypt(unsigned char *in, unsigned char *out, long length,
+ RC5_32_KEY *ks, unsigned char *iv, int encrypt)
{
register unsigned long tin0,tin1;
register unsigned long tout0,tout1,xor0,xor1;
tin[0]=tin[1]=0;
}
-void RC5_32_encrypt(d,key)
-unsigned long *d;
-RC5_32_KEY *key;
+void RC5_32_encrypt(unsigned long *d, RC5_32_KEY *key)
{
RC5_32_INT a,b,*s;
d[1]=b;
}
-void RC5_32_decrypt(d,key)
-unsigned long *d;
-RC5_32_KEY *key;
+void RC5_32_decrypt(unsigned long *d, RC5_32_KEY *key)
{
RC5_32_INT a,b,*s;
#include "rc5.h"
#include "rc5_locl.h"
-void RC5_32_set_key(key,len,data,rounds)
-RC5_32_KEY *key;
-int len;
-unsigned char *data;
-int rounds;
+void RC5_32_set_key(RC5_32_KEY *key, int len, unsigned char *data,
+ int rounds)
{
RC5_32_INT L[64],l,ll,A,B,*S,k;
int i,j,m,c,t,ii,jj;
* 64bit block we have used is contained in *num;
*/
-void RC5_32_cfb64_encrypt(in, out, length, schedule, ivec, num, encrypt)
-unsigned char *in;
-unsigned char *out;
-long length;
-RC5_32_KEY *schedule;
-unsigned char *ivec;
-int *num;
-int encrypt;
+void RC5_32_cfb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ RC5_32_KEY *schedule, unsigned char *ivec, int *num, int encrypt)
{
register unsigned long v0,v1,t;
register int n= *num;
* used. The extra state information to record how much of the
* 64bit block we have used is contained in *num;
*/
-void RC5_32_ofb64_encrypt(in, out, length, schedule, ivec, num)
-unsigned char *in;
-unsigned char *out;
-long length;
-RC5_32_KEY *schedule;
-unsigned char *ivec;
-int *num;
+void RC5_32_ofb64_encrypt(unsigned char *in, unsigned char *out, long length,
+ RC5_32_KEY *schedule, unsigned char *ivec, int *num)
{
register unsigned long v0,v1,t;
register int n= *num;
SIGRETTYPE sig_done();
#endif
-SIGRETTYPE sig_done(sig)
-int sig;
+SIGRETTYPE sig_done(int sig)
{
signal(SIGALRM,sig_done);
run=0;
#define START 0
#define STOP 1
-double Time_F(s)
-int s;
+double Time_F(int s)
{
double ret;
#ifdef TIMES
#endif
}
-int main(argc,argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
{0x7c,0xb3,0xf1,0xdf,0x34,0xf9,0x48,0x11},
};
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,n,err=0;
RC5_32_KEY key;
}
#ifdef undef
-static int cfb64_test(cfb_cipher)
-unsigned char *cfb_cipher;
+static int cfb64_test(unsigned char *cfb_cipher)
{
IDEA_KEY_SCHEDULE eks,dks;
int err=0,i,n;
return(err);
}
-static char *pt(p)
-unsigned char *p;
+static char *pt(unsigned char *p)
{
static char bufs[10][20];
static int bnum=0;
int read();
#endif
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
int i,err=0;
FILE *IN;
exit(err);
}
-void do_fp(f)
-FILE *f;
+void do_fp(FILE *f)
{
RIPEMD160_CTX c;
unsigned char md[RIPEMD160_DIGEST_LENGTH];
pt(md);
}
-void pt(md)
-unsigned char *md;
+void pt(unsigned char *md)
{
int i;
# endif
#endif
-void RIPEMD160_Init(c)
-RIPEMD160_CTX *c;
+void RIPEMD160_Init(RIPEMD160_CTX *c)
{
c->A=RIPEMD160_A;
c->B=RIPEMD160_B;
c->num=0;
}
-void RIPEMD160_Update(c, data, len)
-RIPEMD160_CTX *c;
-register unsigned char *data;
-unsigned long len;
+void RIPEMD160_Update(RIPEMD160_CTX *c, register unsigned char *data,
+ unsigned long len)
{
register ULONG *p;
int sw,sc;
}
}
-void RIPEMD160_Transform(c,b)
-RIPEMD160_CTX *c;
-unsigned char *b;
+void RIPEMD160_Transform(RIPEMD160_CTX *c, unsigned char *b)
{
ULONG p[16];
#if !defined(L_ENDIAN)
#ifndef RMD160_ASM
-void ripemd160_block(ctx, X, num)
-RIPEMD160_CTX *ctx;
-register ULONG *X;
-int num;
+void ripemd160_block(RIPEMD160_CTX *ctx, register ULONG *X, int num)
{
register ULONG A,B,C,D,E;
ULONG a,b,c,d,e;
}
#endif
-void RIPEMD160_Final(md, c)
-unsigned char *md;
-RIPEMD160_CTX *c;
+void RIPEMD160_Final(unsigned char *md, RIPEMD160_CTX *c)
{
register int i,j;
register ULONG l;
}
#ifdef undef
-int printit(l)
-unsigned long *l;
+int printit(unsigned long *l)
{
int i,ii;
#include <stdio.h>
#include "rmd_locl.h"
-unsigned char *RIPEMD160(d, n, md)
-unsigned char *d;
-unsigned long n;
-unsigned char *md;
+unsigned char *RIPEMD160(unsigned char *d, unsigned long n,
+ unsigned char *md)
{
RIPEMD160_CTX c;
static unsigned char m[RIPEMD160_DIGEST_LENGTH];
static char *pt();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
unsigned char **P,**R;
return(0);
}
-static char *pt(md)
-unsigned char *md;
+static char *pt(unsigned char *md)
{
int i;
static char buf[80];
NULL,
};
-RSA_METHOD *RSA_PKCS1_SSLeay()
+RSA_METHOD *RSA_PKCS1_SSLeay(void)
{
return(&rsa_pkcs1_eay_meth);
}
-static int RSA_eay_public_encrypt(flen, from, to, rsa, padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+static int RSA_eay_public_encrypt(int flen, unsigned char *from,
+ unsigned char *to, RSA *rsa, int padding)
{
BIGNUM f,ret;
int i,j,k,num=0,r= -1;
return(r);
}
-static int RSA_eay_private_encrypt(flen, from, to, rsa, padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+static int RSA_eay_private_encrypt(int flen, unsigned char *from,
+ unsigned char *to, RSA *rsa, int padding)
{
BIGNUM f,ret;
int i,j,k,num=0,r= -1;
return(r);
}
-static int RSA_eay_private_decrypt(flen, from, to, rsa,padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+static int RSA_eay_private_decrypt(int flen, unsigned char *from,
+ unsigned char *to, RSA *rsa, int padding)
{
BIGNUM f,ret;
int j,num=0,r= -1;
return(r);
}
-static int RSA_eay_public_decrypt(flen, from, to, rsa, padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+static int RSA_eay_public_decrypt(int flen, unsigned char *from,
+ unsigned char *to, RSA *rsa, int padding)
{
BIGNUM f,ret;
int i,num=0,r= -1;
return(r);
}
-static int RSA_eay_mod_exp(r0, I, rsa)
-BIGNUM *r0;
-BIGNUM *I;
-RSA *rsa;
+static int RSA_eay_mod_exp(BIGNUM *r0, BIGNUM *I, RSA *rsa)
{
BIGNUM r1,m1;
int ret=0;
return(ret);
}
-static int RSA_eay_init(rsa)
-RSA *rsa;
+static int RSA_eay_init(RSA *rsa)
{
rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
return(1);
}
-static int RSA_eay_finish(rsa)
-RSA *rsa;
+static int RSA_eay_finish(RSA *rsa)
{
if (rsa->_method_mod_n != NULL)
BN_MONT_CTX_free(rsa->_method_mod_n);
#endif
-void ERR_load_RSA_strings()
+void ERR_load_RSA_strings(void)
{
static int init=1;
#include "bn.h"
#include "rsa.h"
-RSA *RSA_generate_key(bits, e_value, callback,cb_arg)
-int bits;
-unsigned long e_value;
-void (*callback)(P_I_I_P);
-char *cb_arg;
+RSA *RSA_generate_key(int bits, unsigned long e_value,
+ void (*callback)(P_I_I_P), char *cb_arg)
{
RSA *rsa=NULL;
BIGNUM *r0=NULL,*r1=NULL,*r2=NULL,*r3=NULL,*tmp;
static int rsa_meth_num=0;
static STACK *rsa_meth=NULL;
-RSA *RSA_new()
+RSA *RSA_new(void)
{
return(RSA_new_method(NULL));
}
-void RSA_set_default_method(meth)
-RSA_METHOD *meth;
+void RSA_set_default_method(RSA_METHOD *meth)
{
default_RSA_meth=meth;
}
-RSA *RSA_new_method(meth)
-RSA_METHOD *meth;
+RSA *RSA_new_method(RSA_METHOD *meth)
{
RSA *ret;
return(ret);
}
-void RSA_free(r)
-RSA *r;
+void RSA_free(RSA *r)
{
int i;
Free(r);
}
-int RSA_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
+int RSA_get_ex_new_index(long argl, char *argp, int (*new_func)(),
+ int (*dup_func)(), void (*free_func)())
{
rsa_meth_num++;
return(CRYPTO_get_ex_new_index(rsa_meth_num-1,
&rsa_meth,argl,argp,new_func,dup_func,free_func));
}
-int RSA_set_ex_data(r,idx,arg)
-RSA *r;
-int idx;
-char *arg;
+int RSA_set_ex_data(RSA *r, int idx, char *arg)
{
return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
}
-char *RSA_get_ex_data(r,idx)
-RSA *r;
-int idx;
+char *RSA_get_ex_data(RSA *r, int idx)
{
return(CRYPTO_get_ex_data(&r->ex_data,idx));
}
-int RSA_size(r)
-RSA *r;
+int RSA_size(RSA *r)
{
return(BN_num_bytes(r->n));
}
-int RSA_public_encrypt(flen, from, to, rsa, padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+int RSA_public_encrypt(int flen, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
return(rsa->meth->rsa_pub_enc(flen, from, to, rsa, padding));
}
-int RSA_private_encrypt(flen, from, to, rsa, padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+int RSA_private_encrypt(int flen, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
return(rsa->meth->rsa_priv_enc(flen, from, to, rsa, padding));
}
-int RSA_private_decrypt(flen, from, to, rsa, padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+int RSA_private_decrypt(int flen, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
return(rsa->meth->rsa_priv_dec(flen, from, to, rsa, padding));
}
-int RSA_public_decrypt(flen, from, to, rsa, padding)
-int flen;
-unsigned char *from;
-unsigned char *to;
-RSA *rsa;
-int padding;
+int RSA_public_decrypt(int flen, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
return(rsa->meth->rsa_pub_dec(flen, from, to, rsa, padding));
}
-int RSA_flags(r)
-RSA *r;
+int RSA_flags(RSA *r)
{
return((r == NULL)?0:r->meth->flags);
}
-void RSA_blinding_off(rsa)
-RSA *rsa;
+void RSA_blinding_off(RSA *rsa)
{
if (rsa->blinding != NULL)
{
rsa->flags&= ~RSA_FLAG_BLINDING;
}
-int RSA_blinding_on(rsa,p_ctx)
-RSA *rsa;
-BN_CTX *p_ctx;
+int RSA_blinding_on(RSA *rsa, BN_CTX *p_ctx)
{
BIGNUM *A,*Ai;
BN_CTX *ctx;
return(ret);
}
-int RSA_memory_lock(r)
-RSA *r;
+int RSA_memory_lock(RSA *r)
{
int i,j,k,off;
char *p;
#include "rsa.h"
#include "rand.h"
-int RSA_padding_add_none(to,tlen,from,flen)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
+int RSA_padding_add_none(unsigned char *to, int tlen, unsigned char *from,
+ int flen)
{
if (flen > tlen)
{
return(1);
}
-int RSA_padding_check_none(to,tlen,from,flen,num)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
-int num;
+int RSA_padding_check_none(unsigned char *to, int tlen, unsigned char *from,
+ int flen, int num)
{
if (flen > tlen)
int MGF1(unsigned char *mask, long len, unsigned char *seed, long seedlen);
-int RSA_padding_add_PKCS1_OAEP(to, tlen, from, flen, param, plen)
- unsigned char *to;
- int tlen;
- unsigned char *from;
- int flen;
- unsigned char *param;
- int plen;
+int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
+ unsigned char *from, int flen, unsigned char *param, int plen)
{
int i, emlen = tlen - 1;
unsigned char *db, *seed;
return (1);
}
-int RSA_padding_check_PKCS1_OAEP(to, tlen, from, flen, num, param, plen)
- unsigned char *to;
- int tlen;
- unsigned char *from;
- int flen;
- int num;
- unsigned char *param;
- int plen;
+int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
+ unsigned char *from, int flen, int num, unsigned char *param,
+ int plen)
{
int i, dblen, mlen = -1;
unsigned char *maskeddb;
SetKey;
}
-int pad_unknown()
+int pad_unknown(void)
{
unsigned long l;
while ((l = ERR_get_error()) != 0)
#endif
-int RSA_padding_add_PKCS1_type_1(to,tlen,from,flen)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
+int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen,
+ unsigned char *from, int flen)
{
int j;
unsigned char *p;
return(1);
}
-int RSA_padding_check_PKCS1_type_1(to,tlen,from,flen,num)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
-int num;
+int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen,
+ unsigned char *from, int flen, int num)
{
int i,j;
unsigned char *p;
return(j);
}
-int RSA_padding_add_PKCS1_type_2(to,tlen,from,flen)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
+int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen,
+ unsigned char *from, int flen)
{
int i,j;
unsigned char *p;
return(1);
}
-int RSA_padding_check_PKCS1_type_2(to,tlen,from,flen,num)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
-int num;
+int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen,
+ unsigned char *from, int flen, int num)
{
int i,j;
unsigned char *p;
#include "objects.h"
#include "x509.h"
-int RSA_sign_ASN1_OCTET_STRING(type,m,m_len,sigret,siglen,rsa)
-int type;
-unsigned char *m;
-unsigned int m_len;
-unsigned char *sigret;
-unsigned int *siglen;
-RSA *rsa;
+int RSA_sign_ASN1_OCTET_STRING(int type, unsigned char *m, unsigned int m_len,
+ unsigned char *sigret, unsigned int *siglen, RSA *rsa)
{
ASN1_OCTET_STRING sig;
int i,j,ret=1;
return(ret);
}
-int RSA_verify_ASN1_OCTET_STRING(dtype, m, m_len, sigbuf, siglen, rsa)
-int dtype;
-unsigned char *m;
-unsigned int m_len;
-unsigned char *sigbuf;
-unsigned int siglen;
-RSA *rsa;
+int RSA_verify_ASN1_OCTET_STRING(int dtype, unsigned char *m,
+ unsigned int m_len, unsigned char *sigbuf, unsigned int siglen,
+ RSA *rsa)
{
int i,ret=0;
unsigned char *p,*s;
#include "objects.h"
#include "x509.h"
-int RSA_sign(type,m,m_len,sigret,siglen,rsa)
-int type;
-unsigned char *m;
-unsigned int m_len;
-unsigned char *sigret;
-unsigned int *siglen;
-RSA *rsa;
+int RSA_sign(int type, unsigned char *m, unsigned int m_len,
+ unsigned char *sigret, unsigned int *siglen, RSA *rsa)
{
X509_SIG sig;
ASN1_TYPE parameter;
return(ret);
}
-int RSA_verify(dtype, m, m_len, sigbuf, siglen, rsa)
-int dtype;
-unsigned char *m;
-unsigned int m_len;
-unsigned char *sigbuf;
-unsigned int siglen;
-RSA *rsa;
+int RSA_verify(int dtype, unsigned char *m, unsigned int m_len,
+ unsigned char *sigbuf, unsigned int siglen, RSA *rsa)
{
int i,ret=0,sigtype;
unsigned char *p,*s;
#include "rsa.h"
#include "rand.h"
-int RSA_padding_add_SSLv23(to,tlen,from,flen)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
+int RSA_padding_add_SSLv23(unsigned char *to, int tlen, unsigned char *from,
+ int flen)
{
int i,j;
unsigned char *p;
return(1);
}
-int RSA_padding_check_SSLv23(to,tlen,from,flen,num)
-unsigned char *to;
-int tlen;
-unsigned char *from;
-int flen;
-int num;
+int RSA_padding_check_SSLv23(unsigned char *to, int tlen, unsigned char *from,
+ int flen, int num)
{
int i,j,k;
unsigned char *p;
int read();
#endif
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
int i,err=0;
FILE *IN;
exit(err);
}
-void do_fp(f)
-FILE *f;
+void do_fp(FILE *f)
{
SHA_CTX c;
unsigned char md[SHA_DIGEST_LENGTH];
pt(md);
}
-void pt(md)
-unsigned char *md;
+void pt(unsigned char *md)
{
int i;
int read();
#endif
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
int i,err=0;
FILE *IN;
exit(err);
}
-void do_fp(f)
-FILE *f;
+void do_fp(FILE *f)
{
SHA_CTX c;
unsigned char md[SHA_DIGEST_LENGTH];
pt(md);
}
-void pt(md)
-unsigned char *md;
+void pt(unsigned char *md)
{
int i;
#include <string.h>
#include "sha.h"
-unsigned char *SHA1(d, n, md)
-unsigned char *d;
-unsigned long n;
-unsigned char *md;
+unsigned char *SHA1(unsigned char *d, unsigned long n, unsigned char *md)
{
SHA_CTX c;
static unsigned char m[SHA_DIGEST_LENGTH];
# define M_nl2c nl2c
#endif
-void SHA1_Init(c)
-SHA_CTX *c;
+void SHA1_Init(SHA_CTX *c)
{
c->h0=INIT_DATA_h0;
c->h1=INIT_DATA_h1;
c->num=0;
}
-void SHA1_Update(c, data, len)
-SHA_CTX *c;
-register unsigned char *data;
-unsigned long len;
+void SHA1_Update(SHA_CTX *c, register unsigned char *data,
+ unsigned long len)
{
register ULONG *p;
int ew,ec,sw,sc;
p[sw]=l;
}
-void SHA1_Transform(c,b)
-SHA_CTX *c;
-unsigned char *b;
+void SHA1_Transform(SHA_CTX *c, unsigned char *b)
{
ULONG p[16];
#ifndef B_ENDIAN
#ifndef SHA1_ASM
-void sha1_block(c, W, num)
-SHA_CTX *c;
-register unsigned long *W;
-int num;
+void sha1_block(SHA_CTX *c, register unsigned long *W, int num)
{
register ULONG A,B,C,D,E,T;
ULONG X[16];
}
#endif
-void SHA1_Final(md, c)
-unsigned char *md;
-SHA_CTX *c;
+void SHA1_Final(unsigned char *md, SHA_CTX *c)
{
register int i,j;
register ULONG l;
static char *pt();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
unsigned char **P,**R;
return(0);
}
-static char *pt(md)
-unsigned char *md;
+static char *pt(unsigned char *md)
{
int i;
static char buf[80];
#define M_p_c2nl_p p_c2nl_p
#define M_nl2c nl2c
-void SHA_Init(c)
-SHA_CTX *c;
+void SHA_Init(SHA_CTX *c)
{
c->h0=INIT_DATA_h0;
c->h1=INIT_DATA_h1;
c->num=0;
}
-void SHA_Update(c, data, len)
-SHA_CTX *c;
-register unsigned char *data;
-unsigned long len;
+void SHA_Update(SHA_CTX *c, register unsigned char *data, unsigned long len)
{
register ULONG *p;
int ew,ec,sw,sc;
p[sw]=l;
}
-void SHA_Transform(c,b)
-SHA_CTX *c;
-unsigned char *b;
+void SHA_Transform(SHA_CTX *c, unsigned char *b)
{
ULONG p[16];
#if !defined(B_ENDIAN)
sha_block(c,p,64);
}
-void sha_block(c, W, num)
-SHA_CTX *c;
-register unsigned long *W;
-int num;
+void sha_block(SHA_CTX *c, register unsigned long *W, int num)
{
register ULONG A,B,C,D,E,T;
ULONG X[16];
}
}
-void SHA_Final(md, c)
-unsigned char *md;
-SHA_CTX *c;
+void SHA_Final(unsigned char *md, SHA_CTX *c)
{
register int i,j;
register ULONG l;
#include <string.h>
#include "sha.h"
-unsigned char *SHA(d, n, md)
-unsigned char *d;
-unsigned long n;
-unsigned char *md;
+unsigned char *SHA(unsigned char *d, unsigned long n, unsigned char *md)
{
SHA_CTX c;
static unsigned char m[SHA_DIGEST_LENGTH];
static char *pt();
#endif
-int main(argc,argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
int i,err=0;
unsigned char **P,**R;
return(0);
}
-static char *pt(md)
-unsigned char *md;
+static char *pt(unsigned char *md)
{
int i;
static char buf[80];
#include <errno.h>
-int (*sk_set_cmp_func(sk,c))()
-STACK *sk;
-int (*c)();
+int (*sk_set_cmp_func(STACK *sk, int (*c)()))(void)
{
int (*old)()=sk->comp;
return old;
}
-STACK *sk_dup(sk)
-STACK *sk;
+STACK *sk_dup(STACK *sk)
{
STACK *ret;
char **s;
return(NULL);
}
-STACK *sk_new(c)
-int (*c)();
+STACK *sk_new(int (*c)())
{
STACK *ret;
int i;
return(NULL);
}
-int sk_insert(st,data,loc)
-STACK *st;
-char *data;
-int loc;
+int sk_insert(STACK *st, char *data, int loc)
{
char **s;
return(st->num);
}
-char *sk_delete_ptr(st,p)
-STACK *st;
-char *p;
+char *sk_delete_ptr(STACK *st, char *p)
{
int i;
return(NULL);
}
-char *sk_delete(st,loc)
-STACK *st;
-int loc;
+char *sk_delete(STACK *st, int loc)
{
char *ret;
int i,j;
return(ret);
}
-int sk_find(st,data)
-STACK *st;
-char *data;
+int sk_find(STACK *st, char *data)
{
char **r;
int i;
return(i);
}
-int sk_push(st,data)
-STACK *st;
-char *data;
+int sk_push(STACK *st, char *data)
{
return(sk_insert(st,data,st->num));
}
-int sk_unshift(st,data)
-STACK *st;
-char *data;
+int sk_unshift(STACK *st, char *data)
{
return(sk_insert(st,data,0));
}
-char *sk_shift(st)
-STACK *st;
+char *sk_shift(STACK *st)
{
if (st == NULL) return(NULL);
if (st->num <= 0) return(NULL);
return(sk_delete(st,0));
}
-char *sk_pop(st)
-STACK *st;
+char *sk_pop(STACK *st)
{
if (st == NULL) return(NULL);
if (st->num <= 0) return(NULL);
return(sk_delete(st,st->num-1));
}
-void sk_zero(st)
-STACK *st;
+void sk_zero(STACK *st)
{
if (st == NULL) return;
if (st->num <= 0) return;
st->num=0;
}
-void sk_pop_free(st,func)
-STACK *st;
-void (*func)();
+void sk_pop_free(STACK *st, void (*func)())
{
int i;
sk_free(st);
}
-void sk_free(st)
-STACK *st;
+void sk_free(STACK *st)
{
if (st == NULL) return;
if (st->data != NULL) Free((char *)st->data);
int doit();
#endif
-static void print_stats(fp,ctx)
-FILE *fp;
-SSL_CTX *ctx;
+static void print_stats(FILE *fp, SSL_CTX *ctx)
{
fprintf(fp,"%4ld items in the session cache\n",
SSL_CTX_sess_number(ctx));
fprintf(fp,"%4d session cache timeouts\n",SSL_CTX_sess_timeouts(ctx));
}
-static void sv_usage()
+static void sv_usage(void)
{
fprintf(stderr,"usage: ssltest [args ...]\n");
fprintf(stderr,"\n");
fprintf(stderr," -ssl3 - just SSLv3n\n");
}
-int main(argc, argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
char *CApath=NULL,*CAfile=NULL;
int badop=0;
#define C_DONE 1
#define S_DONE 2
-int ndoit(ssl_ctx)
-SSL_CTX *ssl_ctx[2];
+int ndoit(SSL_CTX *ssl_ctx[2])
{
int i;
int ret;
return(0);
}
-int doit(ctx)
-char *ctx[4];
+int doit(char *ctx[4])
{
SSL_CTX *s_ctx,*c_ctx;
static char cbuf[200],sbuf[200];
return(0);
}
-int MS_CALLBACK verify_callback(ok, xs, xi, depth, error, arg)
-int ok;
-X509 *xs;
-X509 *xi;
-int depth;
-int error;
-char *arg;
+int MS_CALLBACK verify_callback(int ok, X509 *xs, X509 *xi, int depth,
+ int error, char *arg)
{
char buf[256];
static HANDLE lock_cs[CRYPTO_NUM_LOCKS];
-void thread_setup()
+void thread_setup(void)
{
int i;
/* id callback defined */
}
-void thread_cleanup()
+void thread_cleanup(void)
{
int i;
CloseHandle(lock_cs[i]);
}
-void win32_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void win32_locking_callback(int mode, int type, char *file, int line)
{
if (mode & CRYPTO_LOCK)
{
}
}
-void do_threads(s_ctx,c_ctx)
-SSL_CTX *s_ctx,*c_ctx;
+void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
{
double ret;
SSL_CTX *ssl_ctx[2];
/*static rwlock_t lock_cs[CRYPTO_NUM_LOCKS]; */
static long lock_count[CRYPTO_NUM_LOCKS];
-void thread_setup()
+void thread_setup(void)
{
int i;
CRYPTO_set_locking_callback((void (*)())solaris_locking_callback);
}
-void thread_cleanup()
+void thread_cleanup(void)
{
int i;
fprintf(stderr,"done cleanup\n");
}
-void solaris_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void solaris_locking_callback(int mode, int type, char *file, int line)
{
#ifdef undef
fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
}
}
-void do_threads(s_ctx,c_ctx)
-SSL_CTX *s_ctx,*c_ctx;
+void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
{
SSL_CTX *ssl_ctx[2];
thread_t thread_ctx[MAX_THREAD_NUMBER];
s_ctx->references,c_ctx->references);
}
-unsigned long solaris_thread_id()
+unsigned long solaris_thread_id(void)
{
unsigned long ret;
static usptr_t *arena;
static usema_t *lock_cs[CRYPTO_NUM_LOCKS];
-void thread_setup()
+void thread_setup(void)
{
int i;
char filename[20];
CRYPTO_set_locking_callback((void (*)())irix_locking_callback);
}
-void thread_cleanup()
+void thread_cleanup(void)
{
int i;
}
}
-void irix_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void irix_locking_callback(int mode, int type, char *file, int line)
{
if (mode & CRYPTO_LOCK)
{
}
}
-void do_threads(s_ctx,c_ctx)
-SSL_CTX *s_ctx,*c_ctx;
+void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
{
SSL_CTX *ssl_ctx[2];
int thread_ctx[MAX_THREAD_NUMBER];
s_ctx->references,c_ctx->references);
}
-unsigned long irix_thread_id()
+unsigned long irix_thread_id(void)
{
unsigned long ret;
static pthread_mutex_t lock_cs[CRYPTO_NUM_LOCKS];
static long lock_count[CRYPTO_NUM_LOCKS];
-void thread_setup()
+void thread_setup(void)
{
int i;
CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
}
-void thread_cleanup()
+void thread_cleanup(void)
{
int i;
fprintf(stderr,"done cleanup\n");
}
-void pthreads_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void pthreads_locking_callback(int mode, int type, char *file,
+ int line)
{
#ifdef undef
fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
}
}
-void do_threads(s_ctx,c_ctx)
-SSL_CTX *s_ctx,*c_ctx;
+void do_threads(SSL_CTX *s_ctx, SSL_CTX *c_ctx)
{
SSL_CTX *ssl_ctx[2];
pthread_t thread_ctx[MAX_THREAD_NUMBER];
s_ctx->references,c_ctx->references);
}
-unsigned long pthreads_thread_id()
+unsigned long pthreads_thread_id(void)
{
unsigned long ret;
static HANDLE lock_cs[CRYPTO_NUM_LOCKS];
-int CRYPTO_thread_setup()
+int CRYPTO_thread_setup(void)
{
int i;
return(1);
}
-static void CRYPTO_thread_cleanup()
+static void CRYPTO_thread_cleanup(void)
{
int i;
CloseHandle(lock_cs[i]);
}
-void win32_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void win32_locking_callback(int mode, int type, char *file, int line)
{
if (mode & CRYPTO_LOCK)
{
static rwlock_t lock_cs[CRYPTO_NUM_LOCKS];
#endif
-void CRYPTO_thread_setup()
+void CRYPTO_thread_setup(void)
{
int i;
CRYPTO_set_locking_callback((void (*)())solaris_locking_callback);
}
-void CRYPTO_thread_cleanup()
+void CRYPTO_thread_cleanup(void)
{
int i;
}
}
-void solaris_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void solaris_locking_callback(int mode, int type, char *file, int line)
{
#if 0
fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
}
}
-unsigned long solaris_thread_id()
+unsigned long solaris_thread_id(void)
{
unsigned long ret;
static usptr_t *arena;
static usema_t *lock_cs[CRYPTO_NUM_LOCKS];
-void CRYPTO_thread_setup()
+void CRYPTO_thread_setup(void)
{
int i;
char filename[20];
CRYPTO_set_locking_callback((void (*)())irix_locking_callback);
}
-void CRYPTO_thread_cleanup()
+void CRYPTO_thread_cleanup(void)
{
int i;
}
}
-void irix_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void irix_locking_callback(int mode, int type, char *file, int line)
{
if (mode & CRYPTO_LOCK)
{
}
}
-unsigned long irix_thread_id()
+unsigned long irix_thread_id(void)
{
unsigned long ret;
static pthread_mutex_t lock_cs[CRYPTO_NUM_LOCKS];
static long lock_count[CRYPTO_NUM_LOCKS];
-void CRYPTO_thread_setup()
+void CRYPTO_thread_setup(void)
{
int i;
CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
}
-void thread_cleanup()
+void thread_cleanup(void)
{
int i;
}
}
-void pthreads_locking_callback(mode,type,file,line)
-int mode;
-int type;
-char *file;
-int line;
+void pthreads_locking_callback(int mode, int type, char *file,
+ int line)
{
#if 0
fprintf(stderr,"thread=%4d mode=%s lock=%s %s:%d\n",
}
}
-unsigned long pthreads_thread_id()
+unsigned long pthreads_thread_id(void)
{
unsigned long ret;
#endif
} MS_TM;
-char *ms_time_new()
+char *ms_time_new(void)
{
MS_TM *ret;
return((char *)ret);
}
-void ms_time_free(a)
-char *a;
+void ms_time_free(char *a)
{
if (a != NULL)
Free(a);
}
-void ms_time_get(a)
-char *a;
+void ms_time_get(char *a)
{
MS_TM *tm=(MS_TM *)a;
#ifdef WIN32
#endif
}
-double ms_time_diff(ap,bp)
-char *ap,*bp;
+double ms_time_diff(char *ap, char *bp)
{
MS_TM *a=(MS_TM *)ap;
MS_TM *b=(MS_TM *)bp;
return((ret < 0.0000001)?0.0000001:ret);
}
-int ms_time_cmp(ap,bp)
-char *ap,*bp;
+int ms_time_cmp(char *ap, char *bp)
{
MS_TM *a=(MS_TM *)ap,*b=(MS_TM *)bp;
double d;
const char *TXT_DB_version="TXT_DB" OPENSSL_VERSION_PTEXT;
-TXT_DB *TXT_DB_read(in,num)
-BIO *in;
-int num;
+TXT_DB *TXT_DB_read(BIO *in, int num)
{
TXT_DB *ret=NULL;
int er=1;
return(ret);
}
-char **TXT_DB_get_by_index(db,idx,value)
-TXT_DB *db;
-int idx;
-char **value;
+char **TXT_DB_get_by_index(TXT_DB *db, int idx, char **value)
{
char **ret;
LHASH *lh;
return(ret);
}
-int TXT_DB_create_index(db,field,qual,hash,cmp)
-TXT_DB *db;
-int field;
-int (*qual)();
-unsigned long (*hash)();
-int (*cmp)();
+int TXT_DB_create_index(TXT_DB *db, int field, int (*qual)(),
+ unsigned long (*hash)(), int (*cmp)())
{
LHASH *idx;
char *r;
return(1);
}
-long TXT_DB_write(out,db)
-BIO *out;
-TXT_DB *db;
+long TXT_DB_write(BIO *out, TXT_DB *db)
{
long i,j,n,nn,l,tot=0;
char *p,**pp,*f;
return(ret);
}
-int TXT_DB_insert(db,row)
-TXT_DB *db;
-char **row;
+int TXT_DB_insert(TXT_DB *db, char **row)
{
int i;
char **r;
return(0);
}
-void TXT_DB_free(db)
-TXT_DB *db;
+void TXT_DB_free(TXT_DB *db)
{
int i,n;
char **p,*max;
NULL, /* get_by_alias */
};
-X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir()
+X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void)
{
return(&x509_dir_lookup);
}
-static int dir_ctrl(ctx,cmd,argp,argl,retp)
-X509_LOOKUP *ctx;
-int cmd;
-long argl;
-char *argp;
-char **retp;
+static int dir_ctrl(X509_LOOKUP *ctx, int cmd, char *argp, long argl,
+ char **retp)
{
int ret=0;
BY_DIR *ld;
return(ret);
}
-static int new_dir(lu)
-X509_LOOKUP *lu;
+static int new_dir(X509_LOOKUP *lu)
{
BY_DIR *a;
return(1);
}
-static void free_dir(lu)
-X509_LOOKUP *lu;
+static void free_dir(X509_LOOKUP *lu)
{
BY_DIR *a;
int i;
Free(a);
}
-static int add_cert_dir(ctx,dir, type)
-BY_DIR *ctx;
-const char *dir;
-int type;
+static int add_cert_dir(BY_DIR *ctx, const char *dir, int type)
{
int j,len;
int *ip;
return(1);
}
-static int get_cert_by_subject(xl,type,name,ret)
-X509_LOOKUP *xl;
-int type;
-X509_NAME *name;
-X509_OBJECT *ret;
+static int get_cert_by_subject(X509_LOOKUP *xl, int type, X509_NAME *name,
+ X509_OBJECT *ret)
{
BY_DIR *ctx;
union {
NULL, /* get_by_alias */
};
-X509_LOOKUP_METHOD *X509_LOOKUP_file()
+X509_LOOKUP_METHOD *X509_LOOKUP_file(void)
{
return(&x509_file_lookup);
}
-static int by_file_ctrl(ctx,cmd,argp,argl,ret)
-X509_LOOKUP *ctx;
-int cmd;
-char *argp;
-long argl;
-char **ret;
+static int by_file_ctrl(X509_LOOKUP *ctx, int cmd, char *argp, long argl,
+ char **ret)
{
int ok=0,ok2=0;
char *file;
return((ok && ok2)?ok:0);
}
-int X509_load_cert_file(ctx,file,type)
-X509_LOOKUP *ctx;
-const char *file;
-int type;
+int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type)
{
int ret=0;
BIO *in=NULL;
return(ret);
}
-int X509_load_crl_file(ctx,file,type)
-X509_LOOKUP *ctx;
-const char *file;
-int type;
+int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type)
{
int ret=0;
BIO *in=NULL;
#include "objects.h"
#include "x509.h"
-int X509_issuer_and_serial_cmp(a,b)
-X509 *a;
-X509 *b;
+int X509_issuer_and_serial_cmp(X509 *a, X509 *b)
{
int i;
X509_CINF *ai,*bi;
}
#ifndef NO_MD5
-unsigned long X509_issuer_and_serial_hash(a)
-X509 *a;
+unsigned long X509_issuer_and_serial_hash(X509 *a)
{
unsigned long ret=0;
MD5_CTX ctx;
}
#endif
-int X509_issuer_name_cmp(a, b)
-X509 *a;
-X509 *b;
+int X509_issuer_name_cmp(X509 *a, X509 *b)
{
return(X509_NAME_cmp(a->cert_info->issuer,b->cert_info->issuer));
}
-int X509_subject_name_cmp(a, b)
-X509 *a;
-X509 *b;
+int X509_subject_name_cmp(X509 *a, X509 *b)
{
return(X509_NAME_cmp(a->cert_info->subject,b->cert_info->subject));
}
-int X509_CRL_cmp(a, b)
-X509_CRL *a;
-X509_CRL *b;
+int X509_CRL_cmp(X509_CRL *a, X509_CRL *b)
{
return(X509_NAME_cmp(a->crl->issuer,b->crl->issuer));
}
-X509_NAME *X509_get_issuer_name(a)
-X509 *a;
+X509_NAME *X509_get_issuer_name(X509 *a)
{
return(a->cert_info->issuer);
}
-unsigned long X509_issuer_name_hash(x)
-X509 *x;
+unsigned long X509_issuer_name_hash(X509 *x)
{
return(X509_NAME_hash(x->cert_info->issuer));
}
-X509_NAME *X509_get_subject_name(a)
-X509 *a;
+X509_NAME *X509_get_subject_name(X509 *a)
{
return(a->cert_info->subject);
}
-ASN1_INTEGER *X509_get_serialNumber(a)
-X509 *a;
+ASN1_INTEGER *X509_get_serialNumber(X509 *a)
{
return(a->cert_info->serialNumber);
}
-unsigned long X509_subject_name_hash(x)
-X509 *x;
+unsigned long X509_subject_name_hash(X509 *x)
{
return(X509_NAME_hash(x->cert_info->subject));
}
-int X509_NAME_cmp(a, b)
-X509_NAME *a;
-X509_NAME *b;
+int X509_NAME_cmp(X509_NAME *a, X509_NAME *b)
{
int i,j;
X509_NAME_ENTRY *na,*nb;
#ifndef NO_MD5
/* I now DER encode the name and hash it. Since I cache the DER encoding,
* this is reasonably effiecent. */
-unsigned long X509_NAME_hash(x)
-X509_NAME *x;
+unsigned long X509_NAME_hash(X509_NAME *x)
{
unsigned long ret=0;
unsigned char md[16];
#endif
/* Search a stack of X509 for a match */
-X509 *X509_find_by_issuer_and_serial(sk,name,serial)
-STACK_OF(X509) *sk;
-X509_NAME *name;
-ASN1_INTEGER *serial;
+X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name,
+ ASN1_INTEGER *serial)
{
int i;
X509_CINF cinf;
return(NULL);
}
-X509 *X509_find_by_subject(sk,name)
-STACK_OF(X509) *sk;
-X509_NAME *name;
+X509 *X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name)
{
X509 *x509;
int i;
return(NULL);
}
-EVP_PKEY *X509_get_pubkey(x)
-X509 *x;
+EVP_PKEY *X509_get_pubkey(X509 *x)
{
if ((x == NULL) || (x->cert_info == NULL))
return(NULL);
return(X509_PUBKEY_get(x->cert_info->key));
}
-int X509_check_private_key(x,k)
-X509 *x;
-EVP_PKEY *k;
+int X509_check_private_key(X509 *x, EVP_PKEY *k)
{
EVP_PKEY *xk=NULL;
int ok=0;
#include "x509.h"
#ifndef NO_STDIO
-int X509_STORE_set_default_paths(ctx)
-X509_STORE *ctx;
+int X509_STORE_set_default_paths(X509_STORE *ctx)
{
X509_LOOKUP *lookup;
return(1);
}
-int X509_STORE_load_locations(ctx,file,path)
-X509_STORE *ctx;
-char *file;
-char *path;
+int X509_STORE_load_locations(X509_STORE *ctx, char *file, char *path)
{
X509_LOOKUP *lookup;
#include "crypto.h"
#include "x509.h"
-const char *X509_get_default_private_dir()
+const char *X509_get_default_private_dir(void)
{ return(X509_PRIVATE_DIR); }
-const char *X509_get_default_cert_area()
+const char *X509_get_default_cert_area(void)
{ return(X509_CERT_AREA); }
-const char *X509_get_default_cert_dir()
+const char *X509_get_default_cert_dir(void)
{ return(X509_CERT_DIR); }
-const char *X509_get_default_cert_file()
+const char *X509_get_default_cert_file(void)
{ return(X509_CERT_FILE); }
-const char *X509_get_default_cert_dir_env()
+const char *X509_get_default_cert_dir_env(void)
{ return(X509_CERT_DIR_EVP); }
-const char *X509_get_default_cert_file_env()
+const char *X509_get_default_cert_file_env(void)
{ return(X509_CERT_FILE_EVP); }
#endif
-void ERR_load_X509_strings()
+void ERR_load_X509_strings(void)
{
static int init=1;
#include "evp.h"
#include "x509.h"
-int X509_CRL_get_ext_count(x)
-X509_CRL *x;
+int X509_CRL_get_ext_count(X509_CRL *x)
{
return(X509v3_get_ext_count(x->crl->extensions));
}
-int X509_CRL_get_ext_by_NID(x,nid,lastpos)
-X509_CRL *x;
-int nid;
-int lastpos;
+int X509_CRL_get_ext_by_NID(X509_CRL *x, int nid, int lastpos)
{
return(X509v3_get_ext_by_NID(x->crl->extensions,nid,lastpos));
}
-int X509_CRL_get_ext_by_OBJ(x,obj,lastpos)
-X509_CRL *x;
-ASN1_OBJECT *obj;
-int lastpos;
+int X509_CRL_get_ext_by_OBJ(X509_CRL *x, ASN1_OBJECT *obj, int lastpos)
{
return(X509v3_get_ext_by_OBJ(x->crl->extensions,obj,lastpos));
}
-int X509_CRL_get_ext_by_critical(x,crit,lastpos)
-X509_CRL *x;
-int crit;
-int lastpos;
+int X509_CRL_get_ext_by_critical(X509_CRL *x, int crit, int lastpos)
{
return(X509v3_get_ext_by_critical(x->crl->extensions,crit,lastpos));
}
-X509_EXTENSION *X509_CRL_get_ext(x,loc)
-X509_CRL *x;
-int loc;
+X509_EXTENSION *X509_CRL_get_ext(X509_CRL *x, int loc)
{
return(X509v3_get_ext(x->crl->extensions,loc));
}
-X509_EXTENSION *X509_CRL_delete_ext(x,loc)
-X509_CRL *x;
-int loc;
+X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc)
{
return(X509v3_delete_ext(x->crl->extensions,loc));
}
-int X509_CRL_add_ext(x,ex,loc)
-X509_CRL *x;
-X509_EXTENSION *ex;
-int loc;
+int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc)
{
return(X509v3_add_ext(&(x->crl->extensions),ex,loc) != NULL);
}
-int X509_get_ext_count(x)
-X509 *x;
+int X509_get_ext_count(X509 *x)
{
return(X509v3_get_ext_count(x->cert_info->extensions));
}
-int X509_get_ext_by_NID(x,nid,lastpos)
-X509 *x;
-int nid;
-int lastpos;
+int X509_get_ext_by_NID(X509 *x, int nid, int lastpos)
{
return(X509v3_get_ext_by_NID(x->cert_info->extensions,nid,lastpos));
}
-int X509_get_ext_by_OBJ(x,obj,lastpos)
-X509 *x;
-ASN1_OBJECT *obj;
-int lastpos;
+int X509_get_ext_by_OBJ(X509 *x, ASN1_OBJECT *obj, int lastpos)
{
return(X509v3_get_ext_by_OBJ(x->cert_info->extensions,obj,lastpos));
}
-int X509_get_ext_by_critical(x,crit,lastpos)
-X509 *x;
-int crit;
-int lastpos;
+int X509_get_ext_by_critical(X509 *x, int crit, int lastpos)
{
return(X509v3_get_ext_by_critical(x->cert_info->extensions,crit,lastpos));
}
-X509_EXTENSION *X509_get_ext(x,loc)
-X509 *x;
-int loc;
+X509_EXTENSION *X509_get_ext(X509 *x, int loc)
{
return(X509v3_get_ext(x->cert_info->extensions,loc));
}
-X509_EXTENSION *X509_delete_ext(x,loc)
-X509 *x;
-int loc;
+X509_EXTENSION *X509_delete_ext(X509 *x, int loc)
{
return(X509v3_delete_ext(x->cert_info->extensions,loc));
}
-int X509_add_ext(x,ex,loc)
-X509 *x;
-X509_EXTENSION *ex;
-int loc;
+int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc)
{
return(X509v3_add_ext(&(x->cert_info->extensions),ex,loc) != NULL);
}
-int X509_REVOKED_get_ext_count(x)
-X509_REVOKED *x;
+int X509_REVOKED_get_ext_count(X509_REVOKED *x)
{
return(X509v3_get_ext_count(x->extensions));
}
-int X509_REVOKED_get_ext_by_NID(x,nid,lastpos)
-X509_REVOKED *x;
-int nid;
-int lastpos;
+int X509_REVOKED_get_ext_by_NID(X509_REVOKED *x, int nid, int lastpos)
{
return(X509v3_get_ext_by_NID(x->extensions,nid,lastpos));
}
-int X509_REVOKED_get_ext_by_OBJ(x,obj,lastpos)
-X509_REVOKED *x;
-ASN1_OBJECT *obj;
-int lastpos;
+int X509_REVOKED_get_ext_by_OBJ(X509_REVOKED *x, ASN1_OBJECT *obj,
+ int lastpos)
{
return(X509v3_get_ext_by_OBJ(x->extensions,obj,lastpos));
}
-int X509_REVOKED_get_ext_by_critical(x,crit,lastpos)
-X509_REVOKED *x;
-int crit;
-int lastpos;
+int X509_REVOKED_get_ext_by_critical(X509_REVOKED *x, int crit, int lastpos)
{
return(X509v3_get_ext_by_critical(x->extensions,crit,lastpos));
}
-X509_EXTENSION *X509_REVOKED_get_ext(x,loc)
-X509_REVOKED *x;
-int loc;
+X509_EXTENSION *X509_REVOKED_get_ext(X509_REVOKED *x, int loc)
{
return(X509v3_get_ext(x->extensions,loc));
}
-X509_EXTENSION *X509_REVOKED_delete_ext(x,loc)
-X509_REVOKED *x;
-int loc;
+X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc)
{
return(X509v3_delete_ext(x->extensions,loc));
}
-int X509_REVOKED_add_ext(x,ex,loc)
-X509_REVOKED *x;
-X509_EXTENSION *ex;
-int loc;
+int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc)
{
return(X509v3_add_ext(&(x->extensions),ex,loc) != NULL);
}
static STACK *x509_store_meth=NULL;
static STACK *x509_store_ctx_meth=NULL;
-X509_LOOKUP *X509_LOOKUP_new(method)
-X509_LOOKUP_METHOD *method;
+X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
{
X509_LOOKUP *ret;
return(ret);
}
-void X509_LOOKUP_free(ctx)
-X509_LOOKUP *ctx;
+void X509_LOOKUP_free(X509_LOOKUP *ctx)
{
if (ctx == NULL) return;
if ( (ctx->method != NULL) &&
Free(ctx);
}
-int X509_LOOKUP_init(ctx)
-X509_LOOKUP *ctx;
+int X509_LOOKUP_init(X509_LOOKUP *ctx)
{
if (ctx->method == NULL) return(0);
if (ctx->method->init != NULL)
return(1);
}
-int X509_LOOKUP_shutdown(ctx)
-X509_LOOKUP *ctx;
+int X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
{
if (ctx->method == NULL) return(0);
if (ctx->method->shutdown != NULL)
return(1);
}
-int X509_LOOKUP_ctrl(ctx,cmd,argc,argl,ret)
-X509_LOOKUP *ctx;
-int cmd;
-char *argc;
-long argl;
-char **ret;
+int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, char *argc, long argl,
+ char **ret)
{
if (ctx->method == NULL) return(-1);
if (ctx->method->ctrl != NULL)
return(1);
}
-int X509_LOOKUP_by_subject(ctx,type,name,ret)
-X509_LOOKUP *ctx;
-int type;
-X509_NAME *name;
-X509_OBJECT *ret;
+int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name,
+ X509_OBJECT *ret)
{
if ((ctx->method == NULL) || (ctx->method->get_by_subject == NULL))
return(X509_LU_FAIL);
return(ctx->method->get_by_subject(ctx,type,name,ret));
}
-int X509_LOOKUP_by_issuer_serial(ctx,type,name,serial,ret)
-X509_LOOKUP *ctx;
-int type;
-X509_NAME *name;
-ASN1_INTEGER *serial;
-X509_OBJECT *ret;
+int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, int type, X509_NAME *name,
+ ASN1_INTEGER *serial, X509_OBJECT *ret)
{
if ((ctx->method == NULL) ||
(ctx->method->get_by_issuer_serial == NULL))
return(ctx->method->get_by_issuer_serial(ctx,type,name,serial,ret));
}
-int X509_LOOKUP_by_fingerprint(ctx,type,bytes,len,ret)
-X509_LOOKUP *ctx;
-int type;
-unsigned char *bytes;
-int len;
-X509_OBJECT *ret;
+int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, int type,
+ unsigned char *bytes, int len, X509_OBJECT *ret)
{
if ((ctx->method == NULL) || (ctx->method->get_by_fingerprint == NULL))
return(X509_LU_FAIL);
return(ctx->method->get_by_fingerprint(ctx,type,bytes,len,ret));
}
-int X509_LOOKUP_by_alias(ctx,type,str,len,ret)
-X509_LOOKUP *ctx;
-int type;
-char *str;
-int len;
-X509_OBJECT *ret;
+int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, int type, char *str, int len,
+ X509_OBJECT *ret)
{
if ((ctx->method == NULL) || (ctx->method->get_by_alias == NULL))
return(X509_LU_FAIL);
return(ctx->method->get_by_alias(ctx,type,str,len,ret));
}
-static unsigned long x509_object_hash(a)
-X509_OBJECT *a;
+static unsigned long x509_object_hash(X509_OBJECT *a)
{
unsigned long h;
return(h);
}
-static int x509_object_cmp(a,b)
-X509_OBJECT *a,*b;
+static int x509_object_cmp(X509_OBJECT *a, X509_OBJECT *b)
{
int ret;
return(ret);
}
-X509_STORE *X509_STORE_new()
+X509_STORE *X509_STORE_new(void)
{
X509_STORE *ret;
return(ret);
}
-static void cleanup(a)
-X509_OBJECT *a;
+static void cleanup(X509_OBJECT *a)
{
if (a->type == X509_LU_X509)
{
Free(a);
}
-void X509_STORE_free(vfy)
-X509_STORE *vfy;
+void X509_STORE_free(X509_STORE *vfy)
{
int i;
STACK *sk;
Free(vfy);
}
-X509_LOOKUP *X509_STORE_add_lookup(v,m)
-X509_STORE *v;
-X509_LOOKUP_METHOD *m;
+X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)
{
int i;
STACK *sk;
}
}
-int X509_STORE_get_by_subject(vs,type,name,ret)
-X509_STORE_CTX *vs;
-int type;
-X509_NAME *name;
-X509_OBJECT *ret;
+int X509_STORE_get_by_subject(X509_STORE_CTX *vs, int type, X509_NAME *name,
+ X509_OBJECT *ret)
{
X509_STORE *ctx=vs->ctx;
X509_LOOKUP *lu;
return(1);
}
-void X509_OBJECT_up_ref_count(a)
-X509_OBJECT *a;
+void X509_OBJECT_up_ref_count(X509_OBJECT *a)
{
switch (a->type)
{
}
}
-void X509_OBJECT_free_contents(a)
-X509_OBJECT *a;
+void X509_OBJECT_free_contents(X509_OBJECT *a)
{
switch (a->type)
{
}
}
-X509_OBJECT *X509_OBJECT_retrieve_by_subject(h,type,name)
-LHASH *h;
-int type;
-X509_NAME *name;
+X509_OBJECT *X509_OBJECT_retrieve_by_subject(LHASH *h, int type,
+ X509_NAME *name)
{
X509_OBJECT stmp,*tmp;
X509 x509_s;
return(tmp);
}
-void X509_STORE_CTX_init(ctx,store,x509,chain)
-X509_STORE_CTX *ctx;
-X509_STORE *store;
-X509 *x509;
-STACK_OF(X509) *chain;
+void X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
+ STACK_OF(X509) *chain)
{
ctx->ctx=store;
ctx->current_method=0;
memset(&(ctx->ex_data),0,sizeof(CRYPTO_EX_DATA));
}
-void X509_STORE_CTX_cleanup(ctx)
-X509_STORE_CTX *ctx;
+void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
{
if (ctx->chain != NULL)
{
#include "x509.h"
#include "buffer.h"
-char *X509_NAME_oneline(a,buf,len)
-X509_NAME *a;
-char *buf;
-int len;
+char *X509_NAME_oneline(X509_NAME *a, char *buf, int len)
{
X509_NAME_ENTRY *ne;
unsigned int i;
#include "objects.h"
#include "buffer.h"
-X509 *X509_REQ_to_X509(r,days,pkey)
-X509_REQ *r;
-int days;
-EVP_PKEY *pkey;
+X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey)
{
X509 *ret=NULL;
X509_CINF *xi=NULL;
#include "buffer.h"
#include "pem.h"
-X509_REQ *X509_to_X509_REQ(x,pkey,md)
-X509 *x;
-EVP_PKEY *pkey;
-EVP_MD *md;
+X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, EVP_MD *md)
{
X509_REQ *ret;
X509_REQ_INFO *ri;
return(NULL);
}
-EVP_PKEY *X509_REQ_get_pubkey(req)
-X509_REQ *req;
+EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req)
{
if ((req == NULL) || (req->req_info == NULL))
return(NULL);
#include "evp.h"
#include "x509.h"
-int X509_set_version(x,version)
-X509 *x;
-long version;
+int X509_set_version(X509 *x, long version)
{
if (x == NULL) return(0);
if (x->cert_info->version == NULL)
return(ASN1_INTEGER_set(x->cert_info->version,version));
}
-int X509_set_serialNumber(x,serial)
-X509 *x;
-ASN1_INTEGER *serial;
+int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
{
ASN1_INTEGER *in;
return(in != NULL);
}
-int X509_set_issuer_name(x,name)
-X509 *x;
-X509_NAME *name;
+int X509_set_issuer_name(X509 *x, X509_NAME *name)
{
if ((x == NULL) || (x->cert_info == NULL)) return(0);
return(X509_NAME_set(&x->cert_info->issuer,name));
}
-int X509_set_subject_name(x,name)
-X509 *x;
-X509_NAME *name;
+int X509_set_subject_name(X509 *x, X509_NAME *name)
{
if ((x == NULL) || (x->cert_info == NULL)) return(0);
return(X509_NAME_set(&x->cert_info->subject,name));
}
-int X509_set_notBefore(x,tm)
-X509 *x;
-ASN1_UTCTIME *tm;
+int X509_set_notBefore(X509 *x, ASN1_UTCTIME *tm)
{
ASN1_UTCTIME *in;
return(in != NULL);
}
-int X509_set_notAfter(x,tm)
-X509 *x;
-ASN1_UTCTIME *tm;
+int X509_set_notAfter(X509 *x, ASN1_UTCTIME *tm)
{
ASN1_UTCTIME *in;
return(in != NULL);
}
-int X509_set_pubkey(x,pkey)
-X509 *x;
-EVP_PKEY *pkey;
+int X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
{
if ((x == NULL) || (x->cert_info == NULL)) return(0);
return(X509_PUBKEY_set(&(x->cert_info->key),pkey));
#include "x509.h"
#include "objects.h"
-const char *X509_verify_cert_error_string(n)
-long n;
+const char *X509_verify_cert_error_string(long n)
{
static char buf[100];
#include "evp.h"
#include "x509.h"
-int X509v3_get_ext_count(x)
-STACK *x;
+int X509v3_get_ext_count(STACK *x)
{
if (x == NULL) return(0);
return(sk_num(x));
}
-int X509v3_get_ext_by_NID(x,nid,lastpos)
-STACK *x;
-int nid;
-int lastpos;
+int X509v3_get_ext_by_NID(STACK *x, int nid, int lastpos)
{
ASN1_OBJECT *obj;
return(X509v3_get_ext_by_OBJ(x,obj,lastpos));
}
-int X509v3_get_ext_by_OBJ(sk,obj,lastpos)
-STACK *sk;
-ASN1_OBJECT *obj;
-int lastpos;
+int X509v3_get_ext_by_OBJ(STACK *sk, ASN1_OBJECT *obj, int lastpos)
{
int n;
X509_EXTENSION *ex;
return(-1);
}
-int X509v3_get_ext_by_critical(sk,crit,lastpos)
-STACK *sk;
-int crit;
-int lastpos;
+int X509v3_get_ext_by_critical(STACK *sk, int crit, int lastpos)
{
int n;
X509_EXTENSION *ex;
return(-1);
}
-X509_EXTENSION *X509v3_get_ext(x,loc)
-STACK *x;
-int loc;
+X509_EXTENSION *X509v3_get_ext(STACK *x, int loc)
{
if ((x == NULL) || (sk_num(x) <= loc) || (loc < 0))
return(NULL);
return((X509_EXTENSION *)sk_value(x,loc));
}
-X509_EXTENSION *X509v3_delete_ext(x,loc)
-STACK *x;
-int loc;
+X509_EXTENSION *X509v3_delete_ext(STACK *x, int loc)
{
X509_EXTENSION *ret;
return(ret);
}
-STACK *X509v3_add_ext(x,ex,loc)
-STACK **x;
-X509_EXTENSION *ex;
-int loc;
+STACK *X509v3_add_ext(STACK **x, X509_EXTENSION *ex, int loc)
{
X509_EXTENSION *new_ex=NULL;
int n;
return(NULL);
}
-X509_EXTENSION *X509_EXTENSION_create_by_NID(ex,nid,crit,data)
-X509_EXTENSION **ex;
-int nid;
-int crit;
-ASN1_OCTET_STRING *data;
+X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid,
+ int crit, ASN1_OCTET_STRING *data)
{
ASN1_OBJECT *obj;
X509_EXTENSION *ret;
return(ret);
}
-X509_EXTENSION *X509_EXTENSION_create_by_OBJ(ex,obj,crit,data)
-X509_EXTENSION **ex;
-ASN1_OBJECT *obj;
-int crit;
-ASN1_OCTET_STRING *data;
+X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
+ ASN1_OBJECT *obj, int crit, ASN1_OCTET_STRING *data)
{
X509_EXTENSION *ret;
return(NULL);
}
-int X509_EXTENSION_set_object(ex,obj)
-X509_EXTENSION *ex;
-ASN1_OBJECT *obj;
+int X509_EXTENSION_set_object(X509_EXTENSION *ex, ASN1_OBJECT *obj)
{
if ((ex == NULL) || (obj == NULL))
return(0);
return(1);
}
-int X509_EXTENSION_set_critical(ex,crit)
-X509_EXTENSION *ex;
-int crit;
+int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit)
{
if (ex == NULL) return(0);
ex->critical=(crit)?0xFF:0;
return(1);
}
-int X509_EXTENSION_set_data(ex,data)
-X509_EXTENSION *ex;
-ASN1_OCTET_STRING *data;
+int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data)
{
int i;
return(1);
}
-ASN1_OBJECT *X509_EXTENSION_get_object(ex)
-X509_EXTENSION *ex;
+ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex)
{
if (ex == NULL) return(NULL);
return(ex->object);
}
-ASN1_OCTET_STRING *X509_EXTENSION_get_data(ex)
-X509_EXTENSION *ex;
+ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ex)
{
if (ex == NULL) return(NULL);
return(ex->value);
}
-int X509_EXTENSION_get_critical(ex)
-X509_EXTENSION *ex;
+int X509_EXTENSION_get_critical(X509_EXTENSION *ex)
{
if (ex == NULL) return(0);
return(ex->critical);
static STACK *x509_store_method=NULL;
#endif
-static int null_callback(ok,e)
-int ok;
-X509_STORE_CTX *e;
+static int null_callback(int ok, X509_STORE_CTX *e)
{
return(ok);
}
#if 0
-static int x509_subject_cmp(a,b)
-X509 **a,**b;
+static int x509_subject_cmp(X509 **a, X509 **b)
{
return(X509_subject_name_cmp(*a,*b));
}
#endif
-int X509_verify_cert(ctx)
-X509_STORE_CTX *ctx;
+int X509_verify_cert(X509_STORE_CTX *ctx)
{
X509 *x,*xtmp,*chain_ss=NULL;
X509_NAME *xn;
return(ok);
}
-static int internal_verify(ctx)
-X509_STORE_CTX *ctx;
+static int internal_verify(X509_STORE_CTX *ctx)
{
int i,ok=0,n;
X509 *xs,*xi;
return(ok);
}
-int X509_cmp_current_time(ctm)
-ASN1_UTCTIME *ctm;
+int X509_cmp_current_time(ASN1_UTCTIME *ctm)
{
char *str;
ASN1_UTCTIME atm;
return(i);
}
-ASN1_UTCTIME *X509_gmtime_adj(s, adj)
-ASN1_UTCTIME *s;
-long adj;
+ASN1_UTCTIME *X509_gmtime_adj(ASN1_UTCTIME *s, long adj)
{
time_t t;
return(ASN1_UTCTIME_set(s,t));
}
-int X509_get_pubkey_parameters(pkey,chain)
-EVP_PKEY *pkey;
-STACK *chain;
+int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK *chain)
{
EVP_PKEY *ktmp=NULL,*ktmp2;
int i,j;
return(1);
}
-int X509_STORE_add_cert(ctx,x)
-X509_STORE *ctx;
-X509 *x;
+int X509_STORE_add_cert(X509_STORE *ctx, X509 *x)
{
X509_OBJECT *obj,*r;
int ret=1;
return(ret);
}
-int X509_STORE_add_crl(ctx,x)
-X509_STORE *ctx;
-X509_CRL *x;
+int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x)
{
X509_OBJECT *obj,*r;
int ret=1;
return(ret);
}
-int X509_STORE_CTX_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
+int X509_STORE_CTX_get_ex_new_index(long argl, char *argp, int (*new_func)(),
+ int (*dup_func)(), void (*free_func)())
{
x509_store_ctx_num++;
return(CRYPTO_get_ex_new_index(x509_store_ctx_num-1,
argl,argp,new_func,dup_func,free_func));
}
-int X509_STORE_CTX_set_ex_data(ctx,idx,data)
-X509_STORE_CTX *ctx;
-int idx;
-void *data;
+int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
{
return(CRYPTO_set_ex_data(&ctx->ex_data,idx,data));
}
-void *X509_STORE_CTX_get_ex_data(ctx,idx)
-X509_STORE_CTX *ctx;
-int idx;
+void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
{
return(CRYPTO_get_ex_data(&ctx->ex_data,idx));
}
-int X509_STORE_CTX_get_error(ctx)
-X509_STORE_CTX *ctx;
+int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
{
return(ctx->error);
}
-void X509_STORE_CTX_set_error(ctx,err)
-X509_STORE_CTX *ctx;
-int err;
+void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
{
ctx->error=err;
}
-int X509_STORE_CTX_get_error_depth(ctx)
-X509_STORE_CTX *ctx;
+int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
{
return(ctx->error_depth);
}
-X509 *X509_STORE_CTX_get_current_cert(ctx)
-X509_STORE_CTX *ctx;
+X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
{
return(ctx->current_cert);
}
-STACK *X509_STORE_CTX_get_chain(ctx)
-X509_STORE_CTX *ctx;
+STACK *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
{
return(ctx->chain);
}
-void X509_STORE_CTX_set_cert(ctx,x)
-X509_STORE_CTX *ctx;
-X509 *x;
+void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
{
ctx->cert=x;
}
-void X509_STORE_CTX_set_chain(ctx,sk)
-X509_STORE_CTX *ctx;
-STACK_OF(X509) *sk;
+void X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
{
ctx->untrusted=sk;
}
#include "evp.h"
#include "x509.h"
-int X509_NAME_get_text_by_NID(name,nid,buf,len)
-X509_NAME *name;
-int nid;
-char *buf;
-int len;
+int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len)
{
ASN1_OBJECT *obj;
return(X509_NAME_get_text_by_OBJ(name,obj,buf,len));
}
-int X509_NAME_get_text_by_OBJ(name,obj,buf,len)
-X509_NAME *name;
-ASN1_OBJECT *obj;
-char *buf;
-int len;
+int X509_NAME_get_text_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, char *buf,
+ int len)
{
int i;
ASN1_STRING *data;
return(i);
}
-int X509_NAME_entry_count(name)
-X509_NAME *name;
+int X509_NAME_entry_count(X509_NAME *name)
{
if (name == NULL) return(0);
return(sk_num(name->entries));
}
-int X509_NAME_get_index_by_NID(name,nid,lastpos)
-X509_NAME *name;
-int nid;
-int lastpos;
+int X509_NAME_get_index_by_NID(X509_NAME *name, int nid, int lastpos)
{
ASN1_OBJECT *obj;
}
/* NOTE: you should be passsing -1, not 0 as lastpos */
-int X509_NAME_get_index_by_OBJ(name,obj,lastpos)
-X509_NAME *name;
-ASN1_OBJECT *obj;
-int lastpos;
+int X509_NAME_get_index_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj,
+ int lastpos)
{
int n;
X509_NAME_ENTRY *ne;
return(-1);
}
-X509_NAME_ENTRY *X509_NAME_get_entry(name,loc)
-X509_NAME *name;
-int loc;
+X509_NAME_ENTRY *X509_NAME_get_entry(X509_NAME *name, int loc)
{
if ( (name == NULL) || (sk_num(name->entries) <= loc) || (loc < 0))
return(NULL);
return((X509_NAME_ENTRY *)sk_value(name->entries,loc));
}
-X509_NAME_ENTRY *X509_NAME_delete_entry(name,loc)
-X509_NAME *name;
-int loc;
+X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc)
{
X509_NAME_ENTRY *ret;
int i,n,set_prev,set_next;
/* if set is -1, append to previous set, 0 'a new one', and 1,
* prepend to the guy we are about to stomp on. */
-int X509_NAME_add_entry(name,ne,loc,set)
-X509_NAME *name;
-X509_NAME_ENTRY *ne;
-int loc;
-int set;
+int X509_NAME_add_entry(X509_NAME *name, X509_NAME_ENTRY *ne, int loc,
+ int set)
{
X509_NAME_ENTRY *new_name=NULL;
int n,i,inc;
return(0);
}
-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(ne,nid,type,bytes,len)
-X509_NAME_ENTRY **ne;
-int nid;
-int type;
-unsigned char *bytes;
-int len;
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
+ int type, unsigned char *bytes, int len)
{
ASN1_OBJECT *obj;
return(X509_NAME_ENTRY_create_by_OBJ(ne,obj,type,bytes,len));
}
-X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(ne,obj,type,bytes,len)
-X509_NAME_ENTRY **ne;
-ASN1_OBJECT *obj;
-int type;
-unsigned char *bytes;
-int len;
+X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
+ ASN1_OBJECT *obj, int type, unsigned char *bytes, int len)
{
X509_NAME_ENTRY *ret;
return(NULL);
}
-int X509_NAME_ENTRY_set_object(ne,obj)
-X509_NAME_ENTRY *ne;
-ASN1_OBJECT *obj;
+int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, ASN1_OBJECT *obj)
{
if ((ne == NULL) || (obj == NULL))
{
return((ne->object == NULL)?0:1);
}
-int X509_NAME_ENTRY_set_data(ne,type,bytes,len)
-X509_NAME_ENTRY *ne;
-int type;
-unsigned char *bytes;
-int len;
+int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
+ unsigned char *bytes, int len)
{
int i;
return(1);
}
-ASN1_OBJECT *X509_NAME_ENTRY_get_object(ne)
-X509_NAME_ENTRY *ne;
+ASN1_OBJECT *X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *ne)
{
if (ne == NULL) return(NULL);
return(ne->object);
}
-ASN1_STRING *X509_NAME_ENTRY_get_data(ne)
-X509_NAME_ENTRY *ne;
+ASN1_STRING *X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *ne)
{
if (ne == NULL) return(NULL);
return(ne->value);
#include "evp.h"
#include "x509.h"
-int X509_REQ_set_version(x,version)
-X509_REQ *x;
-long version;
+int X509_REQ_set_version(X509_REQ *x, long version)
{
if (x == NULL) return(0);
return(ASN1_INTEGER_set(x->req_info->version,version));
}
-int X509_REQ_set_subject_name(x,name)
-X509_REQ *x;
-X509_NAME *name;
+int X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name)
{
if ((x == NULL) || (x->req_info == NULL)) return(0);
return(X509_NAME_set(&x->req_info->subject,name));
}
-int X509_REQ_set_pubkey(x,pkey)
-X509_REQ *x;
-EVP_PKEY *pkey;
+int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey)
{
if ((x == NULL) || (x->req_info == NULL)) return(0);
return(X509_PUBKEY_set(&x->req_info->pubkey,pkey));
#include "objects.h"
#include "x509.h"
-int X509_certificate_type(x,pkey)
-X509 *x;
-EVP_PKEY *pkey;
+int X509_certificate_type(X509 *x, EVP_PKEY *pkey)
{
EVP_PKEY *pk;
int ret=0,i;
#include "evp.h"
#include "x509.h"
-int X509_verify(a,r)
-X509 *a;
-EVP_PKEY *r;
+int X509_verify(X509 *a, EVP_PKEY *r)
{
return(ASN1_verify((int (*)())i2d_X509_CINF,a->sig_alg,
a->signature,(char *)a->cert_info,r));
}
-int X509_REQ_verify(a,r)
-X509_REQ *a;
-EVP_PKEY *r;
+int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
{
return( ASN1_verify((int (*)())i2d_X509_REQ_INFO,
a->sig_alg,a->signature,(char *)a->req_info,r));
}
-int X509_CRL_verify(a,r)
-X509_CRL *a;
-EVP_PKEY *r;
+int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r)
{
return(ASN1_verify((int (*)())i2d_X509_CRL_INFO,
a->sig_alg, a->signature,(char *)a->crl,r));
}
-int NETSCAPE_SPKI_verify(a,r)
-NETSCAPE_SPKI *a;
-EVP_PKEY *r;
+int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
{
return(ASN1_verify((int (*)())i2d_NETSCAPE_SPKAC,
a->sig_algor,a->signature, (char *)a->spkac,r));
}
-int X509_sign(x,pkey,md)
-X509 *x;
-EVP_PKEY *pkey;
-const EVP_MD *md;
+int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
{
return(ASN1_sign((int (*)())i2d_X509_CINF, x->cert_info->signature,
x->sig_alg, x->signature, (char *)x->cert_info,pkey,md));
}
-int X509_REQ_sign(x,pkey,md)
-X509_REQ *x;
-EVP_PKEY *pkey;
-const EVP_MD *md;
+int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
{
return(ASN1_sign((int (*)())i2d_X509_REQ_INFO,x->sig_alg, NULL,
x->signature, (char *)x->req_info,pkey,md));
}
-int X509_CRL_sign(x,pkey,md)
-X509_CRL *x;
-EVP_PKEY *pkey;
-const EVP_MD *md;
+int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
{
return(ASN1_sign((int (*)())i2d_X509_CRL_INFO,x->crl->sig_alg,
x->sig_alg, x->signature, (char *)x->crl,pkey,md));
}
-int NETSCAPE_SPKI_sign(x,pkey,md)
-NETSCAPE_SPKI *x;
-EVP_PKEY *pkey;
-const EVP_MD *md;
+int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
{
return(ASN1_sign((int (*)())i2d_NETSCAPE_SPKAC, x->sig_algor,NULL,
x->signature, (char *)x->spkac,pkey,md));
}
-X509_ATTRIBUTE *X509_ATTRIBUTE_dup(xa)
-X509_ATTRIBUTE *xa;
+X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa)
{
return((X509_ATTRIBUTE *)ASN1_dup((int (*)())i2d_X509_ATTRIBUTE,
(char *(*)())d2i_X509_ATTRIBUTE,(char *)xa));
}
-X509 *X509_dup(x509)
-X509 *x509;
+X509 *X509_dup(X509 *x509)
{
return((X509 *)ASN1_dup((int (*)())i2d_X509,
(char *(*)())d2i_X509,(char *)x509));
}
-X509_EXTENSION *X509_EXTENSION_dup(ex)
-X509_EXTENSION *ex;
+X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex)
{
return((X509_EXTENSION *)ASN1_dup(
(int (*)())i2d_X509_EXTENSION,
}
#ifndef NO_FP_API
-X509 *d2i_X509_fp(fp,x509)
-FILE *fp;
-X509 *x509;
+X509 *d2i_X509_fp(FILE *fp, X509 *x509)
{
return((X509 *)ASN1_d2i_fp((char *(*)())X509_new,
(char *(*)())d2i_X509, (fp),(unsigned char **)(x509)));
}
-int i2d_X509_fp(fp,x509)
-FILE *fp;
-X509 *x509;
+int i2d_X509_fp(FILE *fp, X509 *x509)
{
return(ASN1_i2d_fp(i2d_X509,fp,(unsigned char *)x509));
}
#endif
-X509 *d2i_X509_bio(bp,x509)
-BIO *bp;
-X509 *x509;
+X509 *d2i_X509_bio(BIO *bp, X509 *x509)
{
return((X509 *)ASN1_d2i_bio((char *(*)())X509_new,
(char *(*)())d2i_X509, (bp),(unsigned char **)(x509)));
}
-int i2d_X509_bio(bp,x509)
-BIO *bp;
-X509 *x509;
+int i2d_X509_bio(BIO *bp, X509 *x509)
{
return(ASN1_i2d_bio(i2d_X509,bp,(unsigned char *)x509));
}
-X509_CRL *X509_CRL_dup(crl)
-X509_CRL *crl;
+X509_CRL *X509_CRL_dup(X509_CRL *crl)
{
return((X509_CRL *)ASN1_dup((int (*)())i2d_X509_CRL,
(char *(*)())d2i_X509_CRL,(char *)crl));
}
#ifndef NO_FP_API
-X509_CRL *d2i_X509_CRL_fp(fp,crl)
-FILE *fp;
-X509_CRL *crl;
+X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL *crl)
{
return((X509_CRL *)ASN1_d2i_fp((char *(*)())
X509_CRL_new,(char *(*)())d2i_X509_CRL, (fp),
(unsigned char **)(crl)));
}
-int i2d_X509_CRL_fp(fp,crl)
-FILE *fp;
-X509_CRL *crl;
+int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
{
return(ASN1_i2d_fp(i2d_X509_CRL,fp,(unsigned char *)crl));
}
#endif
-X509_CRL *d2i_X509_CRL_bio(bp,crl)
-BIO *bp;
-X509_CRL *crl;
+X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL *crl)
{
return((X509_CRL *)ASN1_d2i_bio((char *(*)())
X509_CRL_new,(char *(*)())d2i_X509_CRL, (bp),
(unsigned char **)(crl)));
}
-int i2d_X509_CRL_bio(bp,crl)
-BIO *bp;
-X509_CRL *crl;
+int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
{
return(ASN1_i2d_bio(i2d_X509_CRL,bp,(unsigned char *)crl));
}
-PKCS7 *PKCS7_dup(p7)
-PKCS7 *p7;
+PKCS7 *PKCS7_dup(PKCS7 *p7)
{
return((PKCS7 *)ASN1_dup((int (*)())i2d_PKCS7,
(char *(*)())d2i_PKCS7,(char *)p7));
}
#ifndef NO_FP_API
-PKCS7 *d2i_PKCS7_fp(fp,p7)
-FILE *fp;
-PKCS7 *p7;
+PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 *p7)
{
return((PKCS7 *)ASN1_d2i_fp((char *(*)())
PKCS7_new,(char *(*)())d2i_PKCS7, (fp),
(unsigned char **)(p7)));
}
-int i2d_PKCS7_fp(fp,p7)
-FILE *fp;
-PKCS7 *p7;
+int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
{
return(ASN1_i2d_fp(i2d_PKCS7,fp,(unsigned char *)p7));
}
#endif
-PKCS7 *d2i_PKCS7_bio(bp,p7)
-BIO *bp;
-PKCS7 *p7;
+PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 *p7)
{
return((PKCS7 *)ASN1_d2i_bio((char *(*)())
PKCS7_new,(char *(*)())d2i_PKCS7, (bp),
(unsigned char **)(p7)));
}
-int i2d_PKCS7_bio(bp,p7)
-BIO *bp;
-PKCS7 *p7;
+int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
{
return(ASN1_i2d_bio(i2d_PKCS7,bp,(unsigned char *)p7));
}
-X509_REQ *X509_REQ_dup(req)
-X509_REQ *req;
+X509_REQ *X509_REQ_dup(X509_REQ *req)
{
return((X509_REQ *)ASN1_dup((int (*)())i2d_X509_REQ,
(char *(*)())d2i_X509_REQ,(char *)req));
}
#ifndef NO_FP_API
-X509_REQ *d2i_X509_REQ_fp(fp,req)
-FILE *fp;
-X509_REQ *req;
+X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ *req)
{
return((X509_REQ *)ASN1_d2i_fp((char *(*)())
X509_REQ_new, (char *(*)())d2i_X509_REQ, (fp),
(unsigned char **)(req)));
}
-int i2d_X509_REQ_fp(fp,req)
-FILE *fp;
-X509_REQ *req;
+int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
{
return(ASN1_i2d_fp(i2d_X509_REQ,fp,(unsigned char *)req));
}
#endif
-X509_REQ *d2i_X509_REQ_bio(bp,req)
-BIO *bp;
-X509_REQ *req;
+X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ *req)
{
return((X509_REQ *)ASN1_d2i_bio((char *(*)())
X509_REQ_new, (char *(*)())d2i_X509_REQ, (bp),
(unsigned char **)(req)));
}
-int i2d_X509_REQ_bio(bp,req)
-BIO *bp;
-X509_REQ *req;
+int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
{
return(ASN1_i2d_bio(i2d_X509_REQ,bp,(unsigned char *)req));
}
#ifndef NO_RSA
-RSA *RSAPublicKey_dup(rsa)
-RSA *rsa;
+RSA *RSAPublicKey_dup(RSA *rsa)
{
return((RSA *)ASN1_dup((int (*)())i2d_RSAPublicKey,
(char *(*)())d2i_RSAPublicKey,(char *)rsa));
}
-RSA *RSAPrivateKey_dup(rsa)
-RSA *rsa;
+RSA *RSAPrivateKey_dup(RSA *rsa)
{
return((RSA *)ASN1_dup((int (*)())i2d_RSAPrivateKey,
(char *(*)())d2i_RSAPrivateKey,(char *)rsa));
}
#ifndef NO_FP_API
-RSA *d2i_RSAPrivateKey_fp(fp,rsa)
-FILE *fp;
-RSA *rsa;
+RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
{
return((RSA *)ASN1_d2i_fp((char *(*)())
RSA_new,(char *(*)())d2i_RSAPrivateKey, (fp),
(unsigned char **)(rsa)));
}
-int i2d_RSAPrivateKey_fp(fp,rsa)
-FILE *fp;
-RSA *rsa;
+int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
{
return(ASN1_i2d_fp(i2d_RSAPrivateKey,fp,(unsigned char *)rsa));
}
-RSA *d2i_RSAPublicKey_fp(fp,rsa)
-FILE *fp;
-RSA *rsa;
+RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA *rsa)
{
return((RSA *)ASN1_d2i_fp((char *(*)())
RSA_new,(char *(*)())d2i_RSAPublicKey, (fp),
(unsigned char **)(rsa)));
}
-int i2d_RSAPublicKey_fp(fp,rsa)
-FILE *fp;
-RSA *rsa;
+int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
{
return(ASN1_i2d_fp(i2d_RSAPublicKey,fp,(unsigned char *)rsa));
}
#endif
-RSA *d2i_RSAPrivateKey_bio(bp,rsa)
-BIO *bp;
-RSA *rsa;
+RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
{
return((RSA *)ASN1_d2i_bio((char *(*)())
RSA_new,(char *(*)())d2i_RSAPrivateKey, (bp),
(unsigned char **)(rsa)));
}
-int i2d_RSAPrivateKey_bio(bp,rsa)
-BIO *bp;
-RSA *rsa;
+int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
{
return(ASN1_i2d_bio(i2d_RSAPrivateKey,bp,(unsigned char *)rsa));
}
-RSA *d2i_RSAPublicKey_bio(bp,rsa)
-BIO *bp;
-RSA *rsa;
+RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA *rsa)
{
return((RSA *)ASN1_d2i_bio((char *(*)())
RSA_new,(char *(*)())d2i_RSAPublicKey, (bp),
(unsigned char **)(rsa)));
}
-int i2d_RSAPublicKey_bio(bp,rsa)
-BIO *bp;
-RSA *rsa;
+int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
{
return(ASN1_i2d_bio(i2d_RSAPublicKey,bp,(unsigned char *)rsa));
}
#ifndef NO_DSA
#ifndef NO_FP_API
-DSA *d2i_DSAPrivateKey_fp(fp,dsa)
-FILE *fp;
-DSA *dsa;
+DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
{
return((DSA *)ASN1_d2i_fp((char *(*)())
DSA_new,(char *(*)())d2i_DSAPrivateKey, (fp),
(unsigned char **)(dsa)));
}
-int i2d_DSAPrivateKey_fp(fp,dsa)
-FILE *fp;
-DSA *dsa;
+int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
{
return(ASN1_i2d_fp(i2d_DSAPrivateKey,fp,(unsigned char *)dsa));
}
#endif
-DSA *d2i_DSAPrivateKey_bio(bp,dsa)
-BIO *bp;
-DSA *dsa;
+DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
{
return((DSA *)ASN1_d2i_bio((char *(*)())
DSA_new,(char *(*)())d2i_DSAPrivateKey, (bp),
(unsigned char **)(dsa)));
}
-int i2d_DSAPrivateKey_bio(bp,dsa)
-BIO *bp;
-DSA *dsa;
+int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
{
return(ASN1_i2d_bio(i2d_DSAPrivateKey,bp,(unsigned char *)dsa));
}
#endif
-X509_ALGOR *X509_ALGOR_dup(xn)
-X509_ALGOR *xn;
+X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn)
{
return((X509_ALGOR *)ASN1_dup((int (*)())i2d_X509_ALGOR,
(char *(*)())d2i_X509_ALGOR,(char *)xn));
}
-X509_NAME *X509_NAME_dup(xn)
-X509_NAME *xn;
+X509_NAME *X509_NAME_dup(X509_NAME *xn)
{
return((X509_NAME *)ASN1_dup((int (*)())i2d_X509_NAME,
(char *(*)())d2i_X509_NAME,(char *)xn));
}
-X509_NAME_ENTRY *X509_NAME_ENTRY_dup(ne)
-X509_NAME_ENTRY *ne;
+X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne)
{
return((X509_NAME_ENTRY *)ASN1_dup((int (*)())i2d_X509_NAME_ENTRY,
(char *(*)())d2i_X509_NAME_ENTRY,(char *)ne));
}
-int X509_digest(data,type,md,len)
-X509 *data;
-EVP_MD *type;
-unsigned char *md;
-unsigned int *len;
+int X509_digest(X509 *data, EVP_MD *type, unsigned char *md,
+ unsigned int *len)
{
return(ASN1_digest((int (*)())i2d_X509,type,(char *)data,md,len));
}
-int X509_NAME_digest(data,type,md,len)
-X509_NAME *data;
-EVP_MD *type;
-unsigned char *md;
-unsigned int *len;
+int X509_NAME_digest(X509_NAME *data, EVP_MD *type, unsigned char *md,
+ unsigned int *len)
{
return(ASN1_digest((int (*)())i2d_X509_NAME,type,(char *)data,md,len));
}
-int PKCS7_ISSUER_AND_SERIAL_digest(data,type,md,len)
-PKCS7_ISSUER_AND_SERIAL *data;
-EVP_MD *type;
-unsigned char *md;
-unsigned int *len;
+int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, EVP_MD *type,
+ unsigned char *md, unsigned int *len)
{
return(ASN1_digest((int (*)())i2d_PKCS7_ISSUER_AND_SERIAL,type,
(char *)data,md,len));
* ASN1err(ASN1_F_D2I_AUTHORITY_KEYID,ERR_R_MALLOC_FAILURE);
*/
-int i2d_AUTHORITY_KEYID(a,pp)
-AUTHORITY_KEYID *a;
-unsigned char **pp;
+int i2d_AUTHORITY_KEYID(AUTHORITY_KEYID *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-AUTHORITY_KEYID *AUTHORITY_KEYID_new()
+AUTHORITY_KEYID *AUTHORITY_KEYID_new(void)
{
AUTHORITY_KEYID *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_AUTHORITY_KEYID_NEW);
}
-AUTHORITY_KEYID *d2i_AUTHORITY_KEYID(a,pp,length)
-AUTHORITY_KEYID **a;
-unsigned char **pp;
-long length;
+AUTHORITY_KEYID *d2i_AUTHORITY_KEYID(AUTHORITY_KEYID **a, unsigned char **pp,
+ long length)
{
M_ASN1_D2I_vars(a,AUTHORITY_KEYID *,AUTHORITY_KEYID_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, AUTHORITY_KEYID_free, ASN1_F_D2I_AUTHORITY_KEYID);
}
-void AUTHORITY_KEYID_free(a)
-AUTHORITY_KEYID *a;
+void AUTHORITY_KEYID_free(AUTHORITY_KEYID *a)
{
if (a == NULL) return;
ASN1_OCTET_STRING_free(a->keyid);
Free ((char *)a);
}
-static STACK *i2v_AUTHORITY_KEYID(method, akeyid, extlist)
-X509V3_EXT_METHOD *method;
-AUTHORITY_KEYID *akeyid;
-STACK *extlist;
+static STACK *i2v_AUTHORITY_KEYID(X509V3_EXT_METHOD *method,
+ AUTHORITY_KEYID *akeyid, STACK *extlist)
{
char *tmp;
if(akeyid->keyid) {
* this is always included.
*/
-static AUTHORITY_KEYID *v2i_AUTHORITY_KEYID(method, ctx, values)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *values;
+static AUTHORITY_KEYID *v2i_AUTHORITY_KEYID(X509V3_EXT_METHOD *method,
+ X509V3_CTX *ctx, STACK *values)
{
char keyid=0, issuer=0;
int i;
EXT_END
};
-STACK *i2v_GENERAL_NAMES(method, gens, ret)
-X509V3_EXT_METHOD *method;
-STACK *gens;
-STACK *ret;
+STACK *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method, STACK *gens, STACK *ret)
{
int i;
GENERAL_NAME *gen;
return ret;
}
-STACK *i2v_GENERAL_NAME(method, gen, ret)
-X509V3_EXT_METHOD *method;
-GENERAL_NAME *gen;
-STACK *ret;
+STACK *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen,
+ STACK *ret)
{
char oline[256];
unsigned char *p;
return ret;
}
-static STACK *v2i_issuer_alt(method, ctx, nval)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *nval;
+static STACK *v2i_issuer_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
+ STACK *nval)
{
STACK *gens = NULL;
CONF_VALUE *cnf;
/* Append subject altname of issuer to issuer alt name of subject */
-static int copy_issuer(ctx, gens)
-X509V3_CTX *ctx;
-STACK *gens;
+static int copy_issuer(X509V3_CTX *ctx, STACK *gens)
{
STACK *ialt;
char *gen;
}
-static STACK *v2i_subject_alt(method, ctx, nval)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *nval;
+static STACK *v2i_subject_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
+ STACK *nval)
{
STACK *gens = NULL;
CONF_VALUE *cnf;
* GENERAL_NAMES
*/
-static int copy_email(ctx, gens)
-X509V3_CTX *ctx;
-STACK *gens;
+static int copy_email(X509V3_CTX *ctx, STACK *gens)
{
X509_NAME *nm;
ASN1_IA5STRING *email = NULL;
}
-STACK *v2i_GENERAL_NAMES(method, ctx, nval)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *nval;
+STACK *v2i_GENERAL_NAMES(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
+ STACK *nval)
{
GENERAL_NAME *gen;
STACK *gens = NULL;
return NULL;
}
-GENERAL_NAME *v2i_GENERAL_NAME(method, ctx, cnf)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-CONF_VALUE *cnf;
+GENERAL_NAME *v2i_GENERAL_NAME(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
+ CONF_VALUE *cnf)
{
char is_string = 0;
int type;
* ASN1err(ASN1_F_D2I_BASIC_CONSTRAINTS,ERR_R_MALLOC_FAILURE);
*/
-int i2d_BASIC_CONSTRAINTS(a,pp)
-BASIC_CONSTRAINTS *a;
-unsigned char **pp;
+int i2d_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
if(a->ca) M_ASN1_I2D_len (a->ca, i2d_ASN1_BOOLEAN);
M_ASN1_I2D_finish();
}
-BASIC_CONSTRAINTS *BASIC_CONSTRAINTS_new()
+BASIC_CONSTRAINTS *BASIC_CONSTRAINTS_new(void)
{
BASIC_CONSTRAINTS *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_BASIC_CONSTRAINTS_NEW);
}
-BASIC_CONSTRAINTS *d2i_BASIC_CONSTRAINTS(a,pp,length)
-BASIC_CONSTRAINTS **a;
-unsigned char **pp;
-long length;
+BASIC_CONSTRAINTS *d2i_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS **a,
+ unsigned char **pp, long length)
{
M_ASN1_D2I_vars(a,BASIC_CONSTRAINTS *,BASIC_CONSTRAINTS_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, BASIC_CONSTRAINTS_free, ASN1_F_D2I_BASIC_CONSTRAINTS);
}
-void BASIC_CONSTRAINTS_free(a)
-BASIC_CONSTRAINTS *a;
+void BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS *a)
{
if (a == NULL) return;
ASN1_INTEGER_free (a->pathlen);
Free ((char *)a);
}
-static STACK *i2v_BASIC_CONSTRAINTS(method, bcons, extlist)
-X509V3_EXT_METHOD *method;
-BASIC_CONSTRAINTS *bcons;
-STACK *extlist;
+static STACK *i2v_BASIC_CONSTRAINTS(X509V3_EXT_METHOD *method,
+ BASIC_CONSTRAINTS *bcons, STACK *extlist)
{
X509V3_add_value_bool("CA", bcons->ca, &extlist);
X509V3_add_value_int("pathlen", bcons->pathlen, &extlist);
return extlist;
}
-static BASIC_CONSTRAINTS *v2i_BASIC_CONSTRAINTS(method, ctx, values)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *values;
+static BASIC_CONSTRAINTS *v2i_BASIC_CONSTRAINTS(X509V3_EXT_METHOD *method,
+ X509V3_CTX *ctx, STACK *values)
{
BASIC_CONSTRAINTS *bcons=NULL;
CONF_VALUE *val;
X509V3_EXT_METHOD v3_nscert = EXT_BITSTRING(NID_netscape_cert_type, ns_cert_type_table);
X509V3_EXT_METHOD v3_key_usage = EXT_BITSTRING(NID_key_usage, key_usage_type_table);
-static ASN1_BIT_STRING *asn1_bit_string_new()
+static ASN1_BIT_STRING *asn1_bit_string_new(void)
{
return ASN1_BIT_STRING_new();
}
-static STACK *i2v_ASN1_BIT_STRING(method, bits, ret)
-X509V3_EXT_METHOD *method;
-ASN1_BIT_STRING *bits;
-STACK *ret;
+static STACK *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
+ ASN1_BIT_STRING *bits, STACK *ret)
{
BIT_STRING_BITNAME *bnam;
for(bnam =(BIT_STRING_BITNAME *)method->usr_data; bnam->lname; bnam++) {
return ret;
}
-static ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(method, ctx, nval)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *nval;
+static ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
+ X509V3_CTX *ctx, STACK *nval)
{
CONF_VALUE *val;
ASN1_BIT_STRING *bs;
static X509V3_EXTENSION *v3_generic_extension();
#endif
-X509_EXTENSION *X509V3_EXT_conf(conf, ctx, name, value)
-LHASH *conf; /* Config file */
-X509V3_CTX *ctx;
-char *name; /* Name */
-char *value; /* Value */
+/* LHASH *conf: Config file */
+/* char *name: Name */
+/* char *value: Value */
+X509_EXTENSION *X509V3_EXT_conf(LHASH *conf, X509V3_CTX *ctx, char *name,
+ char *value)
{
int crit;
int ext_type;
return ret;
}
-X509_EXTENSION *X509V3_EXT_conf_nid(conf, ctx, ext_nid, value)
-LHASH *conf; /* Config file */
-X509V3_CTX *ctx;
-int ext_nid;
-char *value; /* Value */
+/* LHASH *conf: Config file */
+/* char *value: Value */
+X509_EXTENSION *X509V3_EXT_conf_nid(LHASH *conf, X509V3_CTX *ctx, int ext_nid,
+ char *value)
{
int crit;
int ext_type;
return do_ext_conf(conf, ctx, ext_nid, crit, value);
}
-static X509_EXTENSION *do_ext_conf(conf, ctx, ext_nid, crit, value)
-LHASH *conf; /* Config file */
-X509V3_CTX *ctx;
-int ext_nid;
-int crit;
-char *value; /* Value */
+/* LHASH *conf: Config file */
+/* char *value: Value */
+static X509_EXTENSION *do_ext_conf(LHASH *conf, X509V3_CTX *ctx, int ext_nid,
+ int crit, char *value)
{
X509_EXTENSION *ext = NULL;
X509V3_EXT_METHOD *method;
}
/* Check the extension string for critical flag */
-static int v3_check_critical(value)
-char **value;
+static int v3_check_critical(char **value)
{
char *p = *value;
if((strlen(p) < 9) || strncmp(p, "critical,", 9)) return 0;
}
/* Check extension string for generic extension and return the type */
-static int v3_check_generic(value)
-char **value;
+static int v3_check_generic(char **value)
{
char *p = *value;
if((strlen(p) < 4) || strncmp(p, "RAW:,", 4)) return 0;
}
/* Create a generic extension: for now just handle RAW type */
-static X509_EXTENSION *v3_generic_extension(ext, value, crit, type)
-const char *ext;
-char *value;
-int crit;
-int type;
+static X509_EXTENSION *v3_generic_extension(const char *ext, char *value,
+ int crit, int type)
{
unsigned char *ext_der=NULL;
long ext_len;
* section
*/
-int X509V3_EXT_add_conf(conf, ctx, section, cert)
-LHASH *conf;
-X509V3_CTX *ctx;
-char *section;
-X509 *cert;
+int X509V3_EXT_add_conf(LHASH *conf, X509V3_CTX *ctx, char *section,
+ X509 *cert)
{
X509_EXTENSION *ext;
STACK *nval;
/* Same as above but for a CRL */
-int X509V3_EXT_CRL_add_conf(conf, ctx, section, crl)
-LHASH *conf;
-X509V3_CTX *ctx;
-char *section;
-X509_CRL *crl;
+int X509V3_EXT_CRL_add_conf(LHASH *conf, X509V3_CTX *ctx, char *section,
+ X509_CRL *crl)
{
X509_EXTENSION *ext;
STACK *nval;
/* Config database functions */
-char * X509V3_get_string(ctx, name, section)
-X509V3_CTX *ctx;
-char *name;
-char *section;
+char * X509V3_get_string(X509V3_CTX *ctx, char *name, char *section)
{
if(ctx->db_meth->get_string)
return ctx->db_meth->get_string(ctx->db, name, section);
return NULL;
}
-STACK * X509V3_get_section(ctx, section)
-X509V3_CTX *ctx;
-char *section;
+STACK * X509V3_get_section(X509V3_CTX *ctx, char *section)
{
if(ctx->db_meth->get_section)
return ctx->db_meth->get_section(ctx->db, section);
return NULL;
}
-void X509V3_string_free(ctx, str)
-X509V3_CTX *ctx;
-char *str;
+void X509V3_string_free(X509V3_CTX *ctx, char *str)
{
if(!str) return;
if(ctx->db_meth->free_string)
return ctx->db_meth->free_string(ctx->db, str);
}
-void X509V3_section_free(ctx, section)
-X509V3_CTX *ctx;
-STACK *section;
+void X509V3_section_free(X509V3_CTX *ctx, STACK *section)
{
if(!section) return;
if(ctx->db_meth->free_section)
return ctx->db_meth->free_section(ctx->db, section);
}
-static char *conf_lhash_get_string(db, section, value)
-void *db;
-char *section;
-char *value;
+static char *conf_lhash_get_string(void *db, char *section, char *value)
{
return CONF_get_string(db, section, value);
}
-static STACK *conf_lhash_get_section(db, section)
-void *db;
-char *section;
+static STACK *conf_lhash_get_section(void *db, char *section)
{
return CONF_get_section(db, section);
}
NULL
};
-void X509V3_set_conf_lhash(ctx, lhash)
-X509V3_CTX *ctx;
-LHASH *lhash;
+void X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH *lhash)
{
ctx->db_meth = &conf_lhash_method;
ctx->db = lhash;
}
-void X509V3_set_ctx(ctx, issuer, subj, req, crl, flags)
-X509V3_CTX *ctx;
-X509 *issuer;
-X509 *subj;
-X509_REQ *req;
-X509_CRL *crl;
-int flags;
+void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req,
+ X509_CRL *crl, int flags)
{
ctx->issuer_cert = issuer;
ctx->subject_cert = subj;
* ASN1err(ASN1_F_D2I_NOTICEREF,ERR_R_MALLOC_FAILURE);
*/
-static STACK_OF(POLICYINFO) *r2i_certpol(method, ctx, value)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-char *value;
+static STACK_OF(POLICYINFO) *r2i_certpol(X509V3_EXT_METHOD *method,
+ X509V3_CTX *ctx, char *value)
{
STACK_OF(POLICYINFO) *pols = NULL;
char *pstr;
return NULL;
}
-static POLICYINFO *policy_section(ctx, polstrs)
-X509V3_CTX *ctx;
-STACK *polstrs;
+static POLICYINFO *policy_section(X509V3_CTX *ctx, STACK *polstrs)
{
int i;
CONF_VALUE *cnf;
}
-static POLICYQUALINFO *notice_section(ctx, unot)
-X509V3_CTX *ctx;
-STACK *unot;
+static POLICYQUALINFO *notice_section(X509V3_CTX *ctx, STACK *unot)
{
int i;
CONF_VALUE *cnf;
return NULL;
}
-static STACK *nref_nos(nos)
-STACK *nos;
+static STACK *nref_nos(STACK *nos)
{
STACK *nnums;
CONF_VALUE *cnf;
}
-static int i2r_certpol(method, pol, out, indent)
-X509V3_EXT_METHOD *method;
-STACK_OF(POLICYINFO) *pol;
-BIO *out;
-int indent;
+static int i2r_certpol(X509V3_EXT_METHOD *method, STACK_OF(POLICYINFO) *pol,
+ BIO *out, int indent)
{
int i;
POLICYINFO *pinfo;
}
-int i2d_CERTIFICATEPOLICIES(a, pp)
-STACK_OF(POLICYINFO) *a;
-unsigned char **pp;
+int i2d_CERTIFICATEPOLICIES(STACK_OF(POLICYINFO) *a, unsigned char **pp)
{
return i2d_ASN1_SET_OF_POLICYINFO(a, pp, i2d_POLICYINFO, V_ASN1_SEQUENCE,
V_ASN1_UNIVERSAL, IS_SEQUENCE);}
-STACK_OF(POLICYINFO) *CERTIFICATEPOLICIES_new()
+STACK_OF(POLICYINFO) *CERTIFICATEPOLICIES_new(void)
{
return sk_POLICYINFO_new_null();
}
-void CERTIFICATEPOLICIES_free(a)
-STACK_OF(POLICYINFO) *a;
+void CERTIFICATEPOLICIES_free(STACK_OF(POLICYINFO) *a)
{
sk_POLICYINFO_pop_free(a, POLICYINFO_free);
}
-STACK_OF(POLICYINFO) *d2i_CERTIFICATEPOLICIES(a,pp,length)
-STACK_OF(POLICYINFO) **a;
-unsigned char **pp;
-long length;
+STACK_OF(POLICYINFO) *d2i_CERTIFICATEPOLICIES(STACK_OF(POLICYINFO) **a,
+ unsigned char **pp,long length)
{
return d2i_ASN1_SET_OF_POLICYINFO(a, pp, length, d2i_POLICYINFO,
POLICYINFO_free, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);
IMPLEMENT_STACK_OF(POLICYINFO)
IMPLEMENT_ASN1_SET_OF(POLICYINFO)
-int i2d_POLICYINFO(a,pp)
-POLICYINFO *a;
-unsigned char **pp;
+int i2d_POLICYINFO(POLICYINFO *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-POLICYINFO *POLICYINFO_new()
+POLICYINFO *POLICYINFO_new(void)
{
POLICYINFO *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_POLICYINFO_NEW);
}
-POLICYINFO *d2i_POLICYINFO(a,pp,length)
-POLICYINFO **a;
-unsigned char **pp;
-long length;
+POLICYINFO *d2i_POLICYINFO(POLICYINFO **a, unsigned char **pp,long length)
{
M_ASN1_D2I_vars(a,POLICYINFO *,POLICYINFO_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, POLICYINFO_free, ASN1_F_D2I_POLICYINFO);
}
-void POLICYINFO_free(a)
-POLICYINFO *a;
+void POLICYINFO_free(POLICYINFO *a)
{
if (a == NULL) return;
ASN1_OBJECT_free(a->policyid);
Free (a);
}
-static void print_qualifiers(out, quals, indent)
-BIO *out;
-STACK_OF(POLICYQUALINFO) *quals;
-int indent;
+static void print_qualifiers(BIO *out, STACK_OF(POLICYQUALINFO) *quals,
+ int indent)
{
POLICYQUALINFO *qualinfo;
int i;
}
}
-static void print_notice(out, notice, indent)
-BIO *out;
-USERNOTICE *notice;
-int indent;
+static void print_notice(BIO *out, USERNOTICE *notice, int indent)
{
int i;
if(notice->noticeref) {
-int i2d_POLICYQUALINFO(a,pp)
-POLICYQUALINFO *a;
-unsigned char **pp;
+int i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-POLICYQUALINFO *POLICYQUALINFO_new()
+POLICYQUALINFO *POLICYQUALINFO_new(void)
{
POLICYQUALINFO *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_POLICYQUALINFO_NEW);
}
-POLICYQUALINFO *d2i_POLICYQUALINFO(a,pp,length)
-POLICYQUALINFO **a;
-unsigned char **pp;
-long length;
+POLICYQUALINFO *d2i_POLICYQUALINFO(POLICYQUALINFO **a, unsigned char **pp,
+ long length)
{
M_ASN1_D2I_vars(a,POLICYQUALINFO *,POLICYQUALINFO_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, POLICYQUALINFO_free, ASN1_F_D2I_POLICYQUALINFO);
}
-void POLICYQUALINFO_free(a)
-POLICYQUALINFO *a;
+void POLICYQUALINFO_free(POLICYQUALINFO *a)
{
if (a == NULL) return;
switch(OBJ_obj2nid(a->pqualid)) {
Free (a);
}
-int i2d_USERNOTICE(a,pp)
-USERNOTICE *a;
-unsigned char **pp;
+int i2d_USERNOTICE(USERNOTICE *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-USERNOTICE *USERNOTICE_new()
+USERNOTICE *USERNOTICE_new(void)
{
USERNOTICE *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_USERNOTICE_NEW);
}
-USERNOTICE *d2i_USERNOTICE(a,pp,length)
-USERNOTICE **a;
-unsigned char **pp;
-long length;
+USERNOTICE *d2i_USERNOTICE(USERNOTICE **a, unsigned char **pp,long length)
{
M_ASN1_D2I_vars(a,USERNOTICE *,USERNOTICE_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, USERNOTICE_free, ASN1_F_D2I_USERNOTICE);
}
-void USERNOTICE_free(a)
-USERNOTICE *a;
+void USERNOTICE_free(USERNOTICE *a)
{
if (a == NULL) return;
NOTICEREF_free(a->noticeref);
Free (a);
}
-int i2d_NOTICEREF(a,pp)
-NOTICEREF *a;
-unsigned char **pp;
+int i2d_NOTICEREF(NOTICEREF *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-NOTICEREF *NOTICEREF_new()
+NOTICEREF *NOTICEREF_new(void)
{
NOTICEREF *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_NOTICEREF_NEW);
}
-NOTICEREF *d2i_NOTICEREF(a,pp,length)
-NOTICEREF **a;
-unsigned char **pp;
-long length;
+NOTICEREF *d2i_NOTICEREF(NOTICEREF **a, unsigned char **pp,long length)
{
M_ASN1_D2I_vars(a,NOTICEREF *,NOTICEREF_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, NOTICEREF_free, ASN1_F_D2I_NOTICEREF);
}
-void NOTICEREF_free(a)
-NOTICEREF *a;
+void NOTICEREF_free(NOTICEREF *a)
{
if (a == NULL) return;
DISPLAYTEXT_free(a->organization);
NULL, NULL, NULL, NULL, (char *)crl_reasons};
-static ASN1_ENUMERATED *asn1_enumerated_new()
+static ASN1_ENUMERATED *asn1_enumerated_new(void)
{
return ASN1_ENUMERATED_new();
}
-char *i2s_ASN1_ENUMERATED_TABLE(method, e)
-X509V3_EXT_METHOD *method;
-ASN1_ENUMERATED *e;
+char *i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *method,
+ ASN1_ENUMERATED *e)
{
ENUMERATED_NAMES *enam;
long strval;
NULL
};
-STACK *ext_ku_new()
+STACK *ext_ku_new(void)
{
return sk_new_null();
}
-void ext_ku_free(eku)
-STACK *eku;
+void ext_ku_free(STACK *eku)
{
sk_pop_free(eku, ASN1_OBJECT_free);
return;
}
-int i2d_ext_ku(a,pp)
-STACK *a;
-unsigned char **pp;
+int i2d_ext_ku(STACK *a, unsigned char **pp)
{
return i2d_ASN1_SET(a, pp, i2d_ASN1_OBJECT, V_ASN1_SEQUENCE,
V_ASN1_UNIVERSAL, IS_SEQUENCE);
}
-STACK *d2i_ext_ku(a,pp,length)
-STACK **a;
-unsigned char **pp;
-long length;
+STACK *d2i_ext_ku(STACK **a, unsigned char **pp, long length)
{
return d2i_ASN1_SET(a, pp, length, (char *(*)())(d2i_ASN1_OBJECT),
ASN1_OBJECT_free, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);
-static STACK *i2v_ext_ku(method, eku, ext_list)
-X509V3_EXT_METHOD *method;
-STACK *eku;
-STACK *ext_list;
+static STACK *i2v_ext_ku(X509V3_EXT_METHOD *method, STACK *eku,
+ STACK *ext_list)
{
int i;
ASN1_OBJECT *obj;
return ext_list;
}
-static STACK *v2i_ext_ku(method, ctx, nval)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *nval;
+static STACK *v2i_ext_ku(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
+ STACK *nval)
{
STACK *extku;
char *extval;
* ASN1err(ASN1_F_D2I_GENERAL_NAME,ERR_R_MALLOC_FAILURE);
*/
-int i2d_GENERAL_NAME(a,pp)
-GENERAL_NAME *a;
-unsigned char **pp;
+int i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **pp)
{
unsigned char *p;
int ret;
return ret;
}
-GENERAL_NAME *GENERAL_NAME_new()
+GENERAL_NAME *GENERAL_NAME_new(void)
{
GENERAL_NAME *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_GENERAL_NAME_NEW);
}
-GENERAL_NAME *d2i_GENERAL_NAME(a,pp,length)
-GENERAL_NAME **a;
-unsigned char **pp;
-long length;
+GENERAL_NAME *d2i_GENERAL_NAME(GENERAL_NAME **a, unsigned char **pp,
+ long length)
{
unsigned char _tmp;
M_ASN1_D2I_vars(a,GENERAL_NAME *,GENERAL_NAME_new);
M_ASN1_D2I_Finish(a, GENERAL_NAME_free, ASN1_F_D2I_GENERAL_NAME);
}
-void GENERAL_NAME_free(a)
-GENERAL_NAME *a;
+void GENERAL_NAME_free(GENERAL_NAME *a)
{
if (a == NULL) return;
switch(a->type) {
* an explicit functions.
*/
-STACK *GENERAL_NAMES_new()
+STACK *GENERAL_NAMES_new(void)
{
return sk_new(NULL);
}
-void GENERAL_NAMES_free(a)
-STACK *a;
+void GENERAL_NAMES_free(STACK *a)
{
sk_pop_free(a, GENERAL_NAME_free);
}
-STACK *d2i_GENERAL_NAMES(a,pp,length)
-STACK **a;
-unsigned char **pp;
-long length;
+STACK *d2i_GENERAL_NAMES(STACK **a, unsigned char **pp, long length)
{
return d2i_ASN1_SET(a, pp, length, (char *(*)())d2i_GENERAL_NAME,
GENERAL_NAME_free, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL);
}
-int i2d_GENERAL_NAMES(a,pp)
-STACK *a;
-unsigned char **pp;
+int i2d_GENERAL_NAMES(STACK *a, unsigned char **pp)
{
return i2d_ASN1_SET(a, pp, i2d_GENERAL_NAME, V_ASN1_SEQUENCE,
V_ASN1_UNIVERSAL, IS_SEQUENCE);
return ASN1_IA5STRING_new();
}
-static char *i2s_ASN1_IA5STRING(method, ia5)
-X509V3_EXT_METHOD *method;
-ASN1_IA5STRING *ia5;
+static char *i2s_ASN1_IA5STRING(X509V3_EXT_METHOD *method,
+ ASN1_IA5STRING *ia5)
{
char *tmp;
if(!ia5 || !ia5->length) return NULL;
return tmp;
}
-static ASN1_IA5STRING *s2i_ASN1_IA5STRING(method, ctx, str)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-char *str;
+static ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method,
+ X509V3_CTX *ctx, char *str)
{
ASN1_IA5STRING *ia5;
if(!str) {
NULL, NULL, NULL, NULL, NULL};
-static ASN1_INTEGER *asn1_integer_new()
+static ASN1_INTEGER *asn1_integer_new(void)
{
return ASN1_INTEGER_new();
}
static int ext_cmp(X509V3_EXT_METHOD **a, X509V3_EXT_METHOD **b);
static void ext_list_free(X509V3_EXT_METHOD *ext);
-int X509V3_EXT_add(ext)
-X509V3_EXT_METHOD *ext;
+int X509V3_EXT_add(X509V3_EXT_METHOD *ext)
{
if(!ext_list && !(ext_list = sk_new(ext_cmp))) {
X509V3err(X509V3_F_X509V3_EXT_ADD,ERR_R_MALLOC_FAILURE);
return 1;
}
-static int ext_cmp(a, b)
-X509V3_EXT_METHOD **a, **b;
+static int ext_cmp(X509V3_EXT_METHOD **a, X509V3_EXT_METHOD **b)
{
return ((*a)->ext_nid - (*b)->ext_nid);
}
-X509V3_EXT_METHOD *X509V3_EXT_get_nid(nid)
-int nid;
+X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid)
{
X509V3_EXT_METHOD tmp;
int idx;
return (X509V3_EXT_METHOD *)sk_value(ext_list, idx);
}
-X509V3_EXT_METHOD *X509V3_EXT_get(ext)
-X509_EXTENSION *ext;
+X509V3_EXT_METHOD *X509V3_EXT_get(X509_EXTENSION *ext)
{
int nid;
if((nid = OBJ_obj2nid(ext->object)) == NID_undef) return NULL;
}
-int X509V3_EXT_add_list(extlist)
-X509V3_EXT_METHOD *extlist;
+int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist)
{
for(;extlist->ext_nid!=-1;extlist++)
if(!X509V3_EXT_add(extlist)) return 0;
return 1;
}
-int X509V3_EXT_add_alias(nid_to, nid_from)
-int nid_to, nid_from;
+int X509V3_EXT_add_alias(int nid_to, int nid_from)
{
X509V3_EXT_METHOD *ext, *tmpext;
if(!(ext = X509V3_EXT_get_nid(nid_from))) {
return 1;
}
-void X509V3_EXT_cleanup()
+void X509V3_EXT_cleanup(void)
{
sk_pop_free(ext_list, ext_list_free);
}
-static void ext_list_free(ext)
-X509V3_EXT_METHOD *ext;
+static void ext_list_free(X509V3_EXT_METHOD *ext)
{
if(ext->ext_flags & X509V3_EXT_DYNAMIC) Free(ext);
}
extern X509V3_EXT_METHOD v3_crl_num, v3_crl_reason, v3_cpols;
-int X509V3_add_standard_extensions()
+int X509V3_add_standard_extensions(void)
{
X509V3_EXT_add_list(v3_ns_ia5_list);
X509V3_EXT_add_list(v3_alt);
/* Return an extension internal structure */
-char *X509V3_EXT_d2i(ext)
-X509_EXTENSION *ext;
+char *X509V3_EXT_d2i(X509_EXTENSION *ext)
{
X509V3_EXT_METHOD *method;
unsigned char *p;
* ASN1err(ASN1_F_D2I_PKEY_USAGE_PERIOD,ERR_R_MALLOC_FAILURE);
*/
-int i2d_PKEY_USAGE_PERIOD(a,pp)
-PKEY_USAGE_PERIOD *a;
-unsigned char **pp;
+int i2d_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-PKEY_USAGE_PERIOD *PKEY_USAGE_PERIOD_new()
+PKEY_USAGE_PERIOD *PKEY_USAGE_PERIOD_new(void)
{
PKEY_USAGE_PERIOD *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_PKEY_USAGE_PERIOD_NEW);
}
-PKEY_USAGE_PERIOD *d2i_PKEY_USAGE_PERIOD(a,pp,length)
-PKEY_USAGE_PERIOD **a;
-unsigned char **pp;
-long length;
+PKEY_USAGE_PERIOD *d2i_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD **a,
+ unsigned char **pp, long length)
{
M_ASN1_D2I_vars(a,PKEY_USAGE_PERIOD *,PKEY_USAGE_PERIOD_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, PKEY_USAGE_PERIOD_free, ASN1_F_D2I_PKEY_USAGE_PERIOD);
}
-void PKEY_USAGE_PERIOD_free(a)
-PKEY_USAGE_PERIOD *a;
+void PKEY_USAGE_PERIOD_free(PKEY_USAGE_PERIOD *a)
{
if (a == NULL) return;
ASN1_GENERALIZEDTIME_free(a->notBefore);
Free ((char *)a);
}
-static int i2r_PKEY_USAGE_PERIOD(method, usage, out, indent)
-X509V3_EXT_METHOD *method;
-PKEY_USAGE_PERIOD *usage;
-BIO *out;
-int indent;
+static int i2r_PKEY_USAGE_PERIOD(X509V3_EXT_METHOD *method,
+ PKEY_USAGE_PERIOD *usage, BIO *out, int indent)
{
BIO_printf(out, "%*s", indent, "");
if(usage->notBefore) {
/* Print out a name+value stack */
-void X509V3_EXT_val_prn(out, val, indent, ml)
-BIO *out;
-STACK *val;
-int indent;
-int ml;
+void X509V3_EXT_val_prn(BIO *out, STACK *val, int indent, int ml)
{
int i;
CONF_VALUE *nval;
/* Main routine: print out a general extension */
-int X509V3_EXT_print(out, ext, flag, indent)
-BIO *out;
-X509_EXTENSION *ext;
-int flag;
-int indent;
+int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, int flag, int indent)
{
char *ext_str = NULL, *p, *value = NULL;
X509V3_EXT_METHOD *method;
return ok;
}
-int X509V3_EXT_print_fp(fp, ext, flag, indent)
-FILE *fp;
-X509_EXTENSION *ext;
-int flag;
-int indent;
+int X509V3_EXT_print_fp(FILE *fp, X509_EXTENSION *ext, int flag, int indent)
{
BIO *bio_tmp;
int ret;
return ASN1_OCTET_STRING_new();
}
-char *i2s_ASN1_OCTET_STRING(method, oct)
-X509V3_EXT_METHOD *method;
-ASN1_OCTET_STRING *oct;
+char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
+ ASN1_OCTET_STRING *oct)
{
return hex_to_string(oct->data, oct->length);
}
-ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(method, ctx, str)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-char *str;
+ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
+ X509V3_CTX *ctx, char *str)
{
ASN1_OCTET_STRING *oct;
long length;
}
-static ASN1_OCTET_STRING *s2i_skey_id(method, ctx, str)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-char *str;
+static ASN1_OCTET_STRING *s2i_skey_id(X509V3_EXT_METHOD *method,
+ X509V3_CTX *ctx, char *str)
{
ASN1_OCTET_STRING *oct;
ASN1_BIT_STRING *pk;
* ASN1err(ASN1_F_D2I_SXNETID,ERR_R_MALLOC_FAILURE);
*/
-int i2d_SXNET(a,pp)
-SXNET *a;
-unsigned char **pp;
+int i2d_SXNET(SXNET *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-SXNET *SXNET_new()
+SXNET *SXNET_new(void)
{
SXNET *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_SXNET_NEW);
}
-SXNET *d2i_SXNET(a,pp,length)
-SXNET **a;
-unsigned char **pp;
-long length;
+SXNET *d2i_SXNET(SXNET **a, unsigned char **pp, long length)
{
M_ASN1_D2I_vars(a,SXNET *,SXNET_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, SXNET_free, ASN1_F_D2I_SXNET);
}
-void SXNET_free(a)
-SXNET *a;
+void SXNET_free(SXNET *a)
{
if (a == NULL) return;
ASN1_INTEGER_free(a->version);
Free (a);
}
-int i2d_SXNETID(a,pp)
-SXNETID *a;
-unsigned char **pp;
+int i2d_SXNETID(SXNETID *a, unsigned char **pp)
{
M_ASN1_I2D_vars(a);
M_ASN1_I2D_finish();
}
-SXNETID *SXNETID_new()
+SXNETID *SXNETID_new(void)
{
SXNETID *ret=NULL;
ASN1_CTX c;
M_ASN1_New_Error(ASN1_F_SXNETID_NEW);
}
-SXNETID *d2i_SXNETID(a,pp,length)
-SXNETID **a;
-unsigned char **pp;
-long length;
+SXNETID *d2i_SXNETID(SXNETID **a, unsigned char **pp, long length)
{
M_ASN1_D2I_vars(a,SXNETID *,SXNETID_new);
M_ASN1_D2I_Init();
M_ASN1_D2I_Finish(a, SXNETID_free, ASN1_F_D2I_SXNETID);
}
-void SXNETID_free(a)
-SXNETID *a;
+void SXNETID_free(SXNETID *a)
{
if (a == NULL) return;
ASN1_INTEGER_free(a->zone);
Free (a);
}
-static int sxnet_i2r(method, sx, out, indent)
-X509V3_EXT_METHOD *method;
-SXNET *sx;
-BIO *out;
-int indent;
+static int sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out,
+ int indent)
{
long v;
char *tmp;
*/
-static SXNET * sxnet_v2i(method, ctx, nval)
-X509V3_EXT_METHOD *method;
-X509V3_CTX *ctx;
-STACK *nval;
+static SXNET * sxnet_v2i(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
+ STACK *nval)
{
CONF_VALUE *cnf;
SXNET *sx = NULL;
/* Add an id given the zone as an ASCII number */
-int SXNET_add_id_asc(psx, zone, user, userlen)
-SXNET **psx;
-char *zone;
-unsigned char *user;
-int userlen;
+int SXNET_add_id_asc(SXNET **psx, char *zone, unsigned char *user,
+ int userlen)
{
ASN1_INTEGER *izone = NULL;
if(!(izone = s2i_ASN1_INTEGER(NULL, zone))) {
/* Add an id given the zone as an unsigned long */
-int SXNET_add_id_ulong(psx, lzone, user, userlen)
-SXNET **psx;
-unsigned long lzone;
-unsigned char *user;
-int userlen;
+int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, unsigned char *user,
+ int userlen)
{
ASN1_INTEGER *izone = NULL;
if(!(izone = ASN1_INTEGER_new()) || !ASN1_INTEGER_set(izone, lzone)) {
* free it up afterwards.
*/
-int SXNET_add_id_INTEGER(psx, zone, user, userlen)
-SXNET **psx;
-ASN1_INTEGER *zone;
-unsigned char *user;
-int userlen;
+int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *zone, unsigned char *user,
+ int userlen)
{
SXNET *sx = NULL;
SXNETID *id = NULL;
return 0;
}
-ASN1_OCTET_STRING *SXNET_get_id_asc(sx, zone)
-SXNET *sx;
-char *zone;
+ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, char *zone)
{
ASN1_INTEGER *izone = NULL;
ASN1_OCTET_STRING *oct;
return oct;
}
-ASN1_OCTET_STRING *SXNET_get_id_ulong(sx, lzone)
-SXNET *sx;
-unsigned long lzone;
+ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)
{
ASN1_INTEGER *izone = NULL;
ASN1_OCTET_STRING *oct;
return oct;
}
-ASN1_OCTET_STRING *SXNET_get_id_INTEGER(sx, zone)
-SXNET *sx;
-ASN1_INTEGER *zone;
+ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
{
SXNETID *id;
int i;
/* Add a CONF_VALUE name value pair to stack */
-int X509V3_add_value(name, value, extlist)
-const char *name;
-const char *value;
-STACK **extlist;
+int X509V3_add_value(const char *name, const char *value, STACK **extlist)
{
CONF_VALUE *vtmp = NULL;
char *tname = NULL, *tvalue = NULL;
/* Free function for STACK of CONF_VALUE */
-void X509V3_conf_free(conf)
-CONF_VALUE *conf;
+void X509V3_conf_free(CONF_VALUE *conf)
{
if(!conf) return;
if(conf->name) Free(conf->name);
Free((char *)conf);
}
-int X509V3_add_value_bool(name, asn1_bool, extlist)
-const char *name;
-int asn1_bool;
-STACK **extlist;
+int X509V3_add_value_bool(const char *name, int asn1_bool, STACK **extlist)
{
if(asn1_bool) return X509V3_add_value(name, "TRUE", extlist);
return X509V3_add_value(name, "FALSE", extlist);
}
-int X509V3_add_value_bool_nf(name, asn1_bool, extlist)
-char *name;
-int asn1_bool;
-STACK **extlist;
+int X509V3_add_value_bool_nf(char *name, int asn1_bool, STACK **extlist)
{
if(asn1_bool) return X509V3_add_value(name, "TRUE", extlist);
return 1;
}
-char *i2s_ASN1_ENUMERATED(method, a)
-X509V3_EXT_METHOD *method;
-ASN1_ENUMERATED *a;
+char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *method, ASN1_ENUMERATED *a)
{
BIGNUM *bntmp = NULL;
char *strtmp = NULL;
return strtmp;
}
-char *i2s_ASN1_INTEGER(method, a)
-X509V3_EXT_METHOD *method;
-ASN1_INTEGER *a;
+char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, ASN1_INTEGER *a)
{
BIGNUM *bntmp = NULL;
char *strtmp = NULL;
return strtmp;
}
-ASN1_INTEGER *s2i_ASN1_INTEGER(method, value)
-X509V3_EXT_METHOD *method;
-char *value;
+ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, char *value)
{
BIGNUM *bn = NULL;
ASN1_INTEGER *aint;
return aint;
}
-int X509V3_add_value_int(name, aint, extlist)
-const char *name;
-ASN1_INTEGER *aint;
-STACK **extlist;
+int X509V3_add_value_int(const char *name, ASN1_INTEGER *aint,
+ STACK **extlist)
{
char *strtmp;
int ret;
return ret;
}
-int X509V3_get_value_bool(value, asn1_bool)
-CONF_VALUE *value;
-int *asn1_bool;
+int X509V3_get_value_bool(CONF_VALUE *value, int *asn1_bool)
{
char *btmp;
if(!(btmp = value->value)) goto err;
return 0;
}
-int X509V3_get_value_int(value, aint)
-CONF_VALUE *value;
-ASN1_INTEGER **aint;
+int X509V3_get_value_int(CONF_VALUE *value, ASN1_INTEGER **aint)
{
ASN1_INTEGER *itmp;
if(!(itmp = s2i_ASN1_INTEGER(NULL, value->value))) {
/*#define DEBUG*/
-STACK *X509V3_parse_list(line)
-char *line;
+STACK *X509V3_parse_list(char *line)
{
char *p, *q, c;
char *ntmp, *vtmp;
}
/* Delete leading and trailing spaces from a string */
-static char *strip_spaces(name)
-char *name;
+static char *strip_spaces(char *name)
{
char *p, *q;
/* Skip over leading spaces */
* hex representation
*/
-char *hex_to_string(buffer, len)
-unsigned char *buffer;
-long len;
+char *hex_to_string(unsigned char *buffer, long len)
{
char *tmp, *q;
unsigned char *p;
* a buffer
*/
-unsigned char *string_to_hex(str, len)
-char *str;
-long *len;
+unsigned char *string_to_hex(char *str, long *len)
{
unsigned char *hexbuf, *q;
unsigned char ch, cl, *p;
* cmp or cmp.*
*/
-int name_cmp(name, cmp)
-const char *name;
-const char *cmp;
+int name_cmp(const char *name, const char *cmp)
{
int len, ret;
char c;
/* Test application to add extensions from a config file */
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
LHASH *conf;
X509 *cert;
#endif
-void ERR_load_X509V3_strings()
+void ERR_load_X509V3_strings(void)
{
static int init=1;
#include "x509.h"
#include "x509v3.h"
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
{
X509 *cert;
FILE *inf;
* [including the GNU Public Licence.]
*/
-SV *new_ref(type,obj,mort)
-char *type;
-char *obj;
- {
+SV *new_ref(char *type, char *obj, int mort)
+{
SV *ret;
if (mort)
return(ret);
}
-int ex_new(obj,data,ad,idx,argl,argp)
-char *obj;
-SV *data;
-CRYPTO_EX_DATA *ad;
-int idx;
-long argl;
-char *argp;
+int ex_new(char *obj, SV *data, CRYPTO_EX_DATA *ad, int idx, long argl,
+ char *argp)
{
SV *sv;
return(1);
}
-void ex_cleanup(obj,data,ad,idx,argl,argp)
-char *obj;
-SV *data;
-CRYPTO_EX_DATA *ad;
-int idx;
-long argl;
-char *argp;
+void ex_cleanup(char *obj, SV *data, CRYPTO_EX_DATA *ad, int idx, long argl,
+ char *argp)
{
pr_name("ex_cleanup");
fprintf(stderr,"ex_cleanup %08X %s\n",obj,argp);
#endif
-void ERR_load_RSAREF_strings()
+void ERR_load_RSAREF_strings(void)
{
static int init=1;
NULL,
};
-RSA_METHOD *RSA_PKCS1_RSAref()
+RSA_METHOD *RSA_PKCS1_RSAref(void)
{
return(&rsa_pkcs1_ref_meth);
}
-static int RSA_ref_mod_exp(r0, I, rsa)
-BIGNUM *r0;
-BIGNUM *I;
-RSA *rsa;
+static int RSA_ref_mod_exp(BIGNUM *r0, BIGNUM *I, RSA *rsa)
{
RSAREFerr(RSAREF_F_RSA_REF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return(0);
}
-static int BN_ref_mod_exp(r,a,p,m,ctx,m_ctx)
-BIGNUM *r,*a,*p,*m;
-BN_CTX *ctx;
-BN_MONT_CTX *m_ctx;
+static int BN_ref_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
+ BN_CTX *ctx, BN_MONT_CTX *m_ctx)
{
RSAREFerr(RSAREF_F_BN_REF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return(0);
}
-static int RSAref_bn2bin(from,to,max)
-BIGNUM *from;
-unsigned char *to; /* [max] */
-int max;
+/* unsigned char *to: [max] */
+static int RSAref_bn2bin(BIGNUM *from, unsigned char *to, int max)
{
int i;
}
#ifdef undef
-static BIGNUM *RSAref_bin2bn(from,to,max)
-unsigned char *from; /* [max] */
-BIGNUM *to;
-int max;
+/* unsigned char *from: [max] */
+static BIGNUM *RSAref_bin2bn(unsigned char *from, BIGNUM *to, int max)
{
int i;
BIGNUM *ret;
return(ret);
}
-static int RSAref_Public_ref2eay(from,to)
-RSArefPublicKey *from;
-RSA *to;
+static int RSAref_Public_ref2eay(RSArefPublicKey *from, RSA *to)
{
to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN);
to->e=RSAref_bin2bn(from->e,NULL,RSAref_MAX_LEN);
}
#endif
-static int RSAref_Public_eay2ref(from,to)
-RSA *from;
-RSArefPublicKey *to;
+static int RSAref_Public_eay2ref(RSA *from, RSArefPublicKey *to)
{
to->bits=BN_num_bits(from->n);
if (!RSAref_bn2bin(from->n,to->m,RSAref_MAX_LEN)) return(0);
}
#ifdef undef
-static int RSAref_Private_ref2eay(from,to)
-RSArefPrivateKey *from;
-RSA *to;
+static int RSAref_Private_ref2eay(RSArefPrivateKey *from, RSA *to)
{
if ((to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN)) == NULL)
return(0);
}
#endif
-static int RSAref_Private_eay2ref(from,to)
-RSA *from;
-RSArefPrivateKey *to;
+static int RSAref_Private_eay2ref(RSA *from, RSArefPrivateKey *to)
{
to->bits=BN_num_bits(from->n);
if (!RSAref_bn2bin(from->n,to->m,RSAref_MAX_LEN)) return(0);
return(1);
}
-int RSA_ref_private_decrypt(len,from,to,rsa,padding)
-int len;
-unsigned char *from,*to;
-RSA *rsa;
-int padding;
+int RSA_ref_private_decrypt(int len, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
int i,outlen= -1;
RSArefPrivateKey RSAkey;
return(outlen);
}
-int RSA_ref_private_encrypt(len,from,to,rsa,padding)
-int len;
-unsigned char *from,*to;
-RSA *rsa;
-int padding;
+int RSA_ref_private_encrypt(int len, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
int i,outlen= -1;
RSArefPrivateKey RSAkey;
return(outlen);
}
-int RSA_ref_public_decrypt(len,from,to,rsa,padding)
-int len;
-unsigned char *from,*to;
-RSA *rsa;
-int padding;
+int RSA_ref_public_decrypt(int len, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
int i,outlen= -1;
RSArefPublicKey RSAkey;
return(outlen);
}
-int RSA_ref_public_encrypt(len,from,to,rsa,padding)
-int len;
-unsigned char *from,*to;
-RSA *rsa;
-int padding;
+int RSA_ref_public_encrypt(int len, unsigned char *from, unsigned char *to,
+ RSA *rsa, int padding)
{
int outlen= -1;
int i;
ssl_free,
};
-BIO_METHOD *BIO_f_ssl()
+BIO_METHOD *BIO_f_ssl(void)
{
return(&methods_sslp);
}
-static int ssl_new(bi)
-BIO *bi;
+static int ssl_new(BIO *bi)
{
BIO_SSL *bs;
return(1);
}
-static int ssl_free(a)
-BIO *a;
+static int ssl_free(BIO *a)
{
BIO_SSL *bs;
return(1);
}
-static int ssl_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int ssl_read(BIO *b, char *out, int outl)
{
int ret=1;
BIO_SSL *sb;
return(ret);
}
-static int ssl_write(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int ssl_write(BIO *b, char *out, int outl)
{
int ret,r=0;
int retry_reason=0;
return(ret);
}
-static long ssl_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long ssl_ctrl(BIO *b, int cmd, long num, char *ptr)
{
SSL **sslp,*ssl;
BIO_SSL *bs;
return(ret);
}
-static int ssl_puts(bp,str)
-BIO *bp;
-char *str;
+static int ssl_puts(BIO *bp, char *str)
{
int n,ret;
return(ret);
}
-BIO *BIO_new_buffer_ssl_connect(ctx)
-SSL_CTX *ctx;
+BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
{
BIO *ret=NULL,*buf=NULL,*ssl=NULL;
return(NULL);
}
-BIO *BIO_new_ssl_connect(ctx)
-SSL_CTX *ctx;
+BIO *BIO_new_ssl_connect(SSL_CTX *ctx)
{
BIO *ret=NULL,*con=NULL,*ssl=NULL;
return(NULL);
}
-BIO *BIO_new_ssl(ctx,client)
-SSL_CTX *ctx;
-int client;
+BIO *BIO_new_ssl(SSL_CTX *ctx, int client)
{
BIO *ret;
SSL *ssl;
return(ret);
}
-int BIO_ssl_copy_session_id(t,f)
-BIO *t,*f;
+int BIO_ssl_copy_session_id(BIO *t, BIO *f)
{
t=BIO_find_type(t,BIO_TYPE_SSL);
f=BIO_find_type(f,BIO_TYPE_SSL);
return(1);
}
-void BIO_ssl_shutdown(b)
-BIO *b;
+void BIO_ssl_shutdown(BIO *b)
{
SSL *s;
static int ssl23_get_server_hello();
#endif
-static SSL_METHOD *ssl23_get_client_method(ver)
-int ver;
+static SSL_METHOD *ssl23_get_client_method(int ver)
{
if (ver == SSL2_VERSION)
return(SSLv2_client_method());
return(NULL);
}
-SSL_METHOD *SSLv23_client_method()
+SSL_METHOD *SSLv23_client_method(void)
{
static int init=1;
static SSL_METHOD SSLv23_client_data;
return(&SSLv23_client_data);
}
-int ssl23_connect(s)
-SSL *s;
+int ssl23_connect(SSL *s)
{
BUF_MEM *buf;
unsigned long Time=time(NULL);
}
-static int ssl23_client_hello(s)
-SSL *s;
+static int ssl23_client_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p,*d;
return(ssl23_write_bytes(s));
}
-static int ssl23_get_server_hello(s)
-SSL *s;
+static int ssl23_get_server_hello(SSL *s)
{
char buf[8];
unsigned char *p;
&ssl3_undef_enc_method,
};
-static long ssl23_default_timeout()
+static long ssl23_default_timeout(void)
{
return(300);
}
-SSL_METHOD *sslv23_base_method()
+SSL_METHOD *sslv23_base_method(void)
{
return(&SSLv23_data);
}
-static int ssl23_num_ciphers()
+static int ssl23_num_ciphers(void)
{
return(ssl3_num_ciphers()+ssl2_num_ciphers());
}
-static SSL_CIPHER *ssl23_get_cipher(u)
-unsigned int u;
+static SSL_CIPHER *ssl23_get_cipher(unsigned int u)
{
unsigned int uu=ssl3_num_ciphers();
/* This function needs to check if the ciphers required are actually
* available */
-static SSL_CIPHER *ssl23_get_cipher_by_char(p)
-const unsigned char *p;
+static SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p)
{
SSL_CIPHER c,*cp;
unsigned long id;
return(cp);
}
-static int ssl23_put_cipher_by_char(c,p)
-const SSL_CIPHER *c;
-unsigned char *p;
+static int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
{
long l;
return(3);
}
-static int ssl23_read(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+static int ssl23_read(SSL *s, char *buf, int len)
{
int n;
}
}
-static int ssl23_write(s,buf,len)
-SSL *s;
-const char *buf;
-int len;
+static int ssl23_write(SSL *s, const char *buf, int len)
{
int n;
static SSL_METHOD *ssl23_get_method();
#endif
-static SSL_METHOD *ssl23_get_method(ver)
-int ver;
+static SSL_METHOD *ssl23_get_method(int ver)
{
if (ver == SSL2_VERSION)
return(SSLv23_method());
return(NULL);
}
-SSL_METHOD *SSLv23_method()
+SSL_METHOD *SSLv23_method(void)
{
static int init=1;
static SSL_METHOD SSLv23_data;
#include "buffer.h"
#include "ssl_locl.h"
-int ssl23_write_bytes(s)
-SSL *s;
+int ssl23_write_bytes(SSL *s)
{
int i,num,tot;
char *buf;
}
/* only return when we have read 'n' bytes */
-int ssl23_read_bytes(s,n)
-SSL *s;
-int n;
+int ssl23_read_bytes(SSL *s, int n)
{
unsigned char *p;
int j;
int ssl23_get_client_hello();
#endif
-static SSL_METHOD *ssl23_get_server_method(ver)
-int ver;
+static SSL_METHOD *ssl23_get_server_method(int ver)
{
if (ver == SSL2_VERSION)
return(SSLv2_server_method());
return(NULL);
}
-SSL_METHOD *SSLv23_server_method()
+SSL_METHOD *SSLv23_server_method(void)
{
static int init=1;
static SSL_METHOD SSLv23_server_data;
return(&SSLv23_server_data);
}
-int ssl23_accept(s)
-SSL *s;
+int ssl23_accept(SSL *s)
{
BUF_MEM *buf;
unsigned long Time=time(NULL);
}
-int ssl23_get_client_hello(s)
-SSL *s;
+int ssl23_get_client_hello(SSL *s)
{
char buf_space[8];
char *buf= &(buf_space[0]);
#define BREAK break
-static SSL_METHOD *ssl2_get_client_method(ver)
-int ver;
+static SSL_METHOD *ssl2_get_client_method(int ver)
{
if (ver == SSL2_VERSION)
return(SSLv2_client_method());
return(NULL);
}
-SSL_METHOD *SSLv2_client_method()
+SSL_METHOD *SSLv2_client_method(void)
{
static int init=1;
static SSL_METHOD SSLv2_client_data;
return(&SSLv2_client_data);
}
-int ssl2_connect(s)
-SSL *s;
+int ssl2_connect(SSL *s)
{
unsigned long l=time(NULL);
BUF_MEM *buf=NULL;
return(ret);
}
-static int get_server_hello(s)
-SSL *s;
+static int get_server_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p;
return(1);
}
-static int client_hello(s)
-SSL *s;
+static int client_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p,*d;
return(ssl2_do_write(s));
}
-static int client_master_key(s)
-SSL *s;
+static int client_master_key(SSL *s)
{
unsigned char *buf;
unsigned char *p,*d;
return(ssl2_do_write(s));
}
-static int client_finished(s)
-SSL *s;
+static int client_finished(SSL *s)
{
unsigned char *p;
}
/* read the data and then respond */
-static int client_certificate(s)
-SSL *s;
+static int client_certificate(SSL *s)
{
unsigned char *buf;
unsigned char *p,*d;
return(ssl2_do_write(s));
}
-static int get_server_verify(s)
-SSL *s;
+static int get_server_verify(SSL *s)
{
unsigned char *p;
int i;
return(1);
}
-static int get_server_finished(s)
-SSL *s;
+static int get_server_finished(SSL *s)
{
unsigned char *buf;
unsigned char *p;
}
/* loads in the certificate from the server */
-int ssl2_set_certificate(s, type, len, data)
-SSL *s;
-int type;
-int len;
-unsigned char *data;
+int ssl2_set_certificate(SSL *s, int type, int len, unsigned char *data)
{
STACK_OF(X509) *sk=NULL;
EVP_PKEY *pkey=NULL;
return(ret);
}
-static int ssl_rsa_public_encrypt(c, len, from, to, padding)
-CERT *c;
-int len;
-unsigned char *from;
-unsigned char *to;
-int padding;
+static int ssl_rsa_public_encrypt(CERT *c, int len, unsigned char *from,
+ unsigned char *to, int padding)
{
EVP_PKEY *pkey=NULL;
int i= -1;
#include <stdio.h>
#include "ssl_locl.h"
-int ssl2_enc_init(s, client)
-SSL *s;
-int client;
+int ssl2_enc_init(SSL *s, int client)
{
/* Max number of bytes needed */
EVP_CIPHER_CTX *rs,*ws;
/* read/writes from s->s2->mac_data using length for encrypt and
* decrypt. It sets the s->s2->padding, s->[rw]length and
* s->s2->pad_data ptr if we are encrypting */
-void ssl2_enc(s,send)
-SSL *s;
-int send;
+void ssl2_enc(SSL *s, int send)
{
EVP_CIPHER_CTX *ds;
unsigned long l;
EVP_Cipher(ds,s->s2->mac_data,s->s2->mac_data,l);
}
-void ssl2_mac(s, md,send)
-SSL *s;
-unsigned char *md;
-int send;
+void ssl2_mac(SSL *s, unsigned char *md, int send)
{
EVP_MD_CTX c;
unsigned char sequence[4],*p,*sec,*act;
&ssl3_undef_enc_method,
};
-static long ssl2_default_timeout()
+static long ssl2_default_timeout(void)
{
return(300);
}
-SSL_METHOD *sslv2_base_method()
+SSL_METHOD *sslv2_base_method(void)
{
return(&SSLv2_data);
}
-int ssl2_num_ciphers()
+int ssl2_num_ciphers(void)
{
return(SSL2_NUM_CIPHERS);
}
-SSL_CIPHER *ssl2_get_cipher(u)
-unsigned int u;
+SSL_CIPHER *ssl2_get_cipher(unsigned int u)
{
if (u < SSL2_NUM_CIPHERS)
return(&(ssl2_ciphers[SSL2_NUM_CIPHERS-1-u]));
return(NULL);
}
-int ssl2_pending(s)
-SSL *s;
+int ssl2_pending(SSL *s)
{
return(s->s2->ract_data_length);
}
-int ssl2_new(s)
-SSL *s;
+int ssl2_new(SSL *s)
{
SSL2_CTX *s2;
return(0);
}
-void ssl2_free(s)
-SSL *s;
+void ssl2_free(SSL *s)
{
SSL2_CTX *s2;
s->s2=NULL;
}
-void ssl2_clear(s)
-SSL *s;
+void ssl2_clear(SSL *s)
{
SSL2_CTX *s2;
unsigned char *rbuf,*wbuf;
s->packet_length=0;
}
-long ssl2_ctrl(s,cmd,larg,parg)
-SSL *s;
-int cmd;
-long larg;
-char *parg;
+long ssl2_ctrl(SSL *s, int cmd, long larg, char *parg)
{
int ret=0;
return(ret);
}
-long ssl2_ctx_ctrl(ctx,cmd,larg,parg)
-SSL_CTX *ctx;
-int cmd;
-long larg;
-char *parg;
+long ssl2_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, char *parg)
{
return(0);
}
/* This function needs to check if the ciphers required are actually
* available */
-SSL_CIPHER *ssl2_get_cipher_by_char(p)
-const unsigned char *p;
+SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p)
{
static int init=1;
static SSL_CIPHER *sorted[SSL2_NUM_CIPHERS];
return(*cpp);
}
-int ssl2_put_cipher_by_char(c,p)
-const SSL_CIPHER *c;
-unsigned char *p;
+int ssl2_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
{
long l;
return(3);
}
-void ssl2_generate_key_material(s)
-SSL *s;
+void ssl2_generate_key_material(SSL *s)
{
unsigned int i;
MD5_CTX ctx;
}
}
-void ssl2_return_error(s,err)
-SSL *s;
-int err;
+void ssl2_return_error(SSL *s, int err)
{
if (!s->error)
{
}
-void ssl2_write_error(s)
-SSL *s;
+void ssl2_write_error(SSL *s)
{
char buf[3];
int i,error;
s->error=0; */
}
-int ssl2_shutdown(s)
-SSL *s;
+int ssl2_shutdown(SSL *s)
{
s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
return(1);
static SSL_METHOD *ssl2_get_method();
#endif
-static SSL_METHOD *ssl2_get_method(ver)
-int ver;
+static SSL_METHOD *ssl2_get_method(int ver)
{
if (ver == SSL2_VERSION)
return(SSLv2_method());
return(NULL);
}
-SSL_METHOD *SSLv2_method()
+SSL_METHOD *SSLv2_method(void)
{
static int init=1;
static SSL_METHOD SSLv2_data;
static int ssl_mt_error();
#endif
-int ssl2_peek(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+int ssl2_peek(SSL *s, char *buf, int len)
{
int ret;
/* SSL_read -
* This routine will return 0 to len bytes, decrypted etc if required.
*/
-int ssl2_read(s, buf, len)
-SSL *s;
-char *buf;
-int len;
+int ssl2_read(SSL *s, char *buf, int len)
{
int n;
unsigned char mac[MAX_MAC_SIZE];
}
}
-static int read_n(s, n, max, extend)
-SSL *s;
-unsigned int n;
-unsigned int max;
-unsigned int extend;
+static int read_n(SSL *s, unsigned int n, unsigned int max,
+ unsigned int extend)
{
int i,off,newb;
return(n);
}
-int ssl2_write(s, buf, len)
-SSL *s;
-const char *buf;
-int len;
+int ssl2_write(SSL *s, const char *buf, int len)
{
unsigned int n,tot;
int i;
}
}
-static int write_pending(s,buf,len)
-SSL *s;
-const char *buf;
-unsigned int len;
+static int write_pending(SSL *s, const char *buf, unsigned int len)
{
int i;
}
}
-static int do_ssl_write(s, buf, len)
-SSL *s;
-const char *buf;
-unsigned int len;
+static int do_ssl_write(SSL *s, const char *buf, unsigned int len)
{
unsigned int j,k,olen,p,mac_size,bs;
register unsigned char *pp;
return(write_pending(s,buf,olen));
}
-int ssl2_part_read(s,f,i)
-SSL *s;
-unsigned long f;
-int i;
+int ssl2_part_read(SSL *s, unsigned long f, int i)
{
unsigned char *p;
int j;
}
}
-int ssl2_do_write(s)
-SSL *s;
+int ssl2_do_write(SSL *s)
{
int ret;
return(0);
}
-static int ssl_mt_error(n)
-int n;
+static int ssl_mt_error(int n)
{
int ret;
#define BREAK break
-static SSL_METHOD *ssl2_get_server_method(ver)
-int ver;
+static SSL_METHOD *ssl2_get_server_method(int ver)
{
if (ver == SSL2_VERSION)
return(SSLv2_server_method());
return(NULL);
}
-SSL_METHOD *SSLv2_server_method()
+SSL_METHOD *SSLv2_server_method(void)
{
static int init=1;
static SSL_METHOD SSLv2_server_data;
return(&SSLv2_server_data);
}
-int ssl2_accept(s)
-SSL *s;
+int ssl2_accept(SSL *s)
{
unsigned long l=time(NULL);
BUF_MEM *buf=NULL;
return(ret);
}
-static int get_client_master_key(s)
-SSL *s;
+static int get_client_master_key(SSL *s)
{
int export,i,n,keya,ek;
unsigned char *p;
return(1);
}
-static int get_client_hello(s)
-SSL *s;
+static int get_client_hello(SSL *s)
{
int i,n;
unsigned char *p;
return(0);
}
-static int server_hello(s)
-SSL *s;
+static int server_hello(SSL *s)
{
unsigned char *p,*d;
int n,hit;
return(ssl2_do_write(s));
}
-static int get_client_finished(s)
-SSL *s;
+static int get_client_finished(SSL *s)
{
unsigned char *p;
int i;
return(1);
}
-static int server_verify(s)
-SSL *s;
+static int server_verify(SSL *s)
{
unsigned char *p;
return(ssl2_do_write(s));
}
-static int server_finish(s)
-SSL *s;
+static int server_finish(SSL *s)
{
unsigned char *p;
}
/* send the request and check the response */
-static int request_certificate(s)
-SSL *s;
+static int request_certificate(SSL *s)
{
unsigned char *p,*p2,*buf2;
unsigned char *ccd;
return(ret);
}
-static int ssl_rsa_private_decrypt(c, len, from, to,padding)
-CERT *c;
-int len;
-unsigned char *from;
-unsigned char *to;
-int padding;
+static int ssl_rsa_private_decrypt(CERT *c, int len, unsigned char *from,
+ unsigned char *to, int padding)
{
RSA *rsa;
int i;
/* SSL3err(SSL_F_SSL3_GET_FINISHED,SSL_R_EXCESSIVE_MESSAGE_SIZE);
*/
-int ssl3_send_finished(s,a,b,sender,slen)
-SSL *s;
-int a;
-int b;
-unsigned char *sender;
-int slen;
+int ssl3_send_finished(SSL *s, int a, int b, unsigned char *sender,
+ int slen)
{
unsigned char *p,*d;
int i;
return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
}
-int ssl3_get_finished(s,a,b)
-SSL *s;
-int a;
-int b;
+int ssl3_get_finished(SSL *s, int a, int b)
{
int al,i,ok;
long n;
* ssl->session->read_compression assign
* ssl->session->read_hash assign
*/
-int ssl3_send_change_cipher_spec(s,a,b)
-SSL *s;
-int a,b;
+int ssl3_send_change_cipher_spec(SSL *s, int a, int b)
{
unsigned char *p;
return(ssl3_do_write(s,SSL3_RT_CHANGE_CIPHER_SPEC));
}
-unsigned long ssl3_output_cert_chain(s,x)
-SSL *s;
-X509 *x;
+unsigned long ssl3_output_cert_chain(SSL *s, X509 *x)
{
unsigned char *p;
int n,i;
return(l);
}
-long ssl3_get_message(s,st1,stn,mt,max,ok)
-SSL *s;
-int st1,stn,mt;
-long max;
-int *ok;
+long ssl3_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok)
{
unsigned char *p;
unsigned long l;
return(-1);
}
-int ssl_cert_type(x,pkey)
-X509 *x;
-EVP_PKEY *pkey;
+int ssl_cert_type(X509 *x, EVP_PKEY *pkey)
{
EVP_PKEY *pk;
int ret= -1,i,j;
return(ret);
}
-int ssl_verify_alarm_type(type)
-long type;
+int ssl_verify_alarm_type(long type)
{
int al;
return(al);
}
-int ssl3_setup_buffers(s)
-SSL *s;
+int ssl3_setup_buffers(SSL *s)
{
unsigned char *p;
unsigned int extra;
static int ssl3_check_cert_and_algorithm();
#endif
-static SSL_METHOD *ssl3_get_client_method(ver)
-int ver;
+static SSL_METHOD *ssl3_get_client_method(int ver)
{
if (ver == SSL3_VERSION)
return(SSLv3_client_method());
return(NULL);
}
-SSL_METHOD *SSLv3_client_method()
+SSL_METHOD *SSLv3_client_method(void)
{
static int init=1;
static SSL_METHOD SSLv3_client_data;
return(&SSLv3_client_data);
}
-int ssl3_connect(s)
-SSL *s;
+int ssl3_connect(SSL *s)
{
BUF_MEM *buf;
unsigned long Time=time(NULL),l;
}
-static int ssl3_client_hello(s)
-SSL *s;
+static int ssl3_client_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p,*d;
return(-1);
}
-static int ssl3_get_server_hello(s)
-SSL *s;
+static int ssl3_get_server_hello(SSL *s)
{
STACK_OF(SSL_CIPHER) *sk;
SSL_CIPHER *c;
return(-1);
}
-static int ssl3_get_server_certificate(s)
-SSL *s;
+static int ssl3_get_server_certificate(SSL *s)
{
int al,i,ok,ret= -1;
unsigned long n,nc,llen,l;
return(ret);
}
-static int ssl3_get_key_exchange(s)
-SSL *s;
+static int ssl3_get_key_exchange(SSL *s)
{
#ifndef NO_RSA
unsigned char *q,md_buf[EVP_MAX_MD_SIZE*2];
return(-1);
}
-static int ssl3_get_certificate_request(s)
-SSL *s;
+static int ssl3_get_certificate_request(SSL *s)
{
int ok,ret=0;
unsigned long n,nc,l;
return(ret);
}
-static int ca_dn_cmp(a,b)
-X509_NAME **a,**b;
+static int ca_dn_cmp(X509_NAME **a, X509_NAME **b)
{
return(X509_NAME_cmp(*a,*b));
}
-static int ssl3_get_server_done(s)
-SSL *s;
+static int ssl3_get_server_done(SSL *s)
{
int ok,ret=0;
long n;
return(ret);
}
-static int ssl3_send_client_key_exchange(s)
-SSL *s;
+static int ssl3_send_client_key_exchange(SSL *s)
{
unsigned char *p,*q,*d;
int n;
return(-1);
}
-static int ssl3_send_client_verify(s)
-SSL *s;
+static int ssl3_send_client_verify(SSL *s)
{
unsigned char *p,*d;
unsigned char data[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH];
return(-1);
}
-static int ssl3_send_client_certificate(s)
-SSL *s;
+static int ssl3_send_client_certificate(SSL *s)
{
X509 *x509=NULL;
EVP_PKEY *pkey=NULL;
#define has_bits(i,m) (((i)&(m)) == (m))
-static int ssl3_check_cert_and_algorithm(s)
-SSL *s;
+static int ssl3_check_cert_and_algorithm(SSL *s)
{
int i,idx;
long algs;
static int ssl3_handshake_mac();
#endif
-static void ssl3_generate_key_block(s,km,num)
-SSL *s;
-unsigned char *km;
-int num;
+static void ssl3_generate_key_block(SSL *s, unsigned char *km, int num)
{
MD5_CTX m5;
SHA_CTX s1;
memset(smd,0,SHA_DIGEST_LENGTH);
}
-int ssl3_change_cipher_state(s,which)
-SSL *s;
-int which;
+int ssl3_change_cipher_state(SSL *s, int which)
{
unsigned char *p,*key_block,*mac_secret;
unsigned char exp_key[EVP_MAX_KEY_LENGTH];
return(0);
}
-int ssl3_setup_key_block(s)
-SSL *s;
+int ssl3_setup_key_block(SSL *s)
{
unsigned char *p;
const EVP_CIPHER *c;
return(0);
}
-void ssl3_cleanup_key_block(s)
-SSL *s;
+void ssl3_cleanup_key_block(SSL *s)
{
if (s->s3->tmp.key_block != NULL)
{
s->s3->tmp.key_block_length=0;
}
-int ssl3_enc(s,send)
-SSL *s;
-int send;
+int ssl3_enc(SSL *s, int send)
{
SSL3_RECORD *rec;
EVP_CIPHER_CTX *ds;
return(1);
}
-void ssl3_init_finished_mac(s)
-SSL *s;
+void ssl3_init_finished_mac(SSL *s)
{
EVP_DigestInit(&(s->s3->finish_dgst1),s->ctx->md5);
EVP_DigestInit(&(s->s3->finish_dgst2),s->ctx->sha1);
}
-void ssl3_finish_mac(s,buf,len)
-SSL *s;
-const unsigned char *buf;
-int len;
+void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len)
{
EVP_DigestUpdate(&(s->s3->finish_dgst1),buf,len);
EVP_DigestUpdate(&(s->s3->finish_dgst2),buf,len);
}
-int ssl3_cert_verify_mac(s,ctx,p)
-SSL *s;
-EVP_MD_CTX *ctx;
-unsigned char *p;
+int ssl3_cert_verify_mac(SSL *s, EVP_MD_CTX *ctx, unsigned char *p)
{
return(ssl3_handshake_mac(s,ctx,NULL,0,p));
}
-int ssl3_final_finish_mac(s,ctx1,ctx2,sender,len,p)
-SSL *s;
-EVP_MD_CTX *ctx1,*ctx2;
-unsigned char *sender;
-int len;
-unsigned char *p;
+int ssl3_final_finish_mac(SSL *s, EVP_MD_CTX *ctx1, EVP_MD_CTX *ctx2,
+ unsigned char *sender, int len, unsigned char *p)
{
int ret;
return(ret);
}
-static int ssl3_handshake_mac(s,in_ctx,sender,len,p)
-SSL *s;
-EVP_MD_CTX *in_ctx;
-unsigned char *sender;
-int len;
-unsigned char *p;
+static int ssl3_handshake_mac(SSL *s, EVP_MD_CTX *in_ctx,
+ unsigned char *sender, int len, unsigned char *p)
{
unsigned int ret;
int npad,n;
return((int)ret);
}
-int ssl3_mac(ssl,md,send)
-SSL *ssl;
-unsigned char *md;
-int send;
+int ssl3_mac(SSL *ssl, unsigned char *md, int send)
{
SSL3_RECORD *rec;
unsigned char *mac_sec,*seq;
return(md_size);
}
-int ssl3_generate_master_secret(s,out,p,len)
-SSL *s;
-unsigned char *out;
-unsigned char *p;
-int len;
+int ssl3_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
+ int len)
{
static const unsigned char *salt[3]={
(const unsigned char *)"A",
return(ret);
}
-int ssl3_alert_code(code)
-int code;
+int ssl3_alert_code(int code)
{
switch (code)
{
&SSLv3_enc_data,
};
-static long ssl3_default_timeout()
+static long ssl3_default_timeout(void)
{
/* 2 hours, the 24 hours mentioned in the SSLv3 spec
* is way too long for http, the cache would over fill */
return(60*60*2);
}
-SSL_METHOD *sslv3_base_method()
+SSL_METHOD *sslv3_base_method(void)
{
return(&SSLv3_data);
}
-int ssl3_num_ciphers()
+int ssl3_num_ciphers(void)
{
return(SSL3_NUM_CIPHERS);
}
-SSL_CIPHER *ssl3_get_cipher(u)
-unsigned int u;
+SSL_CIPHER *ssl3_get_cipher(unsigned int u)
{
if (u < SSL3_NUM_CIPHERS)
return(&(ssl3_ciphers[SSL3_NUM_CIPHERS-1-u]));
}
/* The problem is that it may not be the correct record type */
-int ssl3_pending(s)
-SSL *s;
+int ssl3_pending(SSL *s)
{
return(s->s3->rrec.length);
}
-int ssl3_new(s)
-SSL *s;
+int ssl3_new(SSL *s)
{
SSL3_CTX *s3;
return(0);
}
-void ssl3_free(s)
-SSL *s;
+void ssl3_free(SSL *s)
{
if(s == NULL)
return;
s->s3=NULL;
}
-void ssl3_clear(s)
-SSL *s;
+void ssl3_clear(SSL *s)
{
unsigned char *rp,*wp;
s->version=SSL3_VERSION;
}
-long ssl3_ctrl(s,cmd,larg,parg)
-SSL *s;
-int cmd;
-long larg;
-char *parg;
+long ssl3_ctrl(SSL *s, int cmd, long larg, char *parg)
{
int ret=0;
return(ret);
}
-long ssl3_ctx_ctrl(ctx,cmd,larg,parg)
-SSL_CTX *ctx;
-int cmd;
-long larg;
-char *parg;
+long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, char *parg)
{
CERT *cert;
/* This function needs to check if the ciphers required are actually
* available */
-SSL_CIPHER *ssl3_get_cipher_by_char(p)
-const unsigned char *p;
+SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p)
{
static int init=1;
static SSL_CIPHER *sorted[SSL3_NUM_CIPHERS];
return(*cpp);
}
-int ssl3_put_cipher_by_char(c,p)
-const SSL_CIPHER *c;
-unsigned char *p;
+int ssl3_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
{
long l;
return(2);
}
-int ssl3_part_read(s,i)
-SSL *s;
-int i;
+int ssl3_part_read(SSL *s, int i)
{
s->rwstate=SSL_READING;
}
}
-SSL_CIPHER *ssl3_choose_cipher(s,have,pref)
-SSL *s;
-STACK_OF(SSL_CIPHER) *have;
-STACK_OF(SSL_CIPHER) *pref;
+SSL_CIPHER *ssl3_choose_cipher(SSL *s, STACK_OF(SSL_CIPHER) *have,
+ STACK_OF(SSL_CIPHER) *pref)
{
SSL_CIPHER *c,*ret=NULL;
int i,j,ok;
return(ret);
}
-int ssl3_get_req_cert_type(s,p)
-SSL *s;
-unsigned char *p;
+int ssl3_get_req_cert_type(SSL *s, unsigned char *p)
{
int ret=0;
unsigned long alg;
return(ret);
}
-int ssl3_shutdown(s)
-SSL *s;
+int ssl3_shutdown(SSL *s)
{
/* Don't do anything much if we have not done the handshake or
return(0);
}
-int ssl3_write(s,buf,len)
-SSL *s;
-const char *buf;
-int len;
+int ssl3_write(SSL *s, const char *buf, int len)
{
int ret,n;
return(ret);
}
-int ssl3_read(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+int ssl3_read(SSL *s, char *buf, int len)
{
int ret;
return(ret);
}
-int ssl3_peek(s,buf,len)
-SSL *s;
-char *buf;
-int len;
+int ssl3_peek(SSL *s, char *buf, int len)
{
SSL3_RECORD *rr;
int n;
return(n);
}
-int ssl3_renegotiate(s)
-SSL *s;
+int ssl3_renegotiate(SSL *s)
{
if (s->handshake_func == NULL)
return(1);
return(1);
}
-int ssl3_renegotiate_check(s)
-SSL *s;
+int ssl3_renegotiate_check(SSL *s)
{
int ret=0;
static SSL_METHOD *ssl3_get_method();
#endif
-static SSL_METHOD *ssl3_get_method(ver)
-int ver;
+static SSL_METHOD *ssl3_get_method(int ver)
{
if (ver == SSL3_VERSION)
return(SSLv3_method());
return(NULL);
}
-SSL_METHOD *SSLv3_method()
+SSL_METHOD *SSLv3_method(void)
{
static int init=1;
static SSL_METHOD SSLv3_data;
static int do_change_cipher_spec();
#endif
-static int ssl3_read_n(s,n,max,extend)
-SSL *s;
-int n;
-int max;
-int extend;
+static int ssl3_read_n(SSL *s, int n, int max, int extend)
{
int i,off,newb;
* ssl->s3->rrec.data, - data
* ssl->s3->rrec.length, - number of bytes
*/
-static int ssl3_get_record(s)
-SSL *s;
+static int ssl3_get_record(SSL *s)
{
int ssl_major,ssl_minor,al;
int n,i,ret= -1;
return(ret);
}
-static int do_uncompress(ssl)
-SSL *ssl;
+static int do_uncompress(SSL *ssl)
{
int i;
SSL3_RECORD *rr;
return(1);
}
-static int do_compress(ssl)
-SSL *ssl;
+static int do_compress(SSL *ssl)
{
int i;
SSL3_RECORD *wr;
/* Call this to write data
* It will return <= 0 if not all data has been sent or non-blocking IO.
*/
-int ssl3_write_bytes(s,type,buf,len)
-SSL *s;
-int type;
-const char *buf;
-int len;
+int ssl3_write_bytes(SSL *s, int type, const char *buf, int len)
{
unsigned int tot,n,nw;
int i;
}
}
-static int do_ssl3_write(s,type,buf,len)
-SSL *s;
-int type;
-const char *buf;
-unsigned int len;
+static int do_ssl3_write(SSL *s, int type, const char *buf,
+ unsigned int len)
{
unsigned char *p,*plen;
int i,mac_size,clear=0;
}
/* if s->s3->wbuf.left != 0, we need to call this */
-static int ssl3_write_pending(s,type,buf,len)
-SSL *s;
-int type;
-const char *buf;
-unsigned int len;
+static int ssl3_write_pending(SSL *s, int type, const char *buf,
+ unsigned int len)
{
int i;
}
}
-int ssl3_read_bytes(s,type,buf,len)
-SSL *s;
-int type;
-char *buf;
-int len;
+int ssl3_read_bytes(SSL *s, int type, char *buf, int len)
{
int al,i,j,n,ret;
SSL3_RECORD *rr;
return(-1);
}
-static int do_change_cipher_spec(s)
-SSL *s;
+static int do_change_cipher_spec(SSL *s)
{
int i;
unsigned char *sender;
return(1);
}
-int ssl3_do_write(s,type)
-SSL *s;
-int type;
+int ssl3_do_write(SSL *s, int type)
{
int ret;
return(0);
}
-void ssl3_send_alert(s,level,desc)
-SSL *s;
-int level;
-int desc;
+void ssl3_send_alert(SSL *s, int level, int desc)
{
/* Map tls/ssl alert value to correct one */
desc=s->method->ssl3_enc->alert_value(desc);
* some time in the future */
}
-int ssl3_dispatch_alert(s)
-SSL *s;
+int ssl3_dispatch_alert(SSL *s)
{
int i,j;
void (*cb)()=NULL;
#endif
-static SSL_METHOD *ssl3_get_server_method(ver)
-int ver;
+static SSL_METHOD *ssl3_get_server_method(int ver)
{
if (ver == SSL3_VERSION)
return(SSLv3_server_method());
return(NULL);
}
-SSL_METHOD *SSLv3_server_method()
+SSL_METHOD *SSLv3_server_method(void)
{
static int init=1;
static SSL_METHOD SSLv3_server_data;
return(&SSLv3_server_data);
}
-int ssl3_accept(s)
-SSL *s;
+int ssl3_accept(SSL *s)
{
BUF_MEM *buf;
unsigned long l,Time=time(NULL);
return(ret);
}
-static int ssl3_send_hello_request(s)
-SSL *s;
+static int ssl3_send_hello_request(SSL *s)
{
unsigned char *p;
return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
}
-static int ssl3_get_client_hello(s)
-SSL *s;
+static int ssl3_get_client_hello(SSL *s)
{
int i,j,ok,al,ret= -1;
long n;
return(ret);
}
-static int ssl3_send_server_hello(s)
-SSL *s;
+static int ssl3_send_server_hello(SSL *s)
{
unsigned char *buf;
unsigned char *p,*d;
return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
}
-static int ssl3_send_server_done(s)
-SSL *s;
+static int ssl3_send_server_done(SSL *s)
{
unsigned char *p;
return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
}
-static int ssl3_send_server_key_exchange(s)
-SSL *s;
+static int ssl3_send_server_key_exchange(SSL *s)
{
#ifndef NO_RSA
unsigned char *q;
return(-1);
}
-static int ssl3_send_certificate_request(s)
-SSL *s;
+static int ssl3_send_certificate_request(SSL *s)
{
unsigned char *p,*d;
int i,j,nl,off,n;
return(-1);
}
-static int ssl3_get_client_key_exchange(s)
-SSL *s;
+static int ssl3_get_client_key_exchange(SSL *s)
{
int i,al,ok;
long n;
return(-1);
}
-static int ssl3_get_cert_verify(s)
-SSL *s;
+static int ssl3_get_cert_verify(SSL *s)
{
EVP_PKEY *pkey=NULL;
unsigned char *p;
return(ret);
}
-static int ssl3_get_client_certificate(s)
-SSL *s;
+static int ssl3_get_client_certificate(SSL *s)
{
int i,ok,al,ret= -1;
X509 *x=NULL;
return(ret);
}
-int ssl3_send_server_certificate(s)
-SSL *s;
+int ssl3_send_server_certificate(SSL *s)
{
unsigned long l;
X509 *x;
#include "lhash.h"
#include "ssl_locl.h"
-int SSL_library_init()
+int SSL_library_init(void)
{
#ifndef NO_DES
EVP_add_cipher(EVP_des_cbc());
* SSLerr(SSL_F_D2I_SSL_SESSION,SSL_R_UNSUPPORTED_CIPHER);
*/
-int i2d_SSL_SESSION(in,pp)
-SSL_SESSION *in;
-unsigned char **pp;
+int i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp)
{
#define LSIZE2 (sizeof(long)*2)
int v1=0,v2=0,v3=0,v4=0;
M_ASN1_I2D_finish();
}
-SSL_SESSION *d2i_SSL_SESSION(a,pp,length)
-SSL_SESSION **a;
-unsigned char **pp;
-long length;
+SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, unsigned char **pp,
+ long length)
{
int version,ssl_version=0,i;
long id;
#include "pem.h"
#include "ssl_locl.h"
-int SSL_get_ex_data_X509_STORE_CTX_idx()
+int SSL_get_ex_data_X509_STORE_CTX_idx(void)
{
static int ssl_x509_store_ctx_idx= -1;
return(ssl_x509_store_ctx_idx);
}
-CERT *ssl_cert_new()
+CERT *ssl_cert_new(void)
{
CERT *ret;
return(i);
}
-static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list,
- STACK_OF(X509_NAME) *list)
+static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list,STACK_OF(X509_NAME) *list)
{
if (*ca_list != NULL)
sk_X509_NAME_pop_free(*ca_list,X509_NAME_free);
static int init_ciphers=1;
static void load_ciphers();
-static int cmp_by_name(a,b)
-SSL_CIPHER **a,**b;
+static int cmp_by_name(SSL_CIPHER **a, SSL_CIPHER **b)
{
return(strcmp((*a)->name,(*b)->name));
}
-static void load_ciphers()
+static void load_ciphers(void)
{
init_ciphers=0;
ssl_cipher_methods[SSL_ENC_DES_IDX]=
EVP_get_digestbyname(SN_sha1);
}
-int ssl_cipher_get_evp(s,enc,md,comp)
-SSL_SESSION *s;
-const EVP_CIPHER **enc;
-const EVP_MD **md;
-SSL_COMP **comp;
+int ssl_cipher_get_evp(SSL_SESSION *s, const EVP_CIPHER **enc,
+ const EVP_MD **md, SSL_COMP **comp)
{
int i;
SSL_CIPHER *c;
#define ITEM_SEP(a) \
(((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))
-static void ll_append_tail(head,curr,tail)
-CIPHER_ORDER **head,*curr,**tail;
+static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
+ CIPHER_ORDER **tail)
{
if (curr == *tail) return;
if (curr == *head)
*tail=curr;
}
-STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(ssl_method,cipher_list,
- cipher_list_by_id,str)
-SSL_METHOD *ssl_method;
-STACK_OF(SSL_CIPHER) **cipher_list,**cipher_list_by_id;
-char *str;
+STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_METHOD *ssl_method,
+ STACK_OF(SSL_CIPHER) **cipher_list,
+ STACK_OF(SSL_CIPHER) **cipher_list_by_id,
+ char *str)
{
SSL_CIPHER *c;
char *l;
return(ok);
}
-char *SSL_CIPHER_description(cipher,buf,len)
-SSL_CIPHER *cipher;
-char *buf;
-int len;
+char *SSL_CIPHER_description(SSL_CIPHER *cipher, char *buf, int len)
{
int is_export,pkl,kl;
char *ver,*exp;
return(buf);
}
-char *SSL_CIPHER_get_version(c)
-SSL_CIPHER *c;
+char *SSL_CIPHER_get_version(SSL_CIPHER *c)
{
int i;
}
/* return the actual cipher being used */
-const char *SSL_CIPHER_get_name(c)
-SSL_CIPHER *c;
+const char *SSL_CIPHER_get_name(SSL_CIPHER *c)
{
if (c != NULL)
return(c->name);
}
/* number of bits for symetric cipher */
-int SSL_CIPHER_get_bits(c,alg_bits)
-SSL_CIPHER *c;
-int *alg_bits;
+int SSL_CIPHER_get_bits(SSL_CIPHER *c, int *alg_bits)
{
int ret=0,a=0;
const EVP_CIPHER *enc;
return(ret);
}
-SSL_COMP *ssl3_comp_find(sk,n)
-STACK_OF(SSL_COMP) *sk;
-int n;
+SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n)
{
SSL_COMP *ctmp;
int i,nn;
return((*a)->id-(*b)->id);
}
-STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods()
+STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
{
return(ssl_comp_methods);
}
-int SSL_COMP_add_compression_method(id,cm)
-int id;
-COMP_METHOD *cm;
+int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm)
{
SSL_COMP *comp;
STACK_OF(SSL_COMP) *sk;
#endif
-void ERR_load_SSL_strings()
+void ERR_load_SSL_strings(void)
{
static int init=1;
#include "err.h"
#include "ssl.h"
-void SSL_load_error_strings()
+void SSL_load_error_strings(void)
{
#ifndef NO_ERR
ERR_load_crypto_strings();
ssl->info_callback=cb;
}
-void (*SSL_get_info_callback(SSL *ssl))()
+void (*SSL_get_info_callback(SSL *ssl))(void)
{
return((void (*)())ssl->info_callback);
}
static int ssl_set_pkey();
#endif
-int SSL_use_certificate(ssl, x)
-SSL *ssl;
-X509 *x;
+int SSL_use_certificate(SSL *ssl, X509 *x)
{
if (x == NULL)
{
}
#ifndef NO_STDIO
-int SSL_use_certificate_file(ssl, file, type)
-SSL *ssl;
-char *file;
-int type;
+int SSL_use_certificate_file(SSL *ssl, char *file, int type)
{
int j;
BIO *in;
}
#endif
-int SSL_use_certificate_ASN1(ssl, d,len)
-SSL *ssl;
-unsigned char *d;
-int len;
+int SSL_use_certificate_ASN1(SSL *ssl, unsigned char *d, int len)
{
X509 *x;
int ret;
}
#ifndef NO_RSA
-int SSL_use_RSAPrivateKey(ssl, rsa)
-SSL *ssl;
-RSA *rsa;
+int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa)
{
EVP_PKEY *pkey;
int ret;
}
#endif
-static int ssl_set_pkey(c,pkey)
-CERT *c;
-EVP_PKEY *pkey;
+static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey)
{
int i,ok=0,bad=0;
#ifndef NO_RSA
#ifndef NO_STDIO
-int SSL_use_RSAPrivateKey_file(ssl, file, type)
-SSL *ssl;
-char *file;
-int type;
+int SSL_use_RSAPrivateKey_file(SSL *ssl, char *file, int type)
{
int j,ret=0;
BIO *in;
}
#endif
-int SSL_use_RSAPrivateKey_ASN1(ssl,d,len)
-SSL *ssl;
-unsigned char *d;
-long len;
+int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, unsigned char *d, long len)
{
int ret;
unsigned char *p;
}
#endif /* !NO_RSA */
-int SSL_use_PrivateKey(ssl, pkey)
-SSL *ssl;
-EVP_PKEY *pkey;
+int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey)
{
int ret;
}
#ifndef NO_STDIO
-int SSL_use_PrivateKey_file(ssl, file, type)
-SSL *ssl;
-char *file;
-int type;
+int SSL_use_PrivateKey_file(SSL *ssl, char *file, int type)
{
int j,ret=0;
BIO *in;
}
#endif
-int SSL_use_PrivateKey_ASN1(type,ssl,d,len)
-int type;
-SSL *ssl;
-unsigned char *d;
-long len;
+int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, unsigned char *d, long len)
{
int ret;
unsigned char *p;
return(ret);
}
-int SSL_CTX_use_certificate(ctx, x)
-SSL_CTX *ctx;
-X509 *x;
+int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x)
{
if (x == NULL)
{
return(ssl_set_cert(ctx->default_cert,x));
}
-static int ssl_set_cert(c,x)
-CERT *c;
-X509 *x;
+static int ssl_set_cert(CERT *c, X509 *x)
{
EVP_PKEY *pkey;
int i,ok=0,bad=0;
}
#ifndef NO_STDIO
-int SSL_CTX_use_certificate_file(ctx, file, type)
-SSL_CTX *ctx;
-char *file;
-int type;
+int SSL_CTX_use_certificate_file(SSL_CTX *ctx, char *file, int type)
{
int j;
BIO *in;
}
#endif
-int SSL_CTX_use_certificate_ASN1(ctx, len, d)
-SSL_CTX *ctx;
-int len;
-unsigned char *d;
+int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, unsigned char *d)
{
X509 *x;
int ret;
}
#ifndef NO_RSA
-int SSL_CTX_use_RSAPrivateKey(ctx, rsa)
-SSL_CTX *ctx;
-RSA *rsa;
+int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa)
{
int ret;
EVP_PKEY *pkey;
}
#ifndef NO_STDIO
-int SSL_CTX_use_RSAPrivateKey_file(ctx, file, type)
-SSL_CTX *ctx;
-char *file;
-int type;
+int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, char *file, int type)
{
int j,ret=0;
BIO *in;
}
#endif
-int SSL_CTX_use_RSAPrivateKey_ASN1(ctx,d,len)
-SSL_CTX *ctx;
-unsigned char *d;
-long len;
+int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, unsigned char *d, long len)
{
int ret;
unsigned char *p;
}
#endif /* !NO_RSA */
-int SSL_CTX_use_PrivateKey(ctx, pkey)
-SSL_CTX *ctx;
-EVP_PKEY *pkey;
+int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey)
{
if (pkey == NULL)
{
}
#ifndef NO_STDIO
-int SSL_CTX_use_PrivateKey_file(ctx, file, type)
-SSL_CTX *ctx;
-char *file;
-int type;
+int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, char *file, int type)
{
int j,ret=0;
BIO *in;
}
#endif
-int SSL_CTX_use_PrivateKey_ASN1(type,ctx,d,len)
-int type;
-SSL_CTX *ctx;
-unsigned char *d;
-long len;
+int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx, unsigned char *d,
+ long len)
{
int ret;
unsigned char *p;
static int ssl_session_num=0;
static STACK *ssl_session_meth=NULL;
-SSL_SESSION *SSL_get_session(ssl)
-SSL *ssl;
+SSL_SESSION *SSL_get_session(SSL *ssl)
{
return(ssl->session);
}
-int SSL_SESSION_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
+int SSL_SESSION_get_ex_new_index(long argl, char *argp, int (*new_func)(),
+ int (*dup_func)(), void (*free_func)())
{
ssl_session_num++;
return(CRYPTO_get_ex_new_index(ssl_session_num-1,
argl,argp,new_func,dup_func,free_func));
}
-int SSL_SESSION_set_ex_data(s,idx,arg)
-SSL_SESSION *s;
-int idx;
-void *arg;
+int SSL_SESSION_set_ex_data(SSL_SESSION *s, int idx, void *arg)
{
return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
}
-void *SSL_SESSION_get_ex_data(s,idx)
-SSL_SESSION *s;
-int idx;
+void *SSL_SESSION_get_ex_data(SSL_SESSION *s, int idx)
{
return(CRYPTO_get_ex_data(&s->ex_data,idx));
}
-SSL_SESSION *SSL_SESSION_new()
+SSL_SESSION *SSL_SESSION_new(void)
{
SSL_SESSION *ss;
return(ss);
}
-int ssl_get_new_session(s, session)
-SSL *s;
-int session;
+int ssl_get_new_session(SSL *s, int session)
{
SSL_SESSION *ss=NULL;
return(1);
}
-int ssl_get_prev_session(s,session_id,len)
-SSL *s;
-unsigned char *session_id;
-int len;
+int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len)
{
SSL_SESSION *ret=NULL,data;
int copy=1;
return(1);
}
-int SSL_CTX_add_session(ctx,c)
-SSL_CTX *ctx;
-SSL_SESSION *c;
+int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
{
int ret=0;
SSL_SESSION *s;
return(ret);
}
-int SSL_CTX_remove_session(ctx,c)
-SSL_CTX *ctx;
-SSL_SESSION *c;
+int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
{
SSL_SESSION *r;
int ret=0;
return(ret);
}
-void SSL_SESSION_free(ss)
-SSL_SESSION *ss;
+void SSL_SESSION_free(SSL_SESSION *ss)
{
int i;
Free(ss);
}
-int SSL_set_session(s, session)
-SSL *s;
-SSL_SESSION *session;
+int SSL_set_session(SSL *s, SSL_SESSION *session)
{
int ret=0;
SSL_METHOD *meth;
return(ret);
}
-long SSL_SESSION_set_timeout(s,t)
-SSL_SESSION *s;
-long t;
+long SSL_SESSION_set_timeout(SSL_SESSION *s, long t)
{
if (s == NULL) return(0);
s->timeout=t;
return(1);
}
-long SSL_SESSION_get_timeout(s)
-SSL_SESSION *s;
+long SSL_SESSION_get_timeout(SSL_SESSION *s)
{
if (s == NULL) return(0);
return(s->timeout);
}
-long SSL_SESSION_get_time(s)
-SSL_SESSION *s;
+long SSL_SESSION_get_time(SSL_SESSION *s)
{
if (s == NULL) return(0);
return(s->time);
}
-long SSL_SESSION_set_time(s,t)
-SSL_SESSION *s;
-long t;
+long SSL_SESSION_set_time(SSL_SESSION *s, long t)
{
if (s == NULL) return(0);
s->time=t;
return(t);
}
-long SSL_CTX_set_timeout(s,t)
-SSL_CTX *s;
-long t;
+long SSL_CTX_set_timeout(SSL_CTX *s, long t)
{
long l;
if (s == NULL) return(0);
return(l);
}
-long SSL_CTX_get_timeout(s)
-SSL_CTX *s;
+long SSL_CTX_get_timeout(SSL_CTX *s)
{
if (s == NULL) return(0);
return(s->session_timeout);
LHASH *cache;
} TIMEOUT_PARAM;
-static void timeout(s,p)
-SSL_SESSION *s;
-TIMEOUT_PARAM *p;
+static void timeout(SSL_SESSION *s, TIMEOUT_PARAM *p)
{
if ((p->time == 0) || (p->time > (s->time+s->timeout))) /* timeout */
{
}
}
-void SSL_CTX_flush_sessions(s,t)
-SSL_CTX *s;
-long t;
+void SSL_CTX_flush_sessions(SSL_CTX *s, long t)
{
unsigned long i;
TIMEOUT_PARAM tp;
CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
}
-int ssl_clear_bad_session(s)
-SSL *s;
+int ssl_clear_bad_session(SSL *s)
{
if ( (s->session != NULL) &&
!(s->shutdown & SSL_SENT_SHUTDOWN) &&
}
/* locked by SSL_CTX in the calling function */
-static void SSL_SESSION_list_remove(ctx,s)
-SSL_CTX *ctx;
-SSL_SESSION *s;
+static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s)
{
if ((s->next == NULL) || (s->prev == NULL)) return;
s->prev=s->next=NULL;
}
-static void SSL_SESSION_list_add(ctx,s)
-SSL_CTX *ctx;
-SSL_SESSION *s;
+static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
{
if ((s->next != NULL) && (s->prev != NULL))
SSL_SESSION_list_remove(ctx,s);
#include <stdio.h>
#include "ssl_locl.h"
-char *SSL_state_string_long(s)
-SSL *s;
+char *SSL_state_string_long(SSL *s)
{
char *str;
return(str);
}
-char *SSL_rstate_string_long(s)
-SSL *s;
+char *SSL_rstate_string_long(SSL *s)
{
char *str;
return(str);
}
-char *SSL_state_string(s)
-SSL *s;
+char *SSL_state_string(SSL *s)
{
char *str;
return(str);
}
-char *SSL_alert_type_string_long(value)
-int value;
+char *SSL_alert_type_string_long(int value)
{
value>>=8;
if (value == SSL3_AL_WARNING)
return("unknown");
}
-char *SSL_alert_type_string(value)
-int value;
+char *SSL_alert_type_string(int value)
{
value>>=8;
if (value == SSL3_AL_WARNING)
return("U");
}
-char *SSL_alert_desc_string(value)
-int value;
+char *SSL_alert_desc_string(int value)
{
char *str;
return(str);
}
-char *SSL_alert_desc_string_long(value)
-int value;
+char *SSL_alert_desc_string_long(int value)
{
char *str;
return(str);
}
-char *SSL_rstate_string(s)
-SSL *s;
+char *SSL_rstate_string(SSL *s)
{
char *str;
#include "ssl_locl.h"
#ifndef NO_FP_API
-int SSL_SESSION_print_fp(fp, x)
-FILE *fp;
-SSL_SESSION *x;
+int SSL_SESSION_print_fp(FILE *fp, SSL_SESSION *x)
{
BIO *b;
int ret;
}
#endif
-int SSL_SESSION_print(bp,x)
-BIO *bp;
-SSL_SESSION *x;
+int SSL_SESSION_print(BIO *bp, SSL_SESSION *x)
{
unsigned int i;
char str[128],*s;
int doit();
#endif
-static void sv_usage()
+static void sv_usage(void)
{
fprintf(stderr,"usage: ssltest [args ...]\n");
fprintf(stderr,"\n");
fprintf(stderr," -cipher arg - The cipher list\n");
}
-int main(argc, argv)
-int argc;
-char *argv[];
+int main(int argc, char *argv[])
{
char *CApath=NULL,*CAfile=NULL;
int badop=0;
#define C_DONE 1
#define S_DONE 2
-int doit(s_ssl,c_ssl,count)
-SSL *s_ssl,*c_ssl;
-long count;
+int doit(SSL *s_ssl, SSL *c_ssl, long count)
{
MS_STATIC char cbuf[1024*8],sbuf[1024*8];
long cw_num=count,cr_num=count;
return(ret);
}
-int MS_CALLBACK verify_callback(ok, ctx)
-int ok;
-X509_STORE_CTX *ctx;
+int MS_CALLBACK verify_callback(int ok, X509_STORE_CTX *ctx)
{
char *s,buf[256];
0x02,
};
-static DH *get_dh512()
+static DH *get_dh512(void)
{
DH *dh=NULL;
}
#endif
-static RSA MS_CALLBACK *tmp_rsa_cb(s,export,keylength)
-SSL *s;
-int export;
-int keylength;
+static RSA MS_CALLBACK *tmp_rsa_cb(SSL *s, int export, int keylength)
{
static RSA *rsa_tmp=NULL;
static SSL_METHOD *tls1_get_client_method();
#endif
-static SSL_METHOD *tls1_get_client_method(ver)
-int ver;
+static SSL_METHOD *tls1_get_client_method(int ver)
{
if (ver == TLS1_VERSION)
return(TLSv1_client_method());
return(NULL);
}
-SSL_METHOD *TLSv1_client_method()
+SSL_METHOD *TLSv1_client_method(void)
{
static int init=1;
static SSL_METHOD TLSv1_client_data;
#include "hmac.h"
#include "ssl_locl.h"
-static void tls1_P_hash(md,sec,sec_len,seed,seed_len,out,olen)
-EVP_MD *md;
-unsigned char *sec;
-int sec_len;
-unsigned char *seed;
-int seed_len;
-unsigned char *out;
-int olen;
+static void tls1_P_hash(EVP_MD *md, unsigned char *sec, int sec_len,
+ unsigned char *seed, int seed_len, unsigned char *out, int olen)
{
int chunk,n;
unsigned int j;
memset(A1,0,sizeof(A1));
}
-static void tls1_PRF(md5,sha1,label,label_len,sec,slen,out1,out2,olen)
-EVP_MD *md5;
-EVP_MD *sha1;
-unsigned char *label;
-int label_len;
-unsigned char *sec;
-int slen;
-unsigned char *out1;
-unsigned char *out2;
-int olen;
+static void tls1_PRF(EVP_MD *md5, EVP_MD *sha1, unsigned char *label,
+ int label_len, unsigned char *sec, int slen, unsigned char *out1,
+ unsigned char *out2, int olen)
{
int len,i;
unsigned char *S1,*S2;
out1[i]^=out2[i];
}
-static void tls1_generate_key_block(s,km,tmp,num)
-SSL *s;
-unsigned char *km,*tmp;
-int num;
+static void tls1_generate_key_block(SSL *s, unsigned char *km,
+ unsigned char *tmp, int num)
{
unsigned char *p;
unsigned char buf[SSL3_RANDOM_SIZE*2+
km,tmp,num);
}
-int tls1_change_cipher_state(s,which)
-SSL *s;
-int which;
+int tls1_change_cipher_state(SSL *s, int which)
{
unsigned char *p,*key_block,*mac_secret;
unsigned char *exp_label,buf[TLS_MD_MAX_CONST_SIZE+
return(0);
}
-int tls1_setup_key_block(s)
-SSL *s;
+int tls1_setup_key_block(SSL *s)
{
unsigned char *p1,*p2;
const EVP_CIPHER *c;
return(0);
}
-int tls1_enc(s,send)
-SSL *s;
-int send;
+int tls1_enc(SSL *s, int send)
{
SSL3_RECORD *rec;
EVP_CIPHER_CTX *ds;
return(1);
}
-int tls1_cert_verify_mac(s,in_ctx,out)
-SSL *s;
-EVP_MD_CTX *in_ctx;
-unsigned char *out;
+int tls1_cert_verify_mac(SSL *s, EVP_MD_CTX *in_ctx, unsigned char *out)
{
unsigned int ret;
EVP_MD_CTX ctx;
return((int)ret);
}
-int tls1_final_finish_mac(s,in1_ctx,in2_ctx,str,slen,out)
-SSL *s;
-EVP_MD_CTX *in1_ctx,*in2_ctx;
-unsigned char *str;
-int slen;
-unsigned char *out;
+int tls1_final_finish_mac(SSL *s, EVP_MD_CTX *in1_ctx, EVP_MD_CTX *in2_ctx,
+ unsigned char *str, int slen, unsigned char *out)
{
unsigned int i;
EVP_MD_CTX ctx;
return((int)12);
}
-int tls1_mac(ssl,md,send)
-SSL *ssl;
-unsigned char *md;
-int send;
+int tls1_mac(SSL *ssl, unsigned char *md, int send)
{
SSL3_RECORD *rec;
unsigned char *mac_sec,*seq;
return(md_size);
}
-int tls1_generate_master_secret(s,out,p,len)
-SSL *s;
-unsigned char *out;
-unsigned char *p;
-int len;
+int tls1_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
+ int len)
{
unsigned char buf[SSL3_RANDOM_SIZE*2+TLS_MD_MASTER_SECRET_CONST_SIZE];
unsigned char buff[SSL_MAX_MASTER_KEY_LENGTH];
return(SSL3_MASTER_SECRET_SIZE);
}
-int tls1_alert_code(code)
-int code;
+int tls1_alert_code(int code)
{
switch (code)
{
&TLSv1_enc_data,
};
-static long tls1_default_timeout()
+static long tls1_default_timeout(void)
{
/* 2 hours, the 24 hours mentioned in the TLSv1 spec
* is way too long for http, the cache would over fill */
return(60*60*2);
}
-SSL_METHOD *tlsv1_base_method()
+SSL_METHOD *tlsv1_base_method(void)
{
return(&TLSv1_data);
}
-int tls1_new(s)
-SSL *s;
+int tls1_new(SSL *s)
{
if (!ssl3_new(s)) return(0);
s->method->ssl_clear(s);
return(1);
}
-void tls1_free(s)
-SSL *s;
+void tls1_free(SSL *s)
{
ssl3_free(s);
}
-void tls1_clear(s)
-SSL *s;
+void tls1_clear(SSL *s)
{
ssl3_clear(s);
s->version=TLS1_VERSION;
}
#if 0
-long tls1_ctrl(s,cmd,larg,parg)
-SSL *s;
-int cmd;
-long larg;
-char *parg;
+long tls1_ctrl(SSL *s, int cmd, long larg, char *parg)
{
return(0);
}
static SSL_METHOD *tls1_get_method();
#endif
-static SSL_METHOD *tls1_get_method(ver)
-int ver;
+static SSL_METHOD *tls1_get_method(int ver)
{
if (ver == TLS1_VERSION)
return(TLSv1_method());
return(NULL);
}
-SSL_METHOD *TLSv1_method()
+SSL_METHOD *TLSv1_method(void)
{
static int init=1;
static SSL_METHOD TLSv1_data;
static SSL_METHOD *tls1_get_server_method();
#endif
-static SSL_METHOD *tls1_get_server_method(ver)
-int ver;
+static SSL_METHOD *tls1_get_server_method(int ver)
{
if (ver == TLS1_VERSION)
return(TLSv1_server_method());
return(NULL);
}
-SSL_METHOD *TLSv1_server_method()
+SSL_METHOD *TLSv1_server_method(void)
{
static int init=1;
static SSL_METHOD TLSv1_server_data;