From: Ken Raeburn Date: Tue, 3 Sep 2002 01:13:48 +0000 (+0000) Subject: protoize X-Git-Tag: krb5-1.3-alpha1~437 X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=4b4c9bcc27e33479ae288fa7ff1fb4924b06eb73;p=krb5.git protoize git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@14812 dc483132-0cff-0310-8789-dd5450dbe970 --- diff --git a/src/lib/krb5/krb/ChangeLog b/src/lib/krb5/krb/ChangeLog index 782e56a04..479378d59 100644 --- a/src/lib/krb5/krb/ChangeLog +++ b/src/lib/krb5/krb/ChangeLog @@ -1,3 +1,29 @@ +2002-09-02 Ken Raeburn + + * addr_comp.c, addr_order.c, addr_srch.c, appdefault.c, + auth_con.c, bld_princ.c, chpw.c, cleanup.h, conv_princ.c, + copy_addrs.c, copy_athctr.c, copy_auth.c, copy_cksum.c, + copy_creds.c, copy_data.c, copy_key.c, copy_princ.c, copy_tick.c, + cp_key_cnt.c, decode_kdc.c, decrypt_tk.c, enc_helper.c, + encode_kdc.c, encrypt_tk.c, free_rtree.c, fwd_tgt.c, gc_frm_kdc.c, + gc_via_tkt.c, gen_seqnum.c, gen_subkey.c, get_creds.c, + get_in_tkt.c, gic_keytab.c, gic_opt.c, gic_pwd.c, in_tkt_ktb.c, + in_tkt_pwd.c, in_tkt_sky.c, init_ctx.c, kdc_rep_dc.c, kfree.c, + mk_cred.c, mk_error.c, mk_priv.c, mk_rep.c, mk_req.c, + mk_req_ext.c, mk_safe.c, parse.c, pr_to_salt.c, preauth.c, + preauth2.c, princ_comp.c, rd_cred.c, rd_error.c, rd_priv.c, + rd_rep.c, rd_req.c, rd_req_dec.c, rd_safe.c, recvauth.c, + send_tgs.c, sendauth.c, ser_actx.c, ser_adata.c, ser_addr.c, + ser_auth.c, ser_cksum.c, ser_ctx.c, ser_key.c, ser_princ.c, + serialize.c, set_realm.c, srv_rcache.c, str_conv.c, t_deltat.c, + t_kerb.c, t_ser.c, t_walk_rtree.c, tgtname.c, unparse.c, + valid_times.c, vfy_increds.c, vic_opt.c, walk_rtree.c, + x-deltat.y: Use prototype style function definitions. + * deltat.c: Regenerated. + * bld_princ.c: Include stdarg.h before k5-int.h. + * cleanup.h (struct cleanup): Include prototype for function + pointer field 'func'. + 2002-08-29 Ken Raeburn * Makefile.in: Revert $(S)=>/ change, for Windows support. diff --git a/src/lib/krb5/krb/addr_comp.c b/src/lib/krb5/krb/addr_comp.c index 22a99e217..16ab03bbf 100644 --- a/src/lib/krb5/krb/addr_comp.c +++ b/src/lib/krb5/krb/addr_comp.c @@ -33,10 +33,7 @@ * If the two addresses are the same, return TRUE, else return FALSE */ krb5_boolean KRB5_CALLCONV -krb5_address_compare(context, addr1, addr2) - krb5_context context; - const krb5_address *addr1; - const krb5_address *addr2; +krb5_address_compare(krb5_context context, const krb5_address *addr1, const krb5_address *addr2) { if (addr1->addrtype != addr2->addrtype) return(FALSE); diff --git a/src/lib/krb5/krb/addr_order.c b/src/lib/krb5/krb/addr_order.c index 07618dd0d..2f01e1fbc 100644 --- a/src/lib/krb5/krb/addr_order.c +++ b/src/lib/krb5/krb/addr_order.c @@ -38,10 +38,7 @@ * < 0 if first is less than 2nd, > 0 if first is greater than 2nd. */ int KRB5_CALLCONV -krb5_address_order(context, addr1, addr2) - krb5_context context; - const krb5_address *addr1; - const krb5_address *addr2; +krb5_address_order(krb5_context context, const krb5_address *addr1, const krb5_address *addr2) { int dir; register int i; diff --git a/src/lib/krb5/krb/addr_srch.c b/src/lib/krb5/krb/addr_srch.c index 75da7d21d..efab59f8f 100644 --- a/src/lib/krb5/krb/addr_srch.c +++ b/src/lib/krb5/krb/addr_srch.c @@ -34,10 +34,7 @@ * if not listed, return FALSE */ krb5_boolean -krb5_address_search(context, addr, addrlist) - krb5_context context; - const krb5_address *addr; - krb5_address * const * addrlist; +krb5_address_search(krb5_context context, const krb5_address *addr, krb5_address *const *addrlist) { if (!addrlist) return TRUE; diff --git a/src/lib/krb5/krb/appdefault.c b/src/lib/krb5/krb/appdefault.c index 3f9216228..35b6eb418 100644 --- a/src/lib/krb5/krb/appdefault.c +++ b/src/lib/krb5/krb/appdefault.c @@ -20,8 +20,7 @@ static const char *conf_no[] = { 0, }; -static int conf_boolean(s) - char *s; +static int conf_boolean(char *s) { const char **p; for(p=conf_yes; *p; p++) { @@ -36,12 +35,7 @@ static int conf_boolean(s) return 0; } -static krb5_error_code appdefault_get(context, appname, realm, option, - ret_value) - krb5_context context; - const char *appname, *option; - const krb5_data *realm; - char **ret_value; +static krb5_error_code appdefault_get(krb5_context context, const char *appname, const krb5_data *realm, const char *option, char **ret_value) { profile_t profile; const char *names[5]; @@ -142,13 +136,7 @@ goodbye: } void KRB5_CALLCONV -krb5_appdefault_boolean(context, appname, realm, option, - default_value, ret_value) - krb5_context context; - const char *appname, *option; - const krb5_data *realm; - int default_value; - int *ret_value; +krb5_appdefault_boolean(krb5_context context, const char *appname, const krb5_data *realm, const char *option, int default_value, int *ret_value) { char *string = NULL; krb5_error_code retval; @@ -163,13 +151,8 @@ krb5_appdefault_boolean(context, appname, realm, option, } void KRB5_CALLCONV -krb5_appdefault_string(context, appname, realm, option, default_value, - ret_value) - krb5_context context; - const char *appname, *option, *default_value; - char **ret_value; - const krb5_data *realm; - { +krb5_appdefault_string(krb5_context context, const char *appname, const krb5_data *realm, const char *option, const char *default_value, char **ret_value) +{ krb5_error_code retval; char *string; diff --git a/src/lib/krb5/krb/auth_con.c b/src/lib/krb5/krb/auth_con.c index a27b552a5..7c60785ad 100644 --- a/src/lib/krb5/krb/auth_con.c +++ b/src/lib/krb5/krb/auth_con.c @@ -2,10 +2,7 @@ #include "auth_con.h" static krb5_error_code -actx_copy_addr(context, inad, outad) - krb5_context context; - const krb5_address *inad; - krb5_address **outad; +actx_copy_addr(krb5_context context, const krb5_address *inad, krb5_address **outad) { krb5_address *tmpad; @@ -26,9 +23,7 @@ actx_copy_addr(context, inad, outad) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_init(context, auth_context) - krb5_context context; - krb5_auth_context * auth_context; +krb5_auth_con_init(krb5_context context, krb5_auth_context *auth_context) { *auth_context = (krb5_auth_context)malloc(sizeof(struct _krb5_auth_context)); @@ -48,9 +43,7 @@ krb5_auth_con_init(context, auth_context) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_free(context, auth_context) - krb5_context context; - krb5_auth_context auth_context; +krb5_auth_con_free(krb5_context context, krb5_auth_context auth_context) { if (auth_context->local_addr) krb5_free_address(context, auth_context->local_addr); @@ -77,11 +70,7 @@ krb5_auth_con_free(context, auth_context) } krb5_error_code -krb5_auth_con_setaddrs(context, auth_context, local_addr, remote_addr) - krb5_context context; - krb5_auth_context auth_context; - krb5_address * local_addr; - krb5_address * remote_addr; +krb5_auth_con_setaddrs(krb5_context context, krb5_auth_context auth_context, krb5_address *local_addr, krb5_address *remote_addr) { krb5_error_code retval; @@ -110,11 +99,7 @@ krb5_auth_con_setaddrs(context, auth_context, local_addr, remote_addr) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getaddrs(context, auth_context, local_addr, remote_addr) - krb5_context context; - krb5_auth_context auth_context; - krb5_address ** local_addr; - krb5_address ** remote_addr; +krb5_auth_con_getaddrs(krb5_context context, krb5_auth_context auth_context, krb5_address **local_addr, krb5_address **remote_addr) { krb5_error_code retval; @@ -133,11 +118,7 @@ krb5_auth_con_getaddrs(context, auth_context, local_addr, remote_addr) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_setports(context, auth_context, local_port, remote_port) - krb5_context context; - krb5_auth_context auth_context; - krb5_address * local_port; - krb5_address * remote_port; +krb5_auth_con_setports(krb5_context context, krb5_auth_context auth_context, krb5_address *local_port, krb5_address *remote_port) { krb5_error_code retval; @@ -174,10 +155,7 @@ krb5_auth_con_setports(context, auth_context, local_port, remote_port) * with the session key sent by the client. */ krb5_error_code KRB5_CALLCONV -krb5_auth_con_setuseruserkey(context, auth_context, keyblock) - krb5_context context; - krb5_auth_context auth_context; - krb5_keyblock * keyblock; +krb5_auth_con_setuseruserkey(krb5_context context, krb5_auth_context auth_context, krb5_keyblock *keyblock) { if (auth_context->keyblock) krb5_free_keyblock(context, auth_context->keyblock); @@ -185,10 +163,7 @@ krb5_auth_con_setuseruserkey(context, auth_context, keyblock) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getkey(context, auth_context, keyblock) - krb5_context context; - krb5_auth_context auth_context; - krb5_keyblock ** keyblock; +krb5_auth_con_getkey(krb5_context context, krb5_auth_context auth_context, krb5_keyblock **keyblock) { if (auth_context->keyblock) return krb5_copy_keyblock(context, auth_context->keyblock, keyblock); @@ -197,10 +172,7 @@ krb5_auth_con_getkey(context, auth_context, keyblock) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getlocalsubkey(context, auth_context, keyblock) - krb5_context context; - krb5_auth_context auth_context; - krb5_keyblock ** keyblock; +krb5_auth_con_getlocalsubkey(krb5_context context, krb5_auth_context auth_context, krb5_keyblock **keyblock) { if (auth_context->local_subkey) return krb5_copy_keyblock(context,auth_context->local_subkey,keyblock); @@ -209,10 +181,7 @@ krb5_auth_con_getlocalsubkey(context, auth_context, keyblock) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getremotesubkey(context, auth_context, keyblock) - krb5_context context; - krb5_auth_context auth_context; - krb5_keyblock ** keyblock; +krb5_auth_con_getremotesubkey(krb5_context context, krb5_auth_context auth_context, krb5_keyblock **keyblock) { if (auth_context->remote_subkey) return krb5_copy_keyblock(context,auth_context->remote_subkey,keyblock); @@ -221,59 +190,42 @@ krb5_auth_con_getremotesubkey(context, auth_context, keyblock) } krb5_error_code KRB5_CALLCONV -krb5_auth_con_set_req_cksumtype(context, auth_context, cksumtype) - krb5_context context; - krb5_auth_context auth_context; - krb5_cksumtype cksumtype; +krb5_auth_con_set_req_cksumtype(krb5_context context, krb5_auth_context auth_context, krb5_cksumtype cksumtype) { auth_context->req_cksumtype = cksumtype; return 0; } krb5_error_code -krb5_auth_con_set_safe_cksumtype(context, auth_context, cksumtype) - krb5_context context; - krb5_auth_context auth_context; - krb5_cksumtype cksumtype; +krb5_auth_con_set_safe_cksumtype(krb5_context context, krb5_auth_context auth_context, krb5_cksumtype cksumtype) { auth_context->safe_cksumtype = cksumtype; return 0; } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getlocalseqnumber(context, auth_context, seqnumber) - krb5_context context; - krb5_auth_context auth_context; - krb5_int32 * seqnumber; +krb5_auth_con_getlocalseqnumber(krb5_context context, krb5_auth_context auth_context, krb5_int32 *seqnumber) { *seqnumber = auth_context->local_seq_number; return 0; } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getauthenticator(context, auth_context, authenticator) - krb5_context context; - krb5_auth_context auth_context; - krb5_authenticator ** authenticator; +krb5_auth_con_getauthenticator(krb5_context context, krb5_auth_context auth_context, krb5_authenticator **authenticator) { return (krb5_copy_authenticator(context, auth_context->authentp, authenticator)); } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getremoteseqnumber(context, auth_context, seqnumber) - krb5_context context; - krb5_auth_context auth_context; - krb5_int32 * seqnumber; +krb5_auth_con_getremoteseqnumber(krb5_context context, krb5_auth_context auth_context, krb5_int32 *seqnumber) { *seqnumber = auth_context->remote_seq_number; return 0; } krb5_error_code KRB5_CALLCONV -krb5_auth_con_initivector(context, auth_context) - krb5_context context; - krb5_auth_context auth_context; +krb5_auth_con_initivector(krb5_context context, krb5_auth_context auth_context) { krb5_error_code ret; @@ -293,70 +245,49 @@ krb5_auth_con_initivector(context, auth_context) } krb5_error_code -krb5_auth_con_setivector(context, auth_context, ivector) - krb5_context context; - krb5_auth_context auth_context; - krb5_pointer ivector; +krb5_auth_con_setivector(krb5_context context, krb5_auth_context auth_context, krb5_pointer ivector) { auth_context->i_vector = ivector; return 0; } krb5_error_code -krb5_auth_con_getivector(context, auth_context, ivector) - krb5_context context; - krb5_auth_context auth_context; - krb5_pointer * ivector; +krb5_auth_con_getivector(krb5_context context, krb5_auth_context auth_context, krb5_pointer *ivector) { *ivector = auth_context->i_vector; return 0; } krb5_error_code KRB5_CALLCONV -krb5_auth_con_setflags(context, auth_context, flags) - krb5_context context; - krb5_auth_context auth_context; - krb5_int32 flags; +krb5_auth_con_setflags(krb5_context context, krb5_auth_context auth_context, krb5_int32 flags) { auth_context->auth_context_flags = flags; return 0; } krb5_error_code KRB5_CALLCONV -krb5_auth_con_getflags(context, auth_context, flags) - krb5_context context; - krb5_auth_context auth_context; - krb5_int32 * flags; +krb5_auth_con_getflags(krb5_context context, krb5_auth_context auth_context, krb5_int32 *flags) { *flags = auth_context->auth_context_flags; return 0; } krb5_error_code KRB5_CALLCONV -krb5_auth_con_setrcache(context, auth_context, rcache) - krb5_context context; - krb5_auth_context auth_context; - krb5_rcache rcache; +krb5_auth_con_setrcache(krb5_context context, krb5_auth_context auth_context, krb5_rcache rcache) { auth_context->rcache = rcache; return 0; } krb5_error_code -krb5_auth_con_getrcache(context, auth_context, rcache) - krb5_context context; - krb5_auth_context auth_context; - krb5_rcache * rcache; +krb5_auth_con_getrcache(krb5_context context, krb5_auth_context auth_context, krb5_rcache *rcache) { *rcache = auth_context->rcache; return 0; } krb5_error_code -krb5_auth_con_setpermetypes(context, auth_context, permetypes) - krb5_context context; - krb5_auth_context auth_context; - const krb5_enctype * permetypes; +krb5_auth_con_setpermetypes(krb5_context context, krb5_auth_context auth_context, const krb5_enctype *permetypes) { krb5_enctype * newpe; int i; @@ -380,10 +311,7 @@ krb5_auth_con_setpermetypes(context, auth_context, permetypes) } krb5_error_code -krb5_auth_con_getpermetypes(context, auth_context, permetypes) - krb5_context context; - krb5_auth_context auth_context; - krb5_enctype ** permetypes; +krb5_auth_con_getpermetypes(krb5_context context, krb5_auth_context auth_context, krb5_enctype **permetypes) { krb5_enctype * newpe; int i; diff --git a/src/lib/krb5/krb/bld_princ.c b/src/lib/krb5/krb/bld_princ.c index 516f15fdc..c6cb7af05 100644 --- a/src/lib/krb5/krb/bld_princ.c +++ b/src/lib/krb5/krb/bld_princ.c @@ -27,19 +27,12 @@ * Build a principal from a list of strings */ -/* Need for HAVE_STDARG_H */ -#include "k5-int.h" - #include +#include "k5-int.h" krb5_error_code KRB5_CALLCONV -krb5_build_principal_va(context, princ, rlen, realm, ap) - krb5_context context; - krb5_principal princ; - unsigned int rlen; - const char *realm; - va_list ap; +krb5_build_principal_va(krb5_context context, krb5_principal princ, unsigned int rlen, const char *realm, va_list ap) { register int i, count = 0; register char *next; diff --git a/src/lib/krb5/krb/chpw.c b/src/lib/krb5/krb/chpw.c index 5f147ca7b..bb2cfe9c7 100644 --- a/src/lib/krb5/krb/chpw.c +++ b/src/lib/krb5/krb/chpw.c @@ -5,12 +5,7 @@ #include "auth_con.h" krb5_error_code KRB5_CALLCONV -krb5_mk_chpw_req(context, auth_context, ap_req, passwd, packet) - krb5_context context; - krb5_auth_context auth_context; - krb5_data *ap_req; - char *passwd; - krb5_data *packet; +krb5_mk_chpw_req(krb5_context context, krb5_auth_context auth_context, krb5_data *ap_req, char *passwd, krb5_data *packet) { krb5_error_code ret = 0; krb5_data clearpw; @@ -72,12 +67,7 @@ cleanup: } krb5_error_code KRB5_CALLCONV -krb5_rd_chpw_rep(context, auth_context, packet, result_code, result_data) - krb5_context context; - krb5_auth_context auth_context; - krb5_data *packet; - int *result_code; - krb5_data *result_data; +krb5_rd_chpw_rep(krb5_context context, krb5_auth_context auth_context, krb5_data *packet, int *result_code, krb5_data *result_data) { char *ptr; int plen, vno; @@ -209,10 +199,7 @@ cleanup: } krb5_error_code KRB5_CALLCONV -krb5_chpw_result_code_string(context, result_code, code_string) - krb5_context context; - int result_code; - char **code_string; +krb5_chpw_result_code_string(krb5_context context, int result_code, char **code_string) { switch (result_code) { case KRB5_KPASSWD_MALFORMED: diff --git a/src/lib/krb5/krb/cleanup.h b/src/lib/krb5/krb/cleanup.h index 953649712..94b39f757 100644 --- a/src/lib/krb5/krb/cleanup.h +++ b/src/lib/krb5/krb/cleanup.h @@ -4,7 +4,7 @@ struct cleanup { void * arg; - void (*func)(); + void (*func)(void *); }; #define CLEANUP_INIT(x) \ diff --git a/src/lib/krb5/krb/conv_princ.c b/src/lib/krb5/krb/conv_princ.c index e6595817a..6eb157aca 100644 --- a/src/lib/krb5/krb/conv_princ.c +++ b/src/lib/krb5/krb/conv_princ.c @@ -128,9 +128,7 @@ static const struct krb_convert sconv_list[] = { * This falls in the "should have been in the ANSI C library" * category. :-) */ -static char *strnchr(s, c, n) - register char *s, c; - register int n; +static char *strnchr(register char *s, register char c, register int n) { if (n < 1) return 0; @@ -148,12 +146,8 @@ static char *strnchr(s, c, n) #define KRB5_INVALID_PRINCIPAL KRB5_LNAME_BADFORMAT krb5_error_code KRB5_CALLCONV -krb5_524_conv_principal(context, princ, name, inst, realm) - krb5_context context; - const krb5_principal princ; - char *name; - char *inst; - char *realm; +krb5_524_conv_principal(krb5_context context, const krb5_principal princ, + char *name, char *inst, char *realm) { const struct krb_convert *p; krb5_data *compo; @@ -251,12 +245,7 @@ krb5_524_conv_principal(context, princ, name, inst, realm) } krb5_error_code KRB5_CALLCONV -krb5_425_conv_principal(context, name, instance, realm, princ) - krb5_context context; - const char *name; - const char *instance; - const char *realm; - krb5_principal *princ; +krb5_425_conv_principal(krb5_context context, const char *name, const char *instance, const char *realm, krb5_principal *princ) { const struct krb_convert *p; char buf[256]; /* V4 instances are limited to 40 characters */ diff --git a/src/lib/krb5/krb/copy_addrs.c b/src/lib/krb5/krb/copy_addrs.c index 667da476c..0e9ee702c 100644 --- a/src/lib/krb5/krb/copy_addrs.c +++ b/src/lib/krb5/krb/copy_addrs.c @@ -30,10 +30,7 @@ #include "k5-int.h" krb5_error_code KRB5_CALLCONV -krb5_copy_addr(context, inad, outad) - krb5_context context; - const krb5_address *inad; - krb5_address **outad; +krb5_copy_addr(krb5_context context, const krb5_address *inad, krb5_address **outad) { krb5_address *tmpad; @@ -57,10 +54,7 @@ krb5_copy_addr(context, inad, outad) * Copy an address array, with fresh allocation. */ krb5_error_code KRB5_CALLCONV -krb5_copy_addresses(context, inaddr, outaddr) - krb5_context context; - krb5_address * const * inaddr; - krb5_address ***outaddr; +krb5_copy_addresses(krb5_context context, krb5_address *const *inaddr, krb5_address ***outaddr) { krb5_error_code retval; krb5_address ** tempaddr; diff --git a/src/lib/krb5/krb/copy_athctr.c b/src/lib/krb5/krb/copy_athctr.c index e421d903f..4b852a435 100644 --- a/src/lib/krb5/krb/copy_athctr.c +++ b/src/lib/krb5/krb/copy_athctr.c @@ -30,10 +30,7 @@ #include "k5-int.h" krb5_error_code KRB5_CALLCONV -krb5_copy_authenticator(context, authfrom, authto) - krb5_context context; - const krb5_authenticator *authfrom; - krb5_authenticator **authto; +krb5_copy_authenticator(krb5_context context, const krb5_authenticator *authfrom, krb5_authenticator **authto) { krb5_error_code retval; krb5_authenticator *tempto; diff --git a/src/lib/krb5/krb/copy_auth.c b/src/lib/krb5/krb/copy_auth.c index cd4abccaa..19e026411 100644 --- a/src/lib/krb5/krb/copy_auth.c +++ b/src/lib/krb5/krb/copy_auth.c @@ -30,10 +30,7 @@ #include "k5-int.h" static krb5_error_code -krb5_copy_authdatum(context, inad, outad) - krb5_context context; -const krb5_authdata *inad; -krb5_authdata **outad; +krb5_copy_authdatum(krb5_context context, const krb5_authdata *inad, krb5_authdata **outad) { krb5_authdata *tmpad; @@ -57,10 +54,7 @@ krb5_authdata **outad; * Copy an authdata array, with fresh allocation. */ krb5_error_code KRB5_CALLCONV -krb5_copy_authdata(context, inauthdat, outauthdat) - krb5_context context; - krb5_authdata * const * inauthdat; - krb5_authdata ***outauthdat; +krb5_copy_authdata(krb5_context context, krb5_authdata *const *inauthdat, krb5_authdata ***outauthdat) { krb5_error_code retval; krb5_authdata ** tempauthdat; diff --git a/src/lib/krb5/krb/copy_cksum.c b/src/lib/krb5/krb/copy_cksum.c index 0507c27b9..38b267159 100644 --- a/src/lib/krb5/krb/copy_cksum.c +++ b/src/lib/krb5/krb/copy_cksum.c @@ -30,10 +30,7 @@ #include "k5-int.h" krb5_error_code KRB5_CALLCONV -krb5_copy_checksum(context, ckfrom, ckto) - krb5_context context; - const krb5_checksum *ckfrom; - krb5_checksum **ckto; +krb5_copy_checksum(krb5_context context, const krb5_checksum *ckfrom, krb5_checksum **ckto) { krb5_checksum *tempto; diff --git a/src/lib/krb5/krb/copy_creds.c b/src/lib/krb5/krb/copy_creds.c index bb896a05d..2be195055 100644 --- a/src/lib/krb5/krb/copy_creds.c +++ b/src/lib/krb5/krb/copy_creds.c @@ -34,10 +34,7 @@ */ krb5_error_code KRB5_CALLCONV -krb5_copy_creds(context, incred, outcred) - krb5_context context; - const krb5_creds *incred; - krb5_creds **outcred; +krb5_copy_creds(krb5_context context, const krb5_creds *incred, krb5_creds **outcred) { krb5_creds *tempcred; krb5_error_code retval; diff --git a/src/lib/krb5/krb/copy_data.c b/src/lib/krb5/krb/copy_data.c index a8b227908..2899c5a88 100644 --- a/src/lib/krb5/krb/copy_data.c +++ b/src/lib/krb5/krb/copy_data.c @@ -33,10 +33,7 @@ * Copy a data structure, with fresh allocation. */ krb5_error_code KRB5_CALLCONV -krb5_copy_data(context, indata, outdata) - krb5_context context; - const krb5_data *indata; - krb5_data **outdata; +krb5_copy_data(krb5_context context, const krb5_data *indata, krb5_data **outdata) { krb5_data *tempdata; diff --git a/src/lib/krb5/krb/copy_key.c b/src/lib/krb5/krb/copy_key.c index 9a5fa13e8..d2640ed58 100644 --- a/src/lib/krb5/krb/copy_key.c +++ b/src/lib/krb5/krb/copy_key.c @@ -33,10 +33,7 @@ * Copy a keyblock, including alloc'ed storage. */ krb5_error_code KRB5_CALLCONV -krb5_copy_keyblock(context, from, to) - krb5_context context; - const krb5_keyblock *from; - krb5_keyblock **to; +krb5_copy_keyblock(krb5_context context, const krb5_keyblock *from, krb5_keyblock **to) { krb5_keyblock *new_key; diff --git a/src/lib/krb5/krb/copy_princ.c b/src/lib/krb5/krb/copy_princ.c index d85bedc3c..569e55b90 100644 --- a/src/lib/krb5/krb/copy_princ.c +++ b/src/lib/krb5/krb/copy_princ.c @@ -33,10 +33,7 @@ * Copy a principal structure, with fresh allocation. */ krb5_error_code KRB5_CALLCONV -krb5_copy_principal(context, inprinc, outprinc) - krb5_context context; - krb5_const_principal inprinc; - krb5_principal *outprinc; +krb5_copy_principal(krb5_context context, krb5_const_principal inprinc, krb5_principal *outprinc) { register krb5_principal tempprinc; register int i, nelems; diff --git a/src/lib/krb5/krb/copy_tick.c b/src/lib/krb5/krb/copy_tick.c index 9ef2954e5..00f235d3c 100644 --- a/src/lib/krb5/krb/copy_tick.c +++ b/src/lib/krb5/krb/copy_tick.c @@ -30,10 +30,7 @@ #include "k5-int.h" static krb5_error_code -krb5_copy_enc_tkt_part(context, partfrom, partto) - krb5_context context; - const krb5_enc_tkt_part *partfrom; - krb5_enc_tkt_part **partto; +krb5_copy_enc_tkt_part(krb5_context context, const krb5_enc_tkt_part *partfrom, krb5_enc_tkt_part **partto) { krb5_error_code retval; krb5_enc_tkt_part *tempto; @@ -99,10 +96,7 @@ krb5_copy_enc_tkt_part(context, partfrom, partto) } krb5_error_code KRB5_CALLCONV -krb5_copy_ticket(context, from, pto) - krb5_context context; - const krb5_ticket *from; - krb5_ticket **pto; +krb5_copy_ticket(krb5_context context, const krb5_ticket *from, krb5_ticket **pto) { krb5_error_code retval; krb5_ticket *tempto; diff --git a/src/lib/krb5/krb/cp_key_cnt.c b/src/lib/krb5/krb/cp_key_cnt.c index d83d07a26..b39a6a98a 100644 --- a/src/lib/krb5/krb/cp_key_cnt.c +++ b/src/lib/krb5/krb/cp_key_cnt.c @@ -33,10 +33,7 @@ * Copy a keyblock, including alloc'ed storage. */ krb5_error_code KRB5_CALLCONV -krb5_copy_keyblock_contents(context, from, to) - krb5_context context; - const krb5_keyblock *from; - krb5_keyblock *to; +krb5_copy_keyblock_contents(krb5_context context, const krb5_keyblock *from, krb5_keyblock *to) { *to = *from; to->contents = (krb5_octet *)malloc(to->length); diff --git a/src/lib/krb5/krb/decode_kdc.c b/src/lib/krb5/krb/decode_kdc.c index 23869c627..cdfc4ffbd 100644 --- a/src/lib/krb5/krb/decode_kdc.c +++ b/src/lib/krb5/krb/decode_kdc.c @@ -43,11 +43,7 @@ */ krb5_error_code -krb5_decode_kdc_rep(context, enc_rep, key, dec_rep) - krb5_context context; - krb5_data * enc_rep; - const krb5_keyblock * key; - krb5_kdc_rep ** dec_rep; +krb5_decode_kdc_rep(krb5_context context, krb5_data *enc_rep, const krb5_keyblock *key, krb5_kdc_rep **dec_rep) { krb5_error_code retval; krb5_kdc_rep *local_dec_rep; diff --git a/src/lib/krb5/krb/decrypt_tk.c b/src/lib/krb5/krb/decrypt_tk.c index d1c44ba02..36ecbb45b 100644 --- a/src/lib/krb5/krb/decrypt_tk.c +++ b/src/lib/krb5/krb/decrypt_tk.c @@ -39,10 +39,7 @@ */ krb5_error_code KRB5_CALLCONV -krb5_decrypt_tkt_part(context, srv_key, ticket) - krb5_context context; - const krb5_keyblock *srv_key; - register krb5_ticket *ticket; +krb5_decrypt_tkt_part(krb5_context context, const krb5_keyblock *srv_key, register krb5_ticket *ticket) { krb5_enc_tkt_part *dec_tkt_part; krb5_data scratch; diff --git a/src/lib/krb5/krb/deltat.c b/src/lib/krb5/krb/deltat.c index c71909a02..615f37a8d 100644 --- a/src/lib/krb5/krb/deltat.c +++ b/src/lib/krb5/krb/deltat.c @@ -1,14 +1,12 @@ - -/* A Bison parser, made from ../../../../src/lib/krb5/krb/x-deltat.y - by GNU Bison version 1.27 - */ +/* A Bison parser, made from ../../../../src/lib/krb5/krb/x-deltat.y + by GNU bison 1.35. */ #define YYBISON 1 /* Identify Bison output. */ -#define NUM 257 -#define LONGNUM 258 -#define OVERFLOW 259 -#define WS 260 +# define NUM 257 +# define LONGNUM 258 +# define OVERFLOW 259 +# define WS 260 #line 38 "../../../../src/lib/krb5/krb/x-deltat.y" @@ -96,13 +94,13 @@ static int yyparse (void *); #line 125 "../../../../src/lib/krb5/krb/x-deltat.y" -typedef union { int val; } YYSTYPE; -#include - -#ifndef __cplusplus -#ifndef __STDC__ -#define const +#ifndef YYSTYPE +typedef union { int val; } yystype; +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 #endif +#ifndef YYDEBUG +# define YYDEBUG 0 #endif @@ -111,134 +109,158 @@ typedef union { int val; } YYSTYPE; #define YYFLAG -32768 #define YYNTBASE 13 +/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ #define YYTRANSLATE(x) ((unsigned)(x) <= 260 ? yytranslate[x] : 22) -static const char yytranslate[] = { 0, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 6, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 7, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, - 2, 2, 2, 9, 2, 2, 2, 2, 10, 2, - 2, 2, 2, 2, 11, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 1, 3, 4, 5, 12 +/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ +static const char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 6, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 7, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 8, 2, 2, 2, 9, 2, 2, 2, 2, 10, + 2, 2, 2, 2, 2, 11, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, + 12 }; -#if YYDEBUG != 0 -static const short yyprhs[] = { 0, - 0, 2, 4, 6, 8, 11, 12, 14, 17, 20, - 24, 28, 32, 35, 43, 49, 53, 55, 59, 61, - 65, 67 +#if YYDEBUG +static const short yyprhs[] = +{ + 0, 0, 2, 4, 6, 8, 11, 12, 14, 17, + 20, 24, 28, 32, 35, 43, 49, 53, 55, 59, + 61, 65, 67 }; - -static const short yyrhs[] = { 18, - 0, 3, 0, 4, 0, 14, 0, 6, 14, 0, - 0, 12, 0, 16, 15, 0, 16, 5, 0, 17, - 8, 19, 0, 17, 9, 20, 0, 17, 10, 21, - 0, 17, 11, 0, 17, 6, 3, 7, 3, 7, - 3, 0, 17, 7, 3, 7, 3, 0, 17, 7, - 3, 0, 20, 0, 17, 9, 20, 0, 21, 0, - 17, 10, 21, 0, 16, 0, 17, 11, 0 +static const short yyrhs[] = +{ + 18, 0, 3, 0, 4, 0, 14, 0, 6, 14, + 0, 0, 12, 0, 16, 15, 0, 16, 5, 0, + 17, 8, 19, 0, 17, 9, 20, 0, 17, 10, + 21, 0, 17, 11, 0, 17, 6, 3, 7, 3, + 7, 3, 0, 17, 7, 3, 7, 3, 0, 17, + 7, 3, 0, 20, 0, 17, 9, 20, 0, 21, + 0, 17, 10, 21, 0, 16, 0, 17, 11, 0 }; #endif -#if YYDEBUG != 0 -static const short yyrline[] = { 0, - 136, 137, 137, 138, 138, 139, 139, 140, 141, 142, - 144, 145, 146, 147, 148, 149, 152, 154, 156, 158, - 160, 162 +#if YYDEBUG +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const short yyrline[] = +{ + 0, 136, 137, 137, 138, 138, 139, 139, 140, 141, + 142, 144, 145, 146, 147, 148, 149, 152, 154, 156, + 158, 160, 162 }; #endif -#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) +#if (YYDEBUG) || defined YYERROR_VERBOSE -static const char * const yytname[] = { "$","error","$undefined.","NUM","LONGNUM", -"OVERFLOW","'-'","':'","'d'","'h'","'m'","'s'","WS","start","posnum","num","ws", -"wsnum","deltat","opt_hms","opt_ms","opt_s", NULL +/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ +static const char *const yytname[] = +{ + "$", "error", "$undefined.", "NUM", "LONGNUM", "OVERFLOW", "'-'", "':'", + "'d'", "'h'", "'m'", "'s'", "WS", "start", "posnum", "num", "ws", + "wsnum", "deltat", "opt_hms", "opt_ms", "opt_s", 0 }; #endif -static const short yyr1[] = { 0, - 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, - 18, 18, 18, 18, 18, 18, 19, 19, 20, 20, - 21, 21 +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const short yyr1[] = +{ + 0, 13, 14, 14, 15, 15, 16, 16, 17, 17, + 18, 18, 18, 18, 18, 18, 18, 19, 19, 20, + 20, 21, 21 }; -static const short yyr2[] = { 0, - 1, 1, 1, 1, 2, 0, 1, 2, 2, 3, - 3, 3, 2, 7, 5, 3, 1, 3, 1, 3, - 1, 2 +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const short yyr2[] = +{ + 0, 1, 1, 1, 1, 2, 0, 1, 2, 2, + 3, 3, 3, 2, 7, 5, 3, 1, 3, 1, + 3, 1, 2 }; -static const short yydefact[] = { 6, - 7, 0, 0, 1, 2, 3, 9, 0, 4, 8, - 0, 0, 6, 6, 6, 13, 5, 0, 16, 21, - 0, 10, 17, 19, 0, 11, 0, 12, 0, 0, - 6, 6, 22, 0, 15, 18, 20, 0, 14, 0, - 0, 0 +/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE + doesn't specify something else to do. Zero means the default is an + error. */ +static const short yydefact[] = +{ + 6, 7, 0, 0, 1, 2, 3, 9, 0, 4, + 8, 0, 0, 6, 6, 6, 13, 5, 0, 16, + 21, 0, 10, 17, 19, 0, 11, 0, 12, 0, + 0, 6, 6, 22, 0, 15, 18, 20, 0, 14, + 0, 0, 0 }; -static const short yydefgoto[] = { 40, - 9, 10, 20, 25, 4, 22, 23, 24 +static const short yydefgoto[] = +{ + 40, 9, 10, 20, 25, 4, 22, 23, 24 }; -static const short yypact[] = { -10, --32768, 18, -2,-32768,-32768,-32768,-32768, 13,-32768,-32768, - 11, 16, -10, -10, -10,-32768,-32768, 20, 21, 18, - 1,-32768,-32768,-32768, 15,-32768, 19,-32768, 26, 28, - -10, -10,-32768, 27,-32768,-32768,-32768, 30,-32768, 35, - 36,-32768 +static const short yypact[] = +{ + -10,-32768, 18, -2,-32768,-32768,-32768,-32768, 13,-32768, + -32768, 11, 16, -10, -10, -10,-32768,-32768, 20, 21, + 18, 1,-32768,-32768,-32768, 15,-32768, 19,-32768, 26, + 28, -10, -10,-32768, 27,-32768,-32768,-32768, 30,-32768, + 35, 36,-32768 }; -static const short yypgoto[] = {-32768, - 29,-32768, 38, 0,-32768,-32768, -13, -12 +static const short yypgoto[] = +{ + -32768, 29,-32768, 38, 0,-32768,-32768, -13, -12 }; #define YYLAST 38 -static const short yytable[] = { 3, - 26, 1, 28, 11, 12, 13, 14, 15, 16, 31, - 32, 33, 21, 18, 27, 5, 6, 36, 19, 37, - 5, 6, 7, 8, 32, 33, 29, 30, 34, 33, - 35, 27, 39, 38, 41, 42, 17, 2 +static const short yytable[] = +{ + 3, 26, 1, 28, 11, 12, 13, 14, 15, 16, + 31, 32, 33, 21, 18, 27, 5, 6, 36, 19, + 37, 5, 6, 7, 8, 32, 33, 29, 30, 34, + 33, 35, 27, 39, 38, 41, 42, 17, 2 }; -static const short yycheck[] = { 0, - 14, 12, 15, 6, 7, 8, 9, 10, 11, 9, - 10, 11, 13, 3, 15, 3, 4, 31, 3, 32, - 3, 4, 5, 6, 10, 11, 7, 7, 3, 11, - 3, 32, 3, 7, 0, 0, 8, 0 +static const short yycheck[] = +{ + 0, 14, 12, 15, 6, 7, 8, 9, 10, 11, + 9, 10, 11, 13, 3, 15, 3, 4, 31, 3, + 32, 3, 4, 5, 6, 10, 11, 7, 7, 3, + 11, 3, 32, 3, 7, 0, 0, 8, 0 }; #define YYPURE 1 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/mit/gnu/share/bison.simple" -/* This file comes from bison-1.27. */ +#line 3 "/usr/share/bison/bison.simple" /* Skeleton output parser for bison, - Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software + Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -260,62 +282,131 @@ static const short yycheck[] = { 0, This special exception was added by the Free Software Foundation in version 1.24 of Bison. */ -/* This is the parser code that is written into each bison parser - when the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the hairy parser - used when %semantic_parser is specified. */ +/* This is the parser code that is written into each bison parser when + the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; +# if YYLSP_NEEDED + YYLTYPE yyls; +# endif +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# if YYLSP_NEEDED +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAX) +# else +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) +# endif + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) -#ifndef YYSTACK_USE_ALLOCA -#ifdef alloca -#define YYSTACK_USE_ALLOCA -#else /* alloca not defined */ -#ifdef __GNUC__ -#define YYSTACK_USE_ALLOCA -#define alloca __builtin_alloca -#else /* not GNU C. */ -#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) -#define YYSTACK_USE_ALLOCA -#include -#else /* not sparc */ -/* We think this test detects Watcom and Microsoft C. */ -/* This used to test MSDOS, but that is a bad idea - since that symbol is in the user namespace. */ -#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) -#if 0 /* No need for malloc.h, which pollutes the namespace; - instead, just don't use alloca. */ -#include #endif -#else /* not MSDOS, or __TURBOC__ */ -#if defined(_AIX) -/* I don't know what this was needed for, but it pollutes the namespace. - So I turned it off. rms, 2 May 1997. */ -/* #include */ - #pragma alloca -#define YYSTACK_USE_ALLOCA -#else /* not MSDOS, or __TURBOC__, or _AIX */ -#if 0 -#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, - and on HPUX 10. Eventually we can turn this on. */ -#define YYSTACK_USE_ALLOCA -#define alloca __builtin_alloca -#endif /* __hpux */ + + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ #endif -#endif /* not _AIX */ -#endif /* not MSDOS, or __TURBOC__ */ -#endif /* not sparc */ -#endif /* not GNU C */ -#endif /* alloca not defined */ -#endif /* YYSTACK_USE_ALLOCA not defined */ - -#ifdef YYSTACK_USE_ALLOCA -#define YYSTACK_ALLOC alloca -#else -#define YYSTACK_ALLOC malloc +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int #endif - -/* Note: there must be only one dollar sign in this file. - It is replaced by the list of actions, each action - as one case of the switch. */ #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) @@ -324,131 +415,161 @@ static const short yycheck[] = { 0, #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrlab1 -/* Like YYERROR except do call yyerror. - This remains here temporarily to ease the - transition to the new meaning of YYERROR, for GCC. +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(token, value) \ +#define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ - { yychar = (token), yylval = (value); \ + { \ + yychar = (Token); \ + yylval = (Value); \ yychar1 = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ - { yyerror ("syntax error: cannot back up"); YYERROR; } \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ while (0) #define YYTERROR 1 #define YYERRCODE 256 -#ifndef YYPURE -#define YYLEX yylex() -#endif -#ifdef YYPURE -#ifdef YYLSP_NEEDED -#ifdef YYLEX_PARAM -#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) -#else -#define YYLEX yylex(&yylval, &yylloc) -#endif -#else /* not YYLSP_NEEDED */ -#ifdef YYLEX_PARAM -#define YYLEX yylex(&yylval, YYLEX_PARAM) -#else -#define YYLEX yylex(&yylval) -#endif -#endif /* not YYLSP_NEEDED */ -#endif - -/* If nonreentrant, generate the variables here */ - -#ifndef YYPURE - -int yychar; /* the lookahead symbol */ -YYSTYPE yylval; /* the semantic value of the */ - /* lookahead symbol */ - -#ifdef YYLSP_NEEDED -YYLTYPE yylloc; /* location data for the lookahead */ - /* symbol */ -#endif +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). -int yynerrs; /* number of parse errors so far */ -#endif /* not YYPURE */ + When YYLLOC_DEFAULT is run, CURRENT is set the location of the + first token. By default, to implement support for ranges, extend + its range to the last symbol. */ -#if YYDEBUG != 0 -int yydebug; /* nonzero means print parse trace */ -/* Since this is uninitialized, it does not stop multiple parsers - from coexisting. */ +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; #endif -/* YYINITDEPTH indicates the initial size of the parser's stacks */ +/* YYLEX -- calling `yylex' with the right arguments. */ + +#if YYPURE +# if YYLSP_NEEDED +# ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) +# else +# define YYLEX yylex (&yylval, &yylloc) +# endif +# else /* !YYLSP_NEEDED */ +# ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +# else +# define YYLEX yylex (&yylval) +# endif +# endif /* !YYLSP_NEEDED */ +#else /* !YYPURE */ +# define YYLEX yylex () +#endif /* !YYPURE */ + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH -#define YYINITDEPTH 200 +# define YYINITDEPTH 200 #endif -/* YYMAXDEPTH is the maximum size the stacks can grow to - (effective only if the built-in stack extension method is used). */ +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ #if YYMAXDEPTH == 0 -#undef YYMAXDEPTH +# undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH -#define YYMAXDEPTH 10000 +# define YYMAXDEPTH 10000 #endif -/* Define __yy_memcpy. Note that the size argument - should be passed with type unsigned int, because that is what the non-GCC - definitions require. With GCC, __builtin_memcpy takes an arg - of type size_t, but it can handle unsigned int. */ - -#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ -#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) -#else /* not GNU C or C++ */ -#ifndef __cplusplus - -/* This is the most reliable way to avoid incompatibilities - in available built-in functions on various systems. */ -static void -__yy_memcpy (to, from, count) - char *to; - char *from; - unsigned int count; -{ - register char *f = from; - register char *t = to; - register int i = count; +#ifdef YYERROR_VERBOSE - while (i-- > 0) - *t++ = *f++; -} +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; -#else /* __cplusplus */ + while (*yys++ != '\0') + continue; -/* This is the most reliable way to avoid incompatibilities - in available built-in functions on various systems. */ -static void -__yy_memcpy (char *to, char *from, unsigned int count) + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif { - register char *t = to; - register char *f = from; - register int i = count; + register char *yyd = yydest; + register const char *yys = yysrc; - while (i-- > 0) - *t++ = *f++; -} + while ((*yyd++ = *yys++) != '\0') + continue; -#endif + return yyd - 1; +} +# endif +# endif #endif -#line 216 "/mit/gnu/share/bison.simple" +#line 315 "/usr/share/bison/bison.simple" + /* The user can define YYPARSE_PARAM as the name of an argument to be passed into yyparse. The argument should have type void *. @@ -457,76 +578,121 @@ __yy_memcpy (char *to, char *from, unsigned int count) to the proper pointer type. */ #ifdef YYPARSE_PARAM -#ifdef __cplusplus -#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -#define YYPARSE_PARAM_DECL -#else /* not __cplusplus */ -#define YYPARSE_PARAM_ARG YYPARSE_PARAM -#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; -#endif /* not __cplusplus */ -#else /* not YYPARSE_PARAM */ -#define YYPARSE_PARAM_ARG -#define YYPARSE_PARAM_DECL -#endif /* not YYPARSE_PARAM */ +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ -#ifdef YYPARSE_PARAM +# ifdef YYPARSE_PARAM int yyparse (void *); -#else +# else int yyparse (void); +# endif #endif + +/* YY_DECL_VARIABLES -- depending whether we use a pure parser, + variables are global, or local to YYPARSE. */ + +#define YY_DECL_NON_LSP_VARIABLES \ +/* The lookahead symbol. */ \ +int yychar; \ + \ +/* The semantic value of the lookahead symbol. */ \ +YYSTYPE yylval; \ + \ +/* Number of parse errors so far. */ \ +int yynerrs; + +#if YYLSP_NEEDED +# define YY_DECL_VARIABLES \ +YY_DECL_NON_LSP_VARIABLES \ + \ +/* Location data for the lookahead symbol. */ \ +YYLTYPE yylloc; +#else +# define YY_DECL_VARIABLES \ +YY_DECL_NON_LSP_VARIABLES #endif + +/* If nonreentrant, generate the variables here. */ + +#if !YYPURE +YY_DECL_VARIABLES +#endif /* !YYPURE */ + int -yyparse(YYPARSE_PARAM_ARG) +yyparse (YYPARSE_PARAM_ARG) YYPARSE_PARAM_DECL { + /* If reentrant, generate the variables here. */ +#if YYPURE + YY_DECL_VARIABLES +#endif /* !YYPURE */ + register int yystate; register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; register short *yyssp; - register YYSTYPE *yyvsp; - int yyerrstatus; /* number of tokens to shift before error messages enabled */ - int yychar1 = 0; /* lookahead token as an internal (translated) token number */ - - short yyssa[YYINITDEPTH]; /* the state stack */ - YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ - short *yyss = yyssa; /* refer to the stacks thru separate pointers */ - YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; -#ifdef YYLSP_NEEDED - YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ +#if YYLSP_NEEDED + /* The location stack. */ + YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls = yylsa; YYLTYPE *yylsp; +#endif -#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#if YYLSP_NEEDED +# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) #else -#define YYPOPSTACK (yyvsp--, yyssp--) +# define YYPOPSTACK (yyvsp--, yyssp--) #endif - int yystacksize = YYINITDEPTH; - int yyfree_stacks = 0; + YYSIZE_T yystacksize = YYINITDEPTH; -#ifdef YYPURE - int yychar; - YYSTYPE yylval; - int yynerrs; -#ifdef YYLSP_NEEDED - YYLTYPE yylloc; -#endif -#endif - YYSTYPE yyval; /* the variable used to return */ - /* semantic values from the action */ - /* routines */ + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; +#if YYLSP_NEEDED + YYLTYPE yyloc; +#endif + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ int yylen; -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Starting parse\n"); -#endif + YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; @@ -538,110 +704,110 @@ yyparse(YYPARSE_PARAM_ARG) so that they stay on the same level as the state stack. The wasted elements are never initialized. */ - yyssp = yyss - 1; + yyssp = yyss; yyvsp = yyvs; -#ifdef YYLSP_NEEDED +#if YYLSP_NEEDED yylsp = yyls; #endif + goto yysetstate; -/* Push a new state, which is found in yystate . */ -/* In all cases, when you get here, the value and location stacks - have just been pushed. so pushing a state here evens the stacks. */ -yynewstate: +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; - *++yyssp = yystate; + yysetstate: + *yyssp = yystate; if (yyssp >= yyss + yystacksize - 1) { - /* Give user a chance to reallocate the stack */ - /* Use copies of these so that the &'s don't force the real ones into memory. */ - YYSTYPE *yyvs1 = yyvs; - short *yyss1 = yyss; -#ifdef YYLSP_NEEDED - YYLTYPE *yyls1 = yyls; -#endif - /* Get the current used size of the three stacks, in elements. */ - int size = yyssp - yyss + 1; + YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow - /* Each stack pointer address is followed by the size of - the data in use in that stack, in bytes. */ -#ifdef YYLSP_NEEDED - /* This used to be a conditional around just the two extra args, - but that might be undefined if yyoverflow is a macro. */ - yyoverflow("parser stack overflow", - &yyss1, size * sizeof (*yyssp), - &yyvs1, size * sizeof (*yyvsp), - &yyls1, size * sizeof (*yylsp), - &yystacksize); -#else - yyoverflow("parser stack overflow", - &yyss1, size * sizeof (*yyssp), - &yyvs1, size * sizeof (*yyvsp), - &yystacksize); -#endif - - yyss = yyss1; yyvs = yyvs1; -#ifdef YYLSP_NEEDED - yyls = yyls1; -#endif + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. */ +# if YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yyls1, yysize * sizeof (*yylsp), + &yystacksize); + yyls = yyls1; +# else + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); +# endif + yyss = yyss1; + yyvs = yyvs1; + } #else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else /* Extend the stack our own way. */ if (yystacksize >= YYMAXDEPTH) - { - yyerror("parser stack overflow"); - if (yyfree_stacks) - { - free (yyss); - free (yyvs); -#ifdef YYLSP_NEEDED - free (yyls); -#endif - } - return 2; - } + goto yyoverflowlab; yystacksize *= 2; if (yystacksize > YYMAXDEPTH) yystacksize = YYMAXDEPTH; -#ifndef YYSTACK_USE_ALLOCA - yyfree_stacks = 1; -#endif - yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); - __yy_memcpy ((char *)yyss, (char *)yyss1, - size * (unsigned int) sizeof (*yyssp)); - yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); - __yy_memcpy ((char *)yyvs, (char *)yyvs1, - size * (unsigned int) sizeof (*yyvsp)); -#ifdef YYLSP_NEEDED - yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); - __yy_memcpy ((char *)yyls, (char *)yyls1, - size * (unsigned int) sizeof (*yylsp)); -#endif + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); +# if YYLSP_NEEDED + YYSTACK_RELOCATE (yyls); +# endif +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif #endif /* no yyoverflow */ - yyssp = yyss + size - 1; - yyvsp = yyvs + size - 1; -#ifdef YYLSP_NEEDED - yylsp = yyls + size - 1; + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; +#if YYLSP_NEEDED + yylsp = yyls + yysize - 1; #endif -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Stack size increased to %d\n", yystacksize); -#endif + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); if (yyssp >= yyss + yystacksize - 1) YYABORT; } -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Entering state %d\n", yystate); -#endif + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); goto yybackup; - yybackup: + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ @@ -660,10 +826,7 @@ yynewstate: if (yychar == YYEMPTY) { -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Reading a token: "); -#endif + YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } @@ -674,25 +837,25 @@ yynewstate: yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Now at end of input.\n"); -#endif + YYDPRINTF ((stderr, "Now at end of input.\n")); } else { - yychar1 = YYTRANSLATE(yychar); + yychar1 = YYTRANSLATE (yychar); -#if YYDEBUG != 0 +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ if (yydebug) { - fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); - /* Give the individual parser a way to print the precise meaning - of a token, for further debugging info. */ -#ifdef YYPRINT + YYFPRINTF (stderr, "Next token is %d (%s", + yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise + meaning of a token, for further debugging info. */ +# ifdef YYPRINT YYPRINT (stderr, yychar, yylval); -#endif - fprintf (stderr, ")\n"); +# endif + YYFPRINTF (stderr, ")\n"); } #endif } @@ -724,56 +887,78 @@ yynewstate: YYACCEPT; /* Shift the lookahead token. */ - -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); -#endif + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; -#ifdef YYLSP_NEEDED +#if YYLSP_NEEDED *++yylsp = yylloc; #endif - /* count tokens shifted since error; after three, turn off error status. */ - if (yyerrstatus) yyerrstatus--; + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; yystate = yyn; goto yynewstate; -/* Do the default action for the current state. */ -yydefault: +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; + goto yyreduce; -/* Do a reduction. yyn is the number of a rule to reduce with. */ + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ yyreduce: + /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; - if (yylen > 0) - yyval = yyvsp[1-yylen]; /* implement default value of the action */ -#if YYDEBUG != 0 + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to the semantic value of + the lookahead token. This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + +#if YYLSP_NEEDED + /* Similarly for the default location. Let the user run additional + commands if for instance locations are ranges. */ + yyloc = yylsp[1-yylen]; + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); +#endif + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ if (yydebug) { - int i; + int yyi; - fprintf (stderr, "Reducing via rule %d (line %d), ", - yyn, yyrline[yyn]); + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); /* Print the symbols being reduced, and their result. */ - for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) - fprintf (stderr, "%s ", yytname[yyrhs[i]]); - fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); } #endif - switch (yyn) { case 5: @@ -831,49 +1016,35 @@ case 21: { yyval.val = 0; ; break;} } - /* the action file gets copied in in place of this dollarsign */ -#line 542 "/mit/gnu/share/bison.simple" + +#line 705 "/usr/share/bison/bison.simple" + yyvsp -= yylen; yyssp -= yylen; -#ifdef YYLSP_NEEDED +#if YYLSP_NEEDED yylsp -= yylen; #endif -#if YYDEBUG != 0 +#if YYDEBUG if (yydebug) { - short *ssp1 = yyss - 1; - fprintf (stderr, "state stack now"); - while (ssp1 != yyssp) - fprintf (stderr, " %d", *++ssp1); - fprintf (stderr, "\n"); + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); } #endif *++yyvsp = yyval; - -#ifdef YYLSP_NEEDED - yylsp++; - if (yylen == 0) - { - yylsp->first_line = yylloc.first_line; - yylsp->first_column = yylloc.first_column; - yylsp->last_line = (yylsp-1)->last_line; - yylsp->last_column = (yylsp-1)->last_column; - yylsp->text = 0; - } - else - { - yylsp->last_line = (yylsp+yylen-1)->last_line; - yylsp->last_column = (yylsp+yylen-1)->last_column; - } +#if YYLSP_NEEDED + *++yylsp = yyloc; #endif - /* Now "shift" the result of the reduction. - Determine what state that goes to, - based on the state we popped back to - and the rule number reduced by. */ + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ yyn = yyr1[yyn]; @@ -885,10 +1056,13 @@ case 21: goto yynewstate; -yyerrlab: /* here on detecting error */ - if (! yyerrstatus) - /* If not already recovering from an error, report this error. */ +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) { ++yynerrs; @@ -897,102 +1071,121 @@ yyerrlab: /* here on detecting error */ if (yyn > YYFLAG && yyn < YYLAST) { - int size = 0; - char *msg; - int x, count; - - count = 0; - /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ - for (x = (yyn < 0 ? -yyn : 0); - x < (sizeof(yytname) / sizeof(char *)); x++) - if (yycheck[x + yyn] == x) - size += strlen(yytname[x]) + 15, count++; - msg = (char *) malloc(size + 15); - if (msg != 0) + YYSIZE_T yysize = 0; + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) { - strcpy(msg, "parse error"); + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); - if (count < 5) + if (yycount < 5) { - count = 0; - for (x = (yyn < 0 ? -yyn : 0); - x < (sizeof(yytname) / sizeof(char *)); x++) - if (yycheck[x + yyn] == x) + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx) { - strcat(msg, count == 0 ? ", expecting `" : " or `"); - strcat(msg, yytname[x]); - strcat(msg, "'"); - count++; + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; } } - yyerror(msg); - free(msg); + yyerror (yymsg); + YYSTACK_FREE (yymsg); } else - yyerror ("parse error; also virtual memory exceeded"); + yyerror ("parse error; also virtual memory exhausted"); } else -#endif /* YYERROR_VERBOSE */ - yyerror("parse error"); +#endif /* defined (YYERROR_VERBOSE) */ + yyerror ("parse error"); } - goto yyerrlab1; -yyerrlab1: /* here on error raised explicitly by an action */ + +/*--------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action | +`--------------------------------------------------*/ +yyerrlab1: if (yyerrstatus == 3) { - /* if just tried and failed to reuse lookahead token after an error, discard it. */ + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ /* return failure if at end of input */ if (yychar == YYEOF) YYABORT; - -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); -#endif - + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); yychar = YYEMPTY; } - /* Else will try to reuse lookahead token - after shifting the error token. */ + /* Else will try to reuse lookahead token after shifting the error + token. */ yyerrstatus = 3; /* Each real token shifted decrements this */ goto yyerrhandle; -yyerrdefault: /* current state does not do anything special for the error token. */ +/*-------------------------------------------------------------------. +| yyerrdefault -- current state does not do anything special for the | +| error token. | +`-------------------------------------------------------------------*/ +yyerrdefault: #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ - yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ - if (yyn) goto yydefault; + + /* If its default is to accept any token, ok. Otherwise pop it. */ + yyn = yydefact[yystate]; + if (yyn) + goto yydefault; #endif -yyerrpop: /* pop the current state because it cannot handle the error token */ - if (yyssp == yyss) YYABORT; +/*---------------------------------------------------------------. +| yyerrpop -- pop the current state because it cannot handle the | +| error token | +`---------------------------------------------------------------*/ +yyerrpop: + if (yyssp == yyss) + YYABORT; yyvsp--; yystate = *--yyssp; -#ifdef YYLSP_NEEDED +#if YYLSP_NEEDED yylsp--; #endif -#if YYDEBUG != 0 +#if YYDEBUG if (yydebug) { - short *ssp1 = yyss - 1; - fprintf (stderr, "Error: state stack now"); - while (ssp1 != yyssp) - fprintf (stderr, " %d", *++ssp1); - fprintf (stderr, "\n"); + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); } #endif +/*--------------. +| yyerrhandle. | +`--------------*/ yyerrhandle: - yyn = yypact[yystate]; if (yyn == YYFLAG) goto yyerrdefault; @@ -1015,42 +1208,45 @@ yyerrhandle: if (yyn == YYFINAL) YYACCEPT; -#if YYDEBUG != 0 - if (yydebug) - fprintf(stderr, "Shifting error token, "); -#endif + YYDPRINTF ((stderr, "Shifting error token, ")); *++yyvsp = yylval; -#ifdef YYLSP_NEEDED +#if YYLSP_NEEDED *++yylsp = yylloc; #endif yystate = yyn; goto yynewstate; - yyacceptlab: - /* YYACCEPT comes here. */ - if (yyfree_stacks) - { - free (yyss); - free (yyvs); -#ifdef YYLSP_NEEDED - free (yyls); -#endif - } - return 0; - yyabortlab: - /* YYABORT comes here. */ - if (yyfree_stacks) - { - free (yyss); - free (yyvs); -#ifdef YYLSP_NEEDED - free (yyls); +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +/*---------------------------------------------. +| yyoverflowab -- parser overflow comes here. | +`---------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); #endif - } - return 1; + return yyresult; } #line 164 "../../../../src/lib/krb5/krb/x-deltat.y" @@ -1108,9 +1304,7 @@ mylex (krb5_int32 *intp, char **pp) } krb5_error_code KRB5_CALLCONV -krb5_string_to_deltat(string, deltatp) - char * string; - krb5_deltat * deltatp; +krb5_string_to_deltat(char *string, krb5_deltat *deltatp) { struct param p; p.delta = 0; diff --git a/src/lib/krb5/krb/enc_helper.c b/src/lib/krb5/krb/enc_helper.c index 2e4bb3ce4..63e3495da 100644 --- a/src/lib/krb5/krb/enc_helper.c +++ b/src/lib/krb5/krb/enc_helper.c @@ -27,12 +27,7 @@ #include "k5-int.h" krb5_error_code -krb5_encrypt_helper(context, key, usage, plain, cipher) - krb5_context context; - const krb5_keyblock *key; - krb5_keyusage usage; - const krb5_data *plain; - krb5_enc_data *cipher; +krb5_encrypt_helper(krb5_context context, const krb5_keyblock *key, krb5_keyusage usage, const krb5_data *plain, krb5_enc_data *cipher) { krb5_error_code ret; size_t enclen; diff --git a/src/lib/krb5/krb/encode_kdc.c b/src/lib/krb5/krb/encode_kdc.c index fb19f3fc4..8b879c015 100644 --- a/src/lib/krb5/krb/encode_kdc.c +++ b/src/lib/krb5/krb/encode_kdc.c @@ -44,15 +44,10 @@ /* due to argument promotion rules, we need to use the DECLARG/OLDDECLARG stuff... */ krb5_error_code -krb5_encode_kdc_rep(context, type, encpart, using_subkey, client_key, - dec_rep, enc_rep) - krb5_context context; - const krb5_msgtype type; - const krb5_enc_kdc_rep_part * encpart; - int using_subkey; - const krb5_keyblock * client_key; - krb5_kdc_rep * dec_rep; - krb5_data ** enc_rep; +krb5_encode_kdc_rep(krb5_context context, krb5_msgtype type, + const krb5_enc_kdc_rep_part *encpart, + int using_subkey, const krb5_keyblock *client_key, + krb5_kdc_rep *dec_rep, krb5_data **enc_rep) { krb5_data *scratch; krb5_error_code retval; diff --git a/src/lib/krb5/krb/encrypt_tk.c b/src/lib/krb5/krb/encrypt_tk.c index 07642f04e..ed2b8c1b8 100644 --- a/src/lib/krb5/krb/encrypt_tk.c +++ b/src/lib/krb5/krb/encrypt_tk.c @@ -42,10 +42,7 @@ */ krb5_error_code -krb5_encrypt_tkt_part(context, srv_key, dec_ticket) - krb5_context context; - const krb5_keyblock *srv_key; - register krb5_ticket *dec_ticket; +krb5_encrypt_tkt_part(krb5_context context, const krb5_keyblock *srv_key, register krb5_ticket *dec_ticket) { krb5_data *scratch; krb5_error_code retval; diff --git a/src/lib/krb5/krb/free_rtree.c b/src/lib/krb5/krb/free_rtree.c index 3d9ea327a..7914d3f23 100644 --- a/src/lib/krb5/krb/free_rtree.c +++ b/src/lib/krb5/krb/free_rtree.c @@ -30,9 +30,7 @@ #include "k5-int.h" void -krb5_free_realm_tree(context, realms) - krb5_context context; - krb5_principal *realms; +krb5_free_realm_tree(krb5_context context, krb5_principal *realms) { register krb5_principal *nrealms = realms; while (*nrealms) { diff --git a/src/lib/krb5/krb/fwd_tgt.c b/src/lib/krb5/krb/fwd_tgt.c index b3ee1aa0e..d589144b8 100644 --- a/src/lib/krb5/krb/fwd_tgt.c +++ b/src/lib/krb5/krb/fwd_tgt.c @@ -35,16 +35,15 @@ /* Get a TGT for use at the remote host */ krb5_error_code KRB5_CALLCONV -krb5_fwd_tgt_creds(context, auth_context, rhost, client, server, cc, - forwardable, outbuf) - krb5_context context; - krb5_auth_context auth_context; - char *rhost; - krb5_principal client; - krb5_principal server; - krb5_ccache cc; - int forwardable; /* Should forwarded TGT also be forwardable? */ - krb5_data *outbuf; +krb5_fwd_tgt_creds(krb5_context context, krb5_auth_context auth_context, char *rhost, krb5_principal client, krb5_principal server, krb5_ccache cc, int forwardable, krb5_data *outbuf) + + + + + + + /* Should forwarded TGT also be forwardable? */ + { krb5_replay_data replaydata; krb5_data * scratch = 0; diff --git a/src/lib/krb5/krb/gc_frm_kdc.c b/src/lib/krb5/krb/gc_frm_kdc.c index 26f195b26..fdf00e6b1 100644 --- a/src/lib/krb5/krb/gc_frm_kdc.c +++ b/src/lib/krb5/krb/gc_frm_kdc.c @@ -63,13 +63,7 @@ #define FLAGS2OPTS(flags) (flags & KDC_TKT_COMMON_MASK) static krb5_error_code -krb5_get_cred_from_kdc_opt(context, ccache, in_cred, out_cred, tgts, kdcopt) - krb5_context context; - krb5_ccache ccache; - krb5_creds *in_cred; - krb5_creds **out_cred; - krb5_creds ***tgts; - int kdcopt; +krb5_get_cred_from_kdc_opt(krb5_context context, krb5_ccache ccache, krb5_creds *in_cred, krb5_creds **out_cred, krb5_creds ***tgts, int kdcopt) { krb5_creds **ret_tgts = NULL; int ntgts = 0; @@ -403,12 +397,7 @@ cleanup: } krb5_error_code -krb5_get_cred_from_kdc(context, ccache, in_cred, out_cred, tgts) - krb5_context context; - krb5_ccache ccache; - krb5_creds *in_cred; - krb5_creds **out_cred; - krb5_creds ***tgts; +krb5_get_cred_from_kdc(krb5_context context, krb5_ccache ccache, krb5_creds *in_cred, krb5_creds **out_cred, krb5_creds ***tgts) { return krb5_get_cred_from_kdc_opt(context, ccache, in_cred, out_cred, tgts, @@ -416,12 +405,7 @@ krb5_get_cred_from_kdc(context, ccache, in_cred, out_cred, tgts) } krb5_error_code -krb5_get_cred_from_kdc_validate(context, ccache, in_cred, out_cred, tgts) - krb5_context context; - krb5_ccache ccache; - krb5_creds *in_cred; - krb5_creds **out_cred; - krb5_creds ***tgts; +krb5_get_cred_from_kdc_validate(krb5_context context, krb5_ccache ccache, krb5_creds *in_cred, krb5_creds **out_cred, krb5_creds ***tgts) { return krb5_get_cred_from_kdc_opt(context, ccache, in_cred, out_cred, tgts, @@ -429,12 +413,7 @@ krb5_get_cred_from_kdc_validate(context, ccache, in_cred, out_cred, tgts) } krb5_error_code -krb5_get_cred_from_kdc_renew(context, ccache, in_cred, out_cred, tgts) - krb5_context context; - krb5_ccache ccache; - krb5_creds *in_cred; - krb5_creds **out_cred; - krb5_creds ***tgts; +krb5_get_cred_from_kdc_renew(krb5_context context, krb5_ccache ccache, krb5_creds *in_cred, krb5_creds **out_cred, krb5_creds ***tgts) { return krb5_get_cred_from_kdc_opt(context, ccache, in_cred, out_cred, tgts, diff --git a/src/lib/krb5/krb/gc_via_tkt.c b/src/lib/krb5/krb/gc_via_tkt.c index 6eda0ce2c..1008d1f92 100644 --- a/src/lib/krb5/krb/gc_via_tkt.c +++ b/src/lib/krb5/krb/gc_via_tkt.c @@ -34,12 +34,7 @@ #define in_clock_skew(date, now) (labs((date)-(now)) < context->clockskew) static krb5_error_code -krb5_kdcrep2creds(context, pkdcrep, address, psectkt, ppcreds) - krb5_context context; - krb5_kdc_rep * pkdcrep; - krb5_address *const * address; - krb5_data * psectkt; - krb5_creds ** ppcreds; +krb5_kdcrep2creds(krb5_context context, krb5_kdc_rep *pkdcrep, krb5_address *const *address, krb5_data *psectkt, krb5_creds **ppcreds) { krb5_error_code retval; krb5_data *pdata; @@ -102,13 +97,9 @@ cleanup: } krb5_error_code -krb5_get_cred_via_tkt (context, tkt, kdcoptions, address, in_cred, out_cred) - krb5_context context; - krb5_creds * tkt; - const krb5_flags kdcoptions; - krb5_address *const * address; - krb5_creds * in_cred; - krb5_creds ** out_cred; +krb5_get_cred_via_tkt (krb5_context context, krb5_creds *tkt, + krb5_flags kdcoptions, krb5_address *const *address, + krb5_creds *in_cred, krb5_creds **out_cred) { krb5_error_code retval; krb5_kdc_rep *dec_rep; diff --git a/src/lib/krb5/krb/gen_seqnum.c b/src/lib/krb5/krb/gen_seqnum.c index 75afb7ef4..196a43744 100644 --- a/src/lib/krb5/krb/gen_seqnum.c +++ b/src/lib/krb5/krb/gen_seqnum.c @@ -36,10 +36,7 @@ #endif krb5_error_code -krb5_generate_seq_number(context, key, seqno) - krb5_context context; - const krb5_keyblock *key; - krb5_int32 *seqno; +krb5_generate_seq_number(krb5_context context, const krb5_keyblock *key, krb5_int32 *seqno) { krb5_data seed; krb5_error_code retval; diff --git a/src/lib/krb5/krb/gen_subkey.c b/src/lib/krb5/krb/gen_subkey.c index 90e3302da..7ffc91f13 100644 --- a/src/lib/krb5/krb/gen_subkey.c +++ b/src/lib/krb5/krb/gen_subkey.c @@ -30,10 +30,7 @@ #include "k5-int.h" krb5_error_code -krb5_generate_subkey(context, key, subkey) - krb5_context context; - const krb5_keyblock *key; - krb5_keyblock **subkey; +krb5_generate_subkey(krb5_context context, const krb5_keyblock *key, krb5_keyblock **subkey) { krb5_error_code retval; krb5_data seed; diff --git a/src/lib/krb5/krb/get_creds.c b/src/lib/krb5/krb/get_creds.c index 0455be4db..934971076 100644 --- a/src/lib/krb5/krb/get_creds.c +++ b/src/lib/krb5/krb/get_creds.c @@ -46,12 +46,9 @@ #include "k5-int.h" static krb5_error_code -krb5_get_credentials_core(context, options, in_creds, mcreds, fields) - krb5_context context; - const krb5_flags options; - krb5_creds *in_creds; - krb5_creds *mcreds; - krb5_flags *fields; +krb5_get_credentials_core(krb5_context context, krb5_flags options, + krb5_creds *in_creds, krb5_creds *mcreds, + krb5_flags *fields) { if (!in_creds || !in_creds->server || !in_creds->client) return EINVAL; @@ -101,12 +98,9 @@ krb5_get_credentials_core(context, options, in_creds, mcreds, fields) } krb5_error_code KRB5_CALLCONV -krb5_get_credentials(context, options, ccache, in_creds, out_creds) - krb5_context context; - const krb5_flags options; - krb5_ccache ccache; - krb5_creds *in_creds; - krb5_creds **out_creds; +krb5_get_credentials(krb5_context context, krb5_flags options, + krb5_ccache ccache, krb5_creds *in_creds, + krb5_creds **out_creds) { krb5_error_code retval; krb5_creds mcreds; @@ -182,14 +176,9 @@ krb5_get_credentials(context, options, ccache, in_creds, out_creds) #define INT_GC_RENEW 2 static krb5_error_code -krb5_get_credentials_val_renew_core(context, options, ccache, - in_creds, out_creds, which) - krb5_context context; - const krb5_flags options; - krb5_ccache ccache; - krb5_creds *in_creds; - krb5_creds **out_creds; - int which; +krb5_get_credentials_val_renew_core(krb5_context context, krb5_flags options, + krb5_ccache ccache, krb5_creds *in_creds, + krb5_creds **out_creds, int which) { krb5_error_code retval; krb5_principal tmp; @@ -223,12 +212,9 @@ krb5_get_credentials_val_renew_core(context, options, ccache, } krb5_error_code KRB5_CALLCONV -krb5_get_credentials_validate(context, options, ccache, in_creds, out_creds) - krb5_context context; - const krb5_flags options; - krb5_ccache ccache; - krb5_creds *in_creds; - krb5_creds **out_creds; +krb5_get_credentials_validate(krb5_context context, krb5_flags options, + krb5_ccache ccache, krb5_creds *in_creds, + krb5_creds **out_creds) { return(krb5_get_credentials_val_renew_core(context, options, ccache, in_creds, out_creds, @@ -236,12 +222,9 @@ krb5_get_credentials_validate(context, options, ccache, in_creds, out_creds) } krb5_error_code KRB5_CALLCONV -krb5_get_credentials_renew(context, options, ccache, in_creds, out_creds) - krb5_context context; - const krb5_flags options; - krb5_ccache ccache; - krb5_creds *in_creds; - krb5_creds **out_creds; +krb5_get_credentials_renew(krb5_context context, krb5_flags options, + krb5_ccache ccache, krb5_creds *in_creds, + krb5_creds **out_creds) { return(krb5_get_credentials_val_renew_core(context, options, ccache, @@ -250,14 +233,9 @@ krb5_get_credentials_renew(context, options, ccache, in_creds, out_creds) } static krb5_error_code -krb5_validate_or_renew_creds(context, creds, client, ccache, in_tkt_service, - validate) - krb5_context context; - krb5_creds *creds; - krb5_principal client; - krb5_ccache ccache; - char *in_tkt_service; - int validate; +krb5_validate_or_renew_creds(krb5_context context, krb5_creds *creds, + krb5_principal client, krb5_ccache ccache, + char *in_tkt_service, int validate) { krb5_error_code ret; krb5_creds in_creds; /* only client and server need to be filled in */ @@ -328,24 +306,14 @@ cleanup: } krb5_error_code KRB5_CALLCONV -krb5_get_validated_creds(context, creds, client, ccache, in_tkt_service) - krb5_context context; - krb5_creds *creds; - krb5_principal client; - krb5_ccache ccache; - char *in_tkt_service; +krb5_get_validated_creds(krb5_context context, krb5_creds *creds, krb5_principal client, krb5_ccache ccache, char *in_tkt_service) { return(krb5_validate_or_renew_creds(context, creds, client, ccache, in_tkt_service, 1)); } krb5_error_code KRB5_CALLCONV -krb5_get_renewed_creds(context, creds, client, ccache, in_tkt_service) - krb5_context context; - krb5_creds *creds; - krb5_principal client; - krb5_ccache ccache; - char *in_tkt_service; +krb5_get_renewed_creds(krb5_context context, krb5_creds *creds, krb5_principal client, krb5_ccache ccache, char *in_tkt_service) { return(krb5_validate_or_renew_creds(context, creds, client, ccache, in_tkt_service, 0)); diff --git a/src/lib/krb5/krb/get_in_tkt.c b/src/lib/krb5/krb/get_in_tkt.c index 81aaf14c9..a8ab3cd21 100644 --- a/src/lib/krb5/krb/get_in_tkt.c +++ b/src/lib/krb5/krb/get_in_tkt.c @@ -85,14 +85,12 @@ static krb5_error_code make_preauth_list (krb5_context, * unexpected response, an error is returned. */ static krb5_error_code -send_as_request(context, request, time_now, ret_err_reply, ret_as_reply, - use_master) - krb5_context context; - krb5_kdc_req *request; - krb5_timestamp *time_now; - krb5_error ** ret_err_reply; - krb5_kdc_rep ** ret_as_reply; - int use_master; +send_as_request(krb5_context context, + krb5_kdc_req *request, + krb5_timestamp *time_now, + krb5_error ** ret_err_reply, + krb5_kdc_rep ** ret_as_reply, + int use_master) { krb5_kdc_rep *as_reply = 0; krb5_error_code retval; @@ -198,16 +196,14 @@ cleanup: } static krb5_error_code -decrypt_as_reply(context, request, as_reply, key_proc, keyseed, key, - decrypt_proc, decryptarg) - krb5_context context; - krb5_kdc_req *request; - krb5_kdc_rep *as_reply; - git_key_proc key_proc; - krb5_const_pointer keyseed; - krb5_keyblock * key; - git_decrypt_proc decrypt_proc; - krb5_const_pointer decryptarg; +decrypt_as_reply(krb5_context context, + krb5_kdc_req *request, + krb5_kdc_rep *as_reply, + git_key_proc key_proc, + krb5_const_pointer keyseed, + krb5_keyblock * key, + git_decrypt_proc decrypt_proc, + krb5_const_pointer decryptarg) { krb5_error_code retval; krb5_keyblock * decrypt_key = 0; @@ -239,11 +235,10 @@ cleanup: } static krb5_error_code -verify_as_reply(context, time_now, request, as_reply) - krb5_context context; - krb5_timestamp time_now; - krb5_kdc_req *request; - krb5_kdc_rep *as_reply; +verify_as_reply(krb5_context context, + krb5_timestamp time_now, + krb5_kdc_req *request, + krb5_kdc_rep *as_reply) { krb5_error_code retval; @@ -288,13 +283,12 @@ verify_as_reply(context, time_now, request, as_reply) } static krb5_error_code -stash_as_reply(context, time_now, request, as_reply, creds, ccache) - krb5_context context; - krb5_timestamp time_now; - krb5_kdc_req *request; - krb5_kdc_rep *as_reply; - krb5_creds * creds; - krb5_ccache ccache; +stash_as_reply(krb5_context context, + krb5_timestamp time_now, + krb5_kdc_req *request, + krb5_kdc_rep *as_reply, + krb5_creds * creds, + krb5_ccache ccache) { krb5_error_code retval; krb5_data * packet; @@ -372,11 +366,10 @@ cleanup: } static krb5_error_code -make_preauth_list(context, ptypes, nptypes, ret_list) - krb5_context context; - krb5_preauthtype * ptypes; - int nptypes; - krb5_pa_data *** ret_list; +make_preauth_list(krb5_context context, + krb5_preauthtype * ptypes, + int nptypes, + krb5_pa_data *** ret_list) { krb5_preauthtype * ptypep; krb5_pa_data ** preauthp; @@ -418,20 +411,18 @@ make_preauth_list(context, ptypes, nptypes, ret_list) #define MAX_IN_TKT_LOOPS 16 krb5_error_code KRB5_CALLCONV -krb5_get_in_tkt(context, options, addrs, ktypes, ptypes, key_proc, keyseed, - decrypt_proc, decryptarg, creds, ccache, ret_as_reply) - krb5_context context; - const krb5_flags options; - krb5_address * const * addrs; - krb5_enctype * ktypes; - krb5_preauthtype * ptypes; - git_key_proc key_proc; - krb5_const_pointer keyseed; - git_decrypt_proc decrypt_proc; - krb5_const_pointer decryptarg; - krb5_creds * creds; - krb5_ccache ccache; - krb5_kdc_rep ** ret_as_reply; +krb5_get_in_tkt(krb5_context context, + const krb5_flags options, + krb5_address * const * addrs, + krb5_enctype * ktypes, + krb5_preauthtype * ptypes, + git_key_proc key_proc, + krb5_const_pointer keyseed, + git_decrypt_proc decrypt_proc, + krb5_const_pointer decryptarg, + krb5_creds * creds, + krb5_ccache ccache, + krb5_kdc_rep ** ret_as_reply) { krb5_error_code retval; krb5_timestamp time_now; @@ -611,8 +602,7 @@ static const char *conf_no[] = { }; int -_krb5_conf_boolean(s) - const char *s; +_krb5_conf_boolean(const char *s) { const char **p; @@ -631,11 +621,8 @@ _krb5_conf_boolean(s) } static krb5_error_code -krb5_libdefault_string(context, realm, option, ret_value) - krb5_context context; - const krb5_data *realm; - const char *option; - char **ret_value; +krb5_libdefault_string(krb5_context context, const krb5_data *realm, + const char *option, char **ret_value) { profile_t profile; const char *names[5]; @@ -708,11 +695,8 @@ goodbye: /* as well as the DNS code */ krb5_error_code -krb5_libdefault_boolean(context, realm, option, ret_value) - krb5_context context; - const char *option; - const krb5_data *realm; - int *ret_value; +krb5_libdefault_boolean(krb5_context context, const krb5_data *realm, + const char *option, int *ret_value) { char *string = NULL; krb5_error_code retval; @@ -729,21 +713,18 @@ krb5_libdefault_boolean(context, realm, option, ret_value) } krb5_error_code KRB5_CALLCONV -krb5_get_init_creds(context, creds, client, prompter, prompter_data, - start_time, in_tkt_service, options, gak_fct, gak_data, - use_master, as_reply) - krb5_context context; - krb5_creds *creds; - krb5_principal client; - krb5_prompter_fct prompter; - void *prompter_data; - krb5_deltat start_time; - char *in_tkt_service; - krb5_get_init_creds_opt *options; - krb5_gic_get_as_key_fct gak_fct; - void *gak_data; - int use_master; - krb5_kdc_rep **as_reply; +krb5_get_init_creds(krb5_context context, + krb5_creds *creds, + krb5_principal client, + krb5_prompter_fct prompter, + void *prompter_data, + krb5_deltat start_time, + char *in_tkt_service, + krb5_get_init_creds_opt *options, + krb5_gic_get_as_key_fct gak_fct, + void *gak_data, + int use_master, + krb5_kdc_rep **as_reply) { krb5_error_code ret; krb5_kdc_req request; diff --git a/src/lib/krb5/krb/gic_keytab.c b/src/lib/krb5/krb/gic_keytab.c index 4fd0aed93..d9ca6a402 100644 --- a/src/lib/krb5/krb/gic_keytab.c +++ b/src/lib/krb5/krb/gic_keytab.c @@ -49,15 +49,7 @@ krb5_get_as_key_keytab( } krb5_error_code KRB5_CALLCONV -krb5_get_init_creds_keytab(context, creds, client, arg_keytab, - start_time, in_tkt_service, options) - krb5_context context; - krb5_creds *creds; - krb5_principal client; - krb5_keytab arg_keytab; - krb5_deltat start_time; - char *in_tkt_service; - krb5_get_init_creds_opt *options; +krb5_get_init_creds_keytab(krb5_context context, krb5_creds *creds, krb5_principal client, krb5_keytab arg_keytab, krb5_deltat start_time, char *in_tkt_service, krb5_get_init_creds_opt *options) { krb5_error_code ret, ret2; int use_master; diff --git a/src/lib/krb5/krb/gic_opt.c b/src/lib/krb5/krb/gic_opt.c index d98225fb9..58d07b03d 100644 --- a/src/lib/krb5/krb/gic_opt.c +++ b/src/lib/krb5/krb/gic_opt.c @@ -1,53 +1,41 @@ #include "k5-int.h" void KRB5_CALLCONV -krb5_get_init_creds_opt_init(opt) - krb5_get_init_creds_opt *opt; +krb5_get_init_creds_opt_init(krb5_get_init_creds_opt *opt) { opt->flags = 0; } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_tkt_life(opt, tkt_life) - krb5_get_init_creds_opt *opt; - krb5_deltat tkt_life; +krb5_get_init_creds_opt_set_tkt_life(krb5_get_init_creds_opt *opt, krb5_deltat tkt_life) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_TKT_LIFE; opt->tkt_life = tkt_life; } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_renew_life(opt, renew_life) - krb5_get_init_creds_opt *opt; - krb5_deltat renew_life; +krb5_get_init_creds_opt_set_renew_life(krb5_get_init_creds_opt *opt, krb5_deltat renew_life) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_RENEW_LIFE; opt->renew_life = renew_life; } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_forwardable(opt, forwardable) - krb5_get_init_creds_opt *opt; - int forwardable; +krb5_get_init_creds_opt_set_forwardable(krb5_get_init_creds_opt *opt, int forwardable) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_FORWARDABLE; opt->forwardable = forwardable; } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_proxiable(opt, proxiable) - krb5_get_init_creds_opt *opt; - int proxiable; +krb5_get_init_creds_opt_set_proxiable(krb5_get_init_creds_opt *opt, int proxiable) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_PROXIABLE; opt->proxiable = proxiable; } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_etype_list(opt, etype_list, etype_list_length) - krb5_get_init_creds_opt *opt; - krb5_enctype *etype_list; - int etype_list_length; +krb5_get_init_creds_opt_set_etype_list(krb5_get_init_creds_opt *opt, krb5_enctype *etype_list, int etype_list_length) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_ETYPE_LIST; opt->etype_list = etype_list; @@ -55,20 +43,14 @@ krb5_get_init_creds_opt_set_etype_list(opt, etype_list, etype_list_length) } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_address_list(opt, addresses) - krb5_get_init_creds_opt *opt; - krb5_address **addresses; +krb5_get_init_creds_opt_set_address_list(krb5_get_init_creds_opt *opt, krb5_address **addresses) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_ADDRESS_LIST; opt->address_list = addresses; } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_preauth_list(opt, preauth_list, - preauth_list_length) - krb5_get_init_creds_opt *opt; - krb5_preauthtype *preauth_list; - int preauth_list_length; +krb5_get_init_creds_opt_set_preauth_list(krb5_get_init_creds_opt *opt, krb5_preauthtype *preauth_list, int preauth_list_length) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_PREAUTH_LIST; opt->preauth_list = preauth_list; @@ -76,9 +58,7 @@ krb5_get_init_creds_opt_set_preauth_list(opt, preauth_list, } void KRB5_CALLCONV -krb5_get_init_creds_opt_set_salt(opt, salt) - krb5_get_init_creds_opt *opt; - krb5_data *salt; +krb5_get_init_creds_opt_set_salt(krb5_get_init_creds_opt *opt, krb5_data *salt) { opt->flags |= KRB5_GET_INIT_CREDS_OPT_SALT; opt->salt = salt; diff --git a/src/lib/krb5/krb/gic_pwd.c b/src/lib/krb5/krb/gic_pwd.c index 6d4fbc331..caa48c590 100644 --- a/src/lib/krb5/krb/gic_pwd.c +++ b/src/lib/krb5/krb/gic_pwd.c @@ -83,17 +83,7 @@ krb5_get_as_key_password( } krb5_error_code KRB5_CALLCONV -krb5_get_init_creds_password(context, creds, client, password, prompter, data, - start_time, in_tkt_service, options) - krb5_context context; - krb5_creds *creds; - krb5_principal client; - char *password; - krb5_prompter_fct prompter; - void *data; - krb5_deltat start_time; - char *in_tkt_service; - krb5_get_init_creds_opt *options; +krb5_get_init_creds_password(krb5_context context, krb5_creds *creds, krb5_principal client, char *password, krb5_prompter_fct prompter, void *data, krb5_deltat start_time, char *in_tkt_service, krb5_get_init_creds_opt *options) { krb5_error_code ret, ret2; int use_master; diff --git a/src/lib/krb5/krb/in_tkt_ktb.c b/src/lib/krb5/krb/in_tkt_ktb.c index 5d8cf3c6d..db4f3b411 100644 --- a/src/lib/krb5/krb/in_tkt_ktb.c +++ b/src/lib/krb5/krb/in_tkt_ktb.c @@ -48,12 +48,8 @@ static krb5_error_code keytab_keyproc krb5_keyblock **); static krb5_error_code -keytab_keyproc(context, type, salt, keyseed, key) - krb5_context context; - const krb5_enctype type; - krb5_data * salt; - krb5_const_pointer keyseed; - krb5_keyblock ** key; +keytab_keyproc(krb5_context context, krb5_enctype type, krb5_data *salt, + krb5_const_pointer keyseed, krb5_keyblock **key) { const struct keytab_keyproc_arg * arg = (const struct keytab_keyproc_arg *)keyseed; @@ -110,17 +106,11 @@ cleanup: */ krb5_error_code KRB5_CALLCONV -krb5_get_in_tkt_with_keytab(context, options, addrs, ktypes, pre_auth_types, - keytab, ccache, creds, ret_as_reply) - krb5_context context; - const krb5_flags options; - krb5_address * const * addrs; - krb5_enctype * ktypes; - krb5_preauthtype * pre_auth_types; - const krb5_keytab keytab; - krb5_ccache ccache; - krb5_creds * creds; - krb5_kdc_rep ** ret_as_reply; +krb5_get_in_tkt_with_keytab(krb5_context context, krb5_flags options, + krb5_address *const *addrs, krb5_enctype *ktypes, + krb5_preauthtype *pre_auth_types, + krb5_keytab keytab, krb5_ccache ccache, + krb5_creds *creds, krb5_kdc_rep **ret_as_reply) { struct keytab_keyproc_arg arg; diff --git a/src/lib/krb5/krb/in_tkt_pwd.c b/src/lib/krb5/krb/in_tkt_pwd.c index 775a85f98..1d9ad2ef4 100644 --- a/src/lib/krb5/krb/in_tkt_pwd.c +++ b/src/lib/krb5/krb/in_tkt_pwd.c @@ -42,12 +42,8 @@ static krb5_error_code pwd_keyproc krb5_keyblock **); static krb5_error_code -pwd_keyproc(context, type, salt, keyseed, key) - krb5_context context; - const krb5_enctype type; - krb5_data * salt; - krb5_const_pointer keyseed; - krb5_keyblock ** key; +pwd_keyproc(krb5_context context, krb5_enctype type, krb5_data *salt, + krb5_const_pointer keyseed, krb5_keyblock **key) { krb5_error_code retval; krb5_data * password; @@ -96,17 +92,11 @@ pwd_keyproc(context, type, salt, keyseed, key) returns system errors, encryption errors */ krb5_error_code KRB5_CALLCONV -krb5_get_in_tkt_with_password(context, options, addrs, ktypes, pre_auth_types, - password, ccache, creds, ret_as_reply) - krb5_context context; - const krb5_flags options; - krb5_address * const * addrs; - krb5_enctype * ktypes; - krb5_preauthtype * pre_auth_types; - const char * password; - krb5_ccache ccache; - krb5_creds * creds; - krb5_kdc_rep ** ret_as_reply; +krb5_get_in_tkt_with_password(krb5_context context, krb5_flags options, + krb5_address *const *addrs, krb5_enctype *ktypes, + krb5_preauthtype *pre_auth_types, + const char *password, krb5_ccache ccache, + krb5_creds *creds, krb5_kdc_rep **ret_as_reply) { krb5_error_code retval; krb5_data data; diff --git a/src/lib/krb5/krb/in_tkt_sky.c b/src/lib/krb5/krb/in_tkt_sky.c index 168ada566..6de207550 100644 --- a/src/lib/krb5/krb/in_tkt_sky.c +++ b/src/lib/krb5/krb/in_tkt_sky.c @@ -48,12 +48,8 @@ static krb5_error_code skey_keyproc krb5_keyblock **); static krb5_error_code -skey_keyproc(context, type, salt, keyseed, key) - krb5_context context; - const krb5_enctype type; - krb5_data * salt; - krb5_const_pointer keyseed; - krb5_keyblock ** key; +skey_keyproc(krb5_context context, krb5_enctype type, krb5_data *salt, + krb5_const_pointer keyseed, krb5_keyblock **key) { krb5_keyblock *realkey; krb5_error_code retval; @@ -98,18 +94,11 @@ skey_keyproc(context, type, salt, keyseed, key) */ krb5_error_code KRB5_CALLCONV -krb5_get_in_tkt_with_skey(context, options, addrs, ktypes, pre_auth_types, - key, ccache, creds, ret_as_reply) - krb5_context context; - const krb5_flags options; - krb5_address * const * addrs; - krb5_enctype * ktypes; - krb5_preauthtype * pre_auth_types; - const krb5_keyblock * key; - krb5_ccache ccache; - krb5_creds * creds; - krb5_kdc_rep ** ret_as_reply; - +krb5_get_in_tkt_with_skey(krb5_context context, krb5_flags options, + krb5_address *const *addrs, krb5_enctype *ktypes, + krb5_preauthtype *pre_auth_types, + const krb5_keyblock *key, krb5_ccache ccache, + krb5_creds *creds, krb5_kdc_rep **ret_as_reply) { if (key) return krb5_get_in_tkt(context, options, addrs, ktypes, pre_auth_types, diff --git a/src/lib/krb5/krb/init_ctx.c b/src/lib/krb5/krb/init_ctx.c index 24d30e9af..05762cdb8 100644 --- a/src/lib/krb5/krb/init_ctx.c +++ b/src/lib/krb5/krb/init_ctx.c @@ -76,16 +76,14 @@ extern void krb5_win_ccdll_load(krb5_context context); static krb5_error_code init_common (krb5_context *, krb5_boolean); krb5_error_code KRB5_CALLCONV -krb5_init_context(context) - krb5_context *context; +krb5_init_context(krb5_context *context) { return init_common (context, FALSE); } krb5_error_code KRB5_CALLCONV -krb5_init_secure_context(context) - krb5_context *context; +krb5_init_secure_context(krb5_context *context) { /* This is to make gcc -Wall happy */ @@ -94,9 +92,7 @@ krb5_init_secure_context(context) } static krb5_error_code -init_common (context, secure) - krb5_context *context; - krb5_boolean secure; +init_common (krb5_context *context, krb5_boolean secure) { krb5_context ctx = 0; krb5_error_code retval; @@ -232,8 +228,7 @@ cleanup: } void KRB5_CALLCONV -krb5_free_context(ctx) - krb5_context ctx; +krb5_free_context(krb5_context ctx) { krb5_free_ets(ctx); krb5_os_free_context(ctx); @@ -266,9 +261,7 @@ krb5_free_context(ctx) * Set the desired default ktypes, making sure they are valid. */ krb5_error_code -krb5_set_default_in_tkt_ktypes(context, ktypes) - krb5_context context; - const krb5_enctype *ktypes; +krb5_set_default_in_tkt_ktypes(krb5_context context, const krb5_enctype *ktypes) { krb5_enctype * new_ktypes; int i; @@ -298,12 +291,7 @@ krb5_set_default_in_tkt_ktypes(context, ktypes) } static krb5_error_code -get_profile_etype_list(context, ktypes, profstr, ctx_count, ctx_list) - krb5_context context; - krb5_enctype **ktypes; - char *profstr; - int ctx_count; - krb5_enctype *ctx_list; +get_profile_etype_list(krb5_context context, krb5_enctype **ktypes, char *profstr, int ctx_count, krb5_enctype *ctx_list) { krb5_enctype *old_ktypes; @@ -383,9 +371,7 @@ get_profile_etype_list(context, ktypes, profstr, ctx_count, ctx_list) } krb5_error_code -krb5_get_default_in_tkt_ktypes(context, ktypes) - krb5_context context; - krb5_enctype **ktypes; +krb5_get_default_in_tkt_ktypes(krb5_context context, krb5_enctype **ktypes) { return(get_profile_etype_list(context, ktypes, "default_tkt_enctypes", context->in_tkt_ktype_count, @@ -393,9 +379,7 @@ krb5_get_default_in_tkt_ktypes(context, ktypes) } krb5_error_code KRB5_CALLCONV -krb5_set_default_tgs_enctypes (context, ktypes) - krb5_context context; - const krb5_enctype *ktypes; +krb5_set_default_tgs_enctypes (krb5_context context, const krb5_enctype *ktypes) { krb5_enctype * new_ktypes; int i; @@ -433,19 +417,14 @@ krb5_error_code krb5_set_default_tgs_ktypes void KRB5_CALLCONV -krb5_free_ktypes (context, val) - krb5_context context; - krb5_enctype *val; +krb5_free_ktypes (krb5_context context, krb5_enctype *val) { free (val); } krb5_error_code KRB5_CALLCONV -krb5_get_tgs_ktypes(context, princ, ktypes) - krb5_context context; - krb5_const_principal princ; - krb5_enctype **ktypes; +krb5_get_tgs_ktypes(krb5_context context, krb5_const_principal princ, krb5_enctype **ktypes) { return(get_profile_etype_list(context, ktypes, "default_tgs_enctypes", context->tgs_ktype_count, @@ -453,9 +432,7 @@ krb5_get_tgs_ktypes(context, princ, ktypes) } krb5_error_code -krb5_get_permitted_enctypes(context, ktypes) - krb5_context context; - krb5_enctype **ktypes; +krb5_get_permitted_enctypes(krb5_context context, krb5_enctype **ktypes) { return(get_profile_etype_list(context, ktypes, "permitted_enctypes", context->tgs_ktype_count, @@ -463,9 +440,7 @@ krb5_get_permitted_enctypes(context, ktypes) } krb5_boolean -krb5_is_permitted_enctype(context, etype) - krb5_context context; - krb5_enctype etype; +krb5_is_permitted_enctype(krb5_context context, krb5_enctype etype) { krb5_enctype *list, *ptr; krb5_boolean ret; diff --git a/src/lib/krb5/krb/kdc_rep_dc.c b/src/lib/krb5/krb/kdc_rep_dc.c index 7a0fb2e67..42559b2f1 100644 --- a/src/lib/krb5/krb/kdc_rep_dc.c +++ b/src/lib/krb5/krb/kdc_rep_dc.c @@ -37,11 +37,7 @@ /*ARGSUSED*/ krb5_error_code -krb5_kdc_rep_decrypt_proc(context, key, decryptarg, dec_rep) - krb5_context context; - const krb5_keyblock * key; - krb5_const_pointer decryptarg; - krb5_kdc_rep * dec_rep; +krb5_kdc_rep_decrypt_proc(krb5_context context, const krb5_keyblock *key, krb5_const_pointer decryptarg, krb5_kdc_rep *dec_rep) { krb5_error_code retval; krb5_data scratch; diff --git a/src/lib/krb5/krb/kfree.c b/src/lib/krb5/krb/kfree.c index da7d294db..60a3c6182 100644 --- a/src/lib/krb5/krb/kfree.c +++ b/src/lib/krb5/krb/kfree.c @@ -29,9 +29,7 @@ #include "k5-int.h" void KRB5_CALLCONV -krb5_free_address(context, val) - krb5_context context; - krb5_address *val; +krb5_free_address(krb5_context context, krb5_address *val) { if (val->contents) krb5_xfree(val->contents); @@ -39,9 +37,7 @@ krb5_free_address(context, val) } void KRB5_CALLCONV -krb5_free_addresses(context, val) - krb5_context context; - krb5_address **val; +krb5_free_addresses(krb5_context context, krb5_address **val) { register krb5_address **temp; @@ -55,9 +51,7 @@ krb5_free_addresses(context, val) void KRB5_CALLCONV -krb5_free_ap_rep(context, val) - krb5_context context; - register krb5_ap_rep *val; +krb5_free_ap_rep(krb5_context context, register krb5_ap_rep *val) { if (val->enc_part.ciphertext.data) krb5_xfree(val->enc_part.ciphertext.data); @@ -65,9 +59,7 @@ krb5_free_ap_rep(context, val) } void KRB5_CALLCONV -krb5_free_ap_req(context, val) - krb5_context context; - register krb5_ap_req *val; +krb5_free_ap_req(krb5_context context, register krb5_ap_req *val) { if (val->ticket) krb5_free_ticket(context, val->ticket); @@ -77,9 +69,7 @@ krb5_free_ap_req(context, val) } void KRB5_CALLCONV -krb5_free_ap_rep_enc_part(context, val) - krb5_context context; - krb5_ap_rep_enc_part *val; +krb5_free_ap_rep_enc_part(krb5_context context, krb5_ap_rep_enc_part *val) { if (val->subkey) krb5_free_keyblock(context, val->subkey); @@ -87,9 +77,7 @@ krb5_free_ap_rep_enc_part(context, val) } void KRB5_CALLCONV -krb5_free_authenticator_contents(context, val) - krb5_context context; - krb5_authenticator *val; +krb5_free_authenticator_contents(krb5_context context, krb5_authenticator *val) { if (val->checksum) { krb5_free_checksum(context, val->checksum); @@ -110,9 +98,7 @@ krb5_free_authenticator_contents(context, val) } void KRB5_CALLCONV -krb5_free_authdata(context, val) - krb5_context context; - krb5_authdata **val; +krb5_free_authdata(krb5_context context, krb5_authdata **val) { register krb5_authdata **temp; @@ -125,27 +111,21 @@ krb5_free_authdata(context, val) } void KRB5_CALLCONV -krb5_free_authenticator(context, val) - krb5_context context; - krb5_authenticator *val; +krb5_free_authenticator(krb5_context context, krb5_authenticator *val) { krb5_free_authenticator_contents(context, val); krb5_xfree(val); } void KRB5_CALLCONV -krb5_free_checksum(context, val) - krb5_context context; - register krb5_checksum *val; +krb5_free_checksum(krb5_context context, register krb5_checksum *val) { krb5_free_checksum_contents(context, val); krb5_xfree(val); } void KRB5_CALLCONV -krb5_free_checksum_contents(context, val) - krb5_context context; - register krb5_checksum *val; +krb5_free_checksum_contents(krb5_context context, register krb5_checksum *val) { if (val->contents) { krb5_xfree(val->contents); @@ -154,9 +134,7 @@ krb5_free_checksum_contents(context, val) } void KRB5_CALLCONV -krb5_free_cred(context, val) - krb5_context context; - register krb5_cred *val; +krb5_free_cred(krb5_context context, register krb5_cred *val) { if (val->tickets) krb5_free_tickets(context, val->tickets); @@ -171,9 +149,7 @@ krb5_free_cred(context, val) */ void KRB5_CALLCONV -krb5_free_cred_contents(context, val) - krb5_context context; - krb5_creds *val; +krb5_free_cred_contents(krb5_context context, krb5_creds *val) { if (val->client) { krb5_free_principal(context, val->client); @@ -207,9 +183,7 @@ krb5_free_cred_contents(context, val) } void KRB5_CALLCONV -krb5_free_cred_enc_part(context, val) - krb5_context context; - register krb5_cred_enc_part *val; +krb5_free_cred_enc_part(krb5_context context, register krb5_cred_enc_part *val) { register krb5_cred_info **temp; @@ -241,9 +215,7 @@ krb5_free_cred_enc_part(context, val) void KRB5_CALLCONV -krb5_free_creds(context, val) - krb5_context context; - krb5_creds *val; +krb5_free_creds(krb5_context context, krb5_creds *val) { krb5_free_cred_contents(context, val); krb5_xfree(val); @@ -251,9 +223,7 @@ krb5_free_creds(context, val) void KRB5_CALLCONV -krb5_free_data(context, val) - krb5_context context; - krb5_data * val; +krb5_free_data(krb5_context context, krb5_data *val) { if (val->data) krb5_xfree(val->data); @@ -261,9 +231,7 @@ krb5_free_data(context, val) } void KRB5_CALLCONV -krb5_free_data_contents(context, val) - krb5_context context; - krb5_data * val; +krb5_free_data_contents(krb5_context context, krb5_data *val) { if (val->data) { krb5_xfree(val->data); @@ -271,9 +239,7 @@ krb5_free_data_contents(context, val) } } -void krb5_free_etype_info(context, info) - krb5_context context; - krb5_etype_info info; +void krb5_free_etype_info(krb5_context context, krb5_etype_info info) { int i; @@ -287,9 +253,7 @@ void krb5_free_etype_info(context, info) void KRB5_CALLCONV -krb5_free_enc_kdc_rep_part(context, val) - krb5_context context; - register krb5_enc_kdc_rep_part *val; +krb5_free_enc_kdc_rep_part(krb5_context context, register krb5_enc_kdc_rep_part *val) { if (val->session) krb5_free_keyblock(context, val->session); @@ -303,9 +267,7 @@ krb5_free_enc_kdc_rep_part(context, val) } void KRB5_CALLCONV -krb5_free_enc_tkt_part(context, val) - krb5_context context; - krb5_enc_tkt_part *val; +krb5_free_enc_tkt_part(krb5_context context, krb5_enc_tkt_part *val) { if (val->session) krb5_free_keyblock(context, val->session); @@ -322,9 +284,7 @@ krb5_free_enc_tkt_part(context, val) void KRB5_CALLCONV -krb5_free_error(context, val) - krb5_context context; - register krb5_error *val; +krb5_free_error(krb5_context context, register krb5_error *val) { if (val->client) krb5_free_principal(context, val->client); @@ -338,9 +298,7 @@ krb5_free_error(context, val) } void KRB5_CALLCONV -krb5_free_kdc_rep(context, val) - krb5_context context; - krb5_kdc_rep *val; +krb5_free_kdc_rep(krb5_context context, krb5_kdc_rep *val) { if (val->padata) krb5_free_pa_data(context, val->padata); @@ -357,9 +315,7 @@ krb5_free_kdc_rep(context, val) void KRB5_CALLCONV -krb5_free_kdc_req(context, val) - krb5_context context; - krb5_kdc_req *val; +krb5_free_kdc_req(krb5_context context, krb5_kdc_req *val) { if (val->padata) krb5_free_pa_data(context, val->padata); @@ -381,9 +337,7 @@ krb5_free_kdc_req(context, val) } void KRB5_CALLCONV -krb5_free_keyblock_contents(context, key) - krb5_context context; - register krb5_keyblock *key; +krb5_free_keyblock_contents(krb5_context context, register krb5_keyblock *key) { if (key->contents) { memset(key->contents, 0, key->length); @@ -393,9 +347,7 @@ krb5_free_keyblock_contents(context, key) } void KRB5_CALLCONV -krb5_free_keyblock(context, val) - krb5_context context; - register krb5_keyblock *val; +krb5_free_keyblock(krb5_context context, register krb5_keyblock *val) { krb5_free_keyblock_contents(context, val); krb5_xfree(val); @@ -404,9 +356,7 @@ krb5_free_keyblock(context, val) void KRB5_CALLCONV -krb5_free_last_req(context, val) - krb5_context context; - krb5_last_req_entry **val; +krb5_free_last_req(krb5_context context, krb5_last_req_entry **val) { register krb5_last_req_entry **temp; @@ -416,9 +366,7 @@ krb5_free_last_req(context, val) } void KRB5_CALLCONV -krb5_free_pa_data(context, val) - krb5_context context; - krb5_pa_data **val; +krb5_free_pa_data(krb5_context context, krb5_pa_data **val) { register krb5_pa_data **temp; @@ -431,9 +379,7 @@ krb5_free_pa_data(context, val) } void KRB5_CALLCONV -krb5_free_principal(context, val) - krb5_context context; - krb5_principal val; +krb5_free_principal(krb5_context context, krb5_principal val) { register krb5_int32 i; @@ -452,9 +398,7 @@ krb5_free_principal(context, val) } void KRB5_CALLCONV -krb5_free_priv(context, val) - krb5_context context; - register krb5_priv *val; +krb5_free_priv(krb5_context context, register krb5_priv *val) { if (val->enc_part.ciphertext.data) krb5_xfree(val->enc_part.ciphertext.data); @@ -462,9 +406,7 @@ krb5_free_priv(context, val) } void KRB5_CALLCONV -krb5_free_priv_enc_part(context, val) - krb5_context context; - register krb5_priv_enc_part *val; +krb5_free_priv_enc_part(krb5_context context, register krb5_priv_enc_part *val) { if (val->user_data.data) krb5_xfree(val->user_data.data); @@ -476,9 +418,7 @@ krb5_free_priv_enc_part(context, val) } void KRB5_CALLCONV -krb5_free_pwd_data(context, val) - krb5_context context; - krb5_pwd_data *val; +krb5_free_pwd_data(krb5_context context, krb5_pwd_data *val) { if (val->element) krb5_free_pwd_sequences(context, val->element); @@ -487,9 +427,7 @@ krb5_free_pwd_data(context, val) void KRB5_CALLCONV -krb5_free_pwd_sequences(context, val) - krb5_context context; - passwd_phrase_element **val; +krb5_free_pwd_sequences(krb5_context context, passwd_phrase_element **val) { if ((*val)->passwd) { krb5_xfree((*val)->passwd); @@ -503,9 +441,7 @@ krb5_free_pwd_sequences(context, val) void KRB5_CALLCONV -krb5_free_safe(context, val) - krb5_context context; - register krb5_safe *val; +krb5_free_safe(krb5_context context, register krb5_safe *val) { if (val->user_data.data) krb5_xfree(val->user_data.data); @@ -520,9 +456,7 @@ krb5_free_safe(context, val) void KRB5_CALLCONV -krb5_free_ticket(context, val) - krb5_context context; - krb5_ticket *val; +krb5_free_ticket(krb5_context context, krb5_ticket *val) { if (val->server) krb5_free_principal(context, val->server); @@ -534,9 +468,7 @@ krb5_free_ticket(context, val) } void KRB5_CALLCONV -krb5_free_tickets(context, val) - krb5_context context; - krb5_ticket **val; +krb5_free_tickets(krb5_context context, krb5_ticket **val) { register krb5_ticket **temp; @@ -547,9 +479,7 @@ krb5_free_tickets(context, val) void KRB5_CALLCONV -krb5_free_tgt_creds(context, tgts) - krb5_context context; - krb5_creds **tgts; +krb5_free_tgt_creds(krb5_context context, krb5_creds **tgts) { register krb5_creds **tgtpp; for (tgtpp = tgts; *tgtpp; tgtpp++) @@ -558,9 +488,7 @@ krb5_free_tgt_creds(context, tgts) } void KRB5_CALLCONV -krb5_free_tkt_authent(context, val) - krb5_context context; - krb5_tkt_authent *val; +krb5_free_tkt_authent(krb5_context context, krb5_tkt_authent *val) { if (val->ticket) krb5_free_ticket(context, val->ticket); @@ -570,9 +498,7 @@ krb5_free_tkt_authent(context, val) } void KRB5_CALLCONV -krb5_free_unparsed_name(context, val) - krb5_context context; - char * val; +krb5_free_unparsed_name(krb5_context context, char *val) { if (val) krb5_xfree(val); diff --git a/src/lib/krb5/krb/mk_cred.c b/src/lib/krb5/krb/mk_cred.c index 22713917a..638929861 100644 --- a/src/lib/krb5/krb/mk_cred.c +++ b/src/lib/krb5/krb/mk_cred.c @@ -21,11 +21,7 @@ * encrypt the enc_part of krb5_cred */ static krb5_error_code -encrypt_credencpart(context, pcredpart, pkeyblock, pencdata) - krb5_context context; - krb5_cred_enc_part * pcredpart; - krb5_keyblock * pkeyblock; - krb5_enc_data * pencdata; +encrypt_credencpart(krb5_context context, krb5_cred_enc_part *pcredpart, krb5_keyblock *pkeyblock, krb5_enc_data *pencdata) { krb5_error_code retval; krb5_data * scratch; @@ -66,16 +62,7 @@ encrypt_credencpart(context, pcredpart, pkeyblock, pencdata) /*----------------------- krb5_mk_ncred_basic -----------------------*/ static krb5_error_code -krb5_mk_ncred_basic(context, ppcreds, nppcreds, keyblock, - replaydata, local_addr, remote_addr, pcred) - krb5_context context; - krb5_creds ** ppcreds; - krb5_int32 nppcreds; - krb5_keyblock * keyblock; - krb5_replay_data * replaydata; - krb5_address * local_addr; - krb5_address * remote_addr; - krb5_cred * pcred; +krb5_mk_ncred_basic(krb5_context context, krb5_creds **ppcreds, krb5_int32 nppcreds, krb5_keyblock *keyblock, krb5_replay_data *replaydata, krb5_address *local_addr, krb5_address *remote_addr, krb5_cred *pcred) { krb5_cred_enc_part credenc; krb5_error_code retval; @@ -158,13 +145,7 @@ cleanup: * outputs an encoded KRB_CRED message suitable for krb5_rd_cred */ krb5_error_code KRB5_CALLCONV -krb5_mk_ncred(context, auth_context, ppcreds, ppdata, outdata) - - krb5_context context; - krb5_auth_context auth_context; - krb5_creds ** ppcreds; - krb5_data ** ppdata; - krb5_replay_data * outdata; +krb5_mk_ncred(krb5_context context, krb5_auth_context auth_context, krb5_creds **ppcreds, krb5_data **ppdata, krb5_replay_data *outdata) { krb5_address * premote_fulladdr = NULL; krb5_address * plocal_fulladdr = NULL; @@ -306,12 +287,7 @@ error: * A convenience function that calls krb5_mk_ncred. */ krb5_error_code KRB5_CALLCONV -krb5_mk_1cred(context, auth_context, pcreds, ppdata, outdata) - krb5_context context; - krb5_auth_context auth_context; - krb5_creds * pcreds; - krb5_data ** ppdata; - krb5_replay_data * outdata; +krb5_mk_1cred(krb5_context context, krb5_auth_context auth_context, krb5_creds *pcreds, krb5_data **ppdata, krb5_replay_data *outdata) { krb5_error_code retval; krb5_creds **ppcreds; diff --git a/src/lib/krb5/krb/mk_error.c b/src/lib/krb5/krb/mk_error.c index bd9519e7d..0444a5d17 100644 --- a/src/lib/krb5/krb/mk_error.c +++ b/src/lib/krb5/krb/mk_error.c @@ -38,10 +38,7 @@ returns system errors */ krb5_error_code KRB5_CALLCONV -krb5_mk_error(context, dec_err, enc_err) - krb5_context context; - const krb5_error *dec_err; - krb5_data *enc_err; +krb5_mk_error(krb5_context context, const krb5_error *dec_err, krb5_data *enc_err) { krb5_error_code retval; krb5_data *new_enc_err; diff --git a/src/lib/krb5/krb/mk_priv.c b/src/lib/krb5/krb/mk_priv.c index 13ad61940..196b6eea0 100644 --- a/src/lib/krb5/krb/mk_priv.c +++ b/src/lib/krb5/krb/mk_priv.c @@ -32,16 +32,7 @@ #include "auth_con.h" static krb5_error_code -krb5_mk_priv_basic(context, userdata, keyblock, replaydata, local_addr, - remote_addr, i_vector, outbuf) - krb5_context context; - const krb5_data * userdata; - const krb5_keyblock * keyblock; - krb5_replay_data * replaydata; - krb5_address * local_addr; - krb5_address * remote_addr; - krb5_pointer i_vector; - krb5_data * outbuf; +krb5_mk_priv_basic(krb5_context context, const krb5_data *userdata, const krb5_keyblock *keyblock, krb5_replay_data *replaydata, krb5_address *local_addr, krb5_address *remote_addr, krb5_pointer i_vector, krb5_data *outbuf) { krb5_error_code retval; krb5_priv privmsg; @@ -116,12 +107,9 @@ clean_scratch: krb5_error_code KRB5_CALLCONV -krb5_mk_priv(context, auth_context, userdata, outbuf, outdata) - krb5_context context; - krb5_auth_context auth_context; - const krb5_data * userdata; - krb5_data * outbuf; - krb5_replay_data * outdata; +krb5_mk_priv(krb5_context context, krb5_auth_context auth_context, + const krb5_data *userdata, krb5_data *outbuf, + krb5_replay_data *outdata) { krb5_error_code retval; krb5_keyblock * keyblock; diff --git a/src/lib/krb5/krb/mk_rep.c b/src/lib/krb5/krb/mk_rep.c index ad3e7cc29..31f3fe500 100644 --- a/src/lib/krb5/krb/mk_rep.c +++ b/src/lib/krb5/krb/mk_rep.c @@ -40,10 +40,7 @@ */ krb5_error_code KRB5_CALLCONV -krb5_mk_rep(context, auth_context, outbuf) - krb5_context context; - krb5_auth_context auth_context; - krb5_data * outbuf; +krb5_mk_rep(krb5_context context, krb5_auth_context auth_context, krb5_data *outbuf) { krb5_error_code retval; krb5_ap_rep_enc_part repl; diff --git a/src/lib/krb5/krb/mk_req.c b/src/lib/krb5/krb/mk_req.c index 340b4818f..2935e41b3 100644 --- a/src/lib/krb5/krb/mk_req.c +++ b/src/lib/krb5/krb/mk_req.c @@ -50,16 +50,9 @@ */ krb5_error_code KRB5_CALLCONV -krb5_mk_req(context, auth_context, ap_req_options, service, hostname, in_data, - ccache, outbuf) - krb5_context context; - krb5_auth_context * auth_context; - const krb5_flags ap_req_options; - char * service; - char * hostname; - krb5_data * in_data; - krb5_ccache ccache; - krb5_data * outbuf; +krb5_mk_req(krb5_context context, krb5_auth_context *auth_context, + krb5_flags ap_req_options, char *service, char *hostname, + krb5_data *in_data, krb5_ccache ccache, krb5_data *outbuf) { krb5_error_code retval; krb5_principal server; diff --git a/src/lib/krb5/krb/mk_req_ext.c b/src/lib/krb5/krb/mk_req_ext.c index cec4b8385..5e07f7b66 100644 --- a/src/lib/krb5/krb/mk_req_ext.c +++ b/src/lib/krb5/krb/mk_req_ext.c @@ -71,14 +71,9 @@ krb5_generate_authenticator (krb5_context, krb5_int32, krb5_authdata ** ); krb5_error_code KRB5_CALLCONV -krb5_mk_req_extended(context, auth_context, ap_req_options, in_data, in_creds, - outbuf) - krb5_context context; - krb5_auth_context * auth_context; - const krb5_flags ap_req_options; - krb5_data * in_data; - krb5_creds * in_creds; - krb5_data * outbuf; +krb5_mk_req_extended(krb5_context context, krb5_auth_context *auth_context, + krb5_flags ap_req_options, krb5_data *in_data, + krb5_creds *in_creds, krb5_data *outbuf) { krb5_error_code retval; krb5_checksum checksum; @@ -226,14 +221,7 @@ cleanup: } static krb5_error_code -krb5_generate_authenticator(context, authent, client, cksum, key, seq_number, authorization) - krb5_context context; - krb5_authenticator *authent; - krb5_principal client; - krb5_checksum *cksum; - krb5_keyblock *key; - krb5_int32 seq_number; - krb5_authdata **authorization; +krb5_generate_authenticator(krb5_context context, krb5_authenticator *authent, krb5_principal client, krb5_checksum *cksum, krb5_keyblock *key, krb5_int32 seq_number, krb5_authdata **authorization) { krb5_error_code retval; diff --git a/src/lib/krb5/krb/mk_safe.c b/src/lib/krb5/krb/mk_safe.c index 59fc388fb..992a456a9 100644 --- a/src/lib/krb5/krb/mk_safe.c +++ b/src/lib/krb5/krb/mk_safe.c @@ -47,16 +47,10 @@ returns system errors */ static krb5_error_code -krb5_mk_safe_basic(context, userdata, keyblock, replaydata, local_addr, - remote_addr, sumtype, outbuf) - krb5_context context; - const krb5_data * userdata; - const krb5_keyblock * keyblock; - krb5_replay_data * replaydata; - krb5_address * local_addr; - krb5_address * remote_addr; - const krb5_cksumtype sumtype; - krb5_data * outbuf; +krb5_mk_safe_basic(krb5_context context, const krb5_data *userdata, + const krb5_keyblock *keyblock, krb5_replay_data *replaydata, + krb5_address *local_addr, krb5_address *remote_addr, + krb5_cksumtype sumtype, krb5_data *outbuf) { krb5_error_code retval; krb5_safe safemsg; @@ -116,12 +110,7 @@ cleanup_checksum: } krb5_error_code KRB5_CALLCONV -krb5_mk_safe(context, auth_context, userdata, outbuf, outdata) - krb5_context context; - krb5_auth_context auth_context; - const krb5_data * userdata; - krb5_data * outbuf; - krb5_replay_data * outdata; +krb5_mk_safe(krb5_context context, krb5_auth_context auth_context, const krb5_data *userdata, krb5_data *outbuf, krb5_replay_data *outdata) { krb5_error_code retval; krb5_keyblock * keyblock; diff --git a/src/lib/krb5/krb/parse.c b/src/lib/krb5/krb/parse.c index 6aded4050..abbcfbe2d 100644 --- a/src/lib/krb5/krb/parse.c +++ b/src/lib/krb5/krb/parse.c @@ -64,10 +64,7 @@ * that arbitrarily large multi-component names are a Good Thing..... */ krb5_error_code KRB5_CALLCONV -krb5_parse_name(context, name, nprincipal) - krb5_context context; - const char *name; - krb5_principal *nprincipal; +krb5_parse_name(krb5_context context, const char *name, krb5_principal *nprincipal) { register const char *cp; register char *q; diff --git a/src/lib/krb5/krb/pr_to_salt.c b/src/lib/krb5/krb/pr_to_salt.c index 00d4f9f01..545d86fb1 100644 --- a/src/lib/krb5/krb/pr_to_salt.c +++ b/src/lib/krb5/krb/pr_to_salt.c @@ -36,11 +36,7 @@ static krb5_error_code krb5_principal2salt_internal * Convert a krb5_principal into the default salt for that principal. */ static krb5_error_code -krb5_principal2salt_internal(context, pr, ret, use_realm) - krb5_context context; - register krb5_const_principal pr; - krb5_data *ret; - int use_realm; +krb5_principal2salt_internal(krb5_context context, register krb5_const_principal pr, krb5_data *ret, int use_realm) { unsigned int size = 0, offset=0; krb5_int32 nelem; @@ -78,19 +74,13 @@ krb5_principal2salt_internal(context, pr, ret, use_realm) } krb5_error_code -krb5_principal2salt(context, pr, ret) - krb5_context context; - register krb5_const_principal pr; - krb5_data *ret; +krb5_principal2salt(krb5_context context, register krb5_const_principal pr, krb5_data *ret) { return krb5_principal2salt_internal(context, pr, ret, 1); } krb5_error_code -krb5_principal2salt_norealm(context, pr, ret) - krb5_context context; - register krb5_const_principal pr; - krb5_data *ret; +krb5_principal2salt_norealm(krb5_context context, register krb5_const_principal pr, krb5_data *ret) { return krb5_principal2salt_internal(context, pr, ret, 0); } diff --git a/src/lib/krb5/krb/preauth.c b/src/lib/krb5/krb/preauth.c index 10e335f1d..7970b4f10 100644 --- a/src/lib/krb5/krb/preauth.c +++ b/src/lib/krb5/krb/preauth.c @@ -131,14 +131,7 @@ typedef krb5_error_code (*git_decrypt_proc) (krb5_context, krb5_const_pointer, krb5_kdc_rep *); -krb5_error_code krb5_obtain_padata(context, preauth_to_use, key_proc, - key_seed, creds, request) - krb5_context context; - krb5_pa_data ** preauth_to_use; - git_key_proc key_proc; - krb5_const_pointer key_seed; - krb5_creds * creds; - krb5_kdc_req * request; +krb5_error_code krb5_obtain_padata(krb5_context context, krb5_pa_data **preauth_to_use, git_key_proc key_proc, krb5_const_pointer key_seed, krb5_creds *creds, krb5_kdc_req *request) { krb5_error_code retval; krb5_etype_info etype_info = 0; @@ -244,17 +237,7 @@ cleanup: } krb5_error_code -krb5_process_padata(context, request, as_reply, key_proc, keyseed, - decrypt_proc, decrypt_key, creds, do_more) - krb5_context context; - krb5_kdc_req * request; - krb5_kdc_rep * as_reply; - git_key_proc key_proc; - krb5_const_pointer keyseed; - git_decrypt_proc decrypt_proc; - krb5_keyblock ** decrypt_key; - krb5_creds * creds; - krb5_int32 * do_more; +krb5_process_padata(krb5_context context, krb5_kdc_req *request, krb5_kdc_rep *as_reply, git_key_proc key_proc, krb5_const_pointer keyseed, git_decrypt_proc decrypt_proc, krb5_keyblock **decrypt_key, krb5_creds *creds, krb5_int32 *do_more) { krb5_error_code retval = 0; krb5_preauth_ops * ops; @@ -291,17 +274,7 @@ cleanup: * in the user's key. */ static krb5_error_code -obtain_enc_ts_padata(context, in_padata, etype_info, def_enc_key, - key_proc, key_seed, creds, request, out_padata) - krb5_context context; - krb5_pa_data * in_padata; - krb5_etype_info etype_info; - krb5_keyblock * def_enc_key; - git_key_proc key_proc; - krb5_const_pointer key_seed; - krb5_creds * creds; - krb5_kdc_req * request; - krb5_pa_data ** out_padata; +obtain_enc_ts_padata(krb5_context context, krb5_pa_data *in_padata, krb5_etype_info etype_info, krb5_keyblock *def_enc_key, git_key_proc key_proc, krb5_const_pointer key_seed, krb5_creds *creds, krb5_kdc_req *request, krb5_pa_data **out_padata) { krb5_pa_enc_ts pa_enc; krb5_error_code retval; @@ -355,20 +328,7 @@ cleanup: } static krb5_error_code -process_pw_salt(context, padata, request, as_reply, - key_proc, keyseed, decrypt_proc, decrypt_key, - creds, do_more, done) - krb5_context context; - krb5_pa_data * padata; - krb5_kdc_req * request; - krb5_kdc_rep * as_reply; - git_key_proc key_proc; - krb5_const_pointer keyseed; - git_decrypt_proc decrypt_proc; - krb5_keyblock ** decrypt_key; - krb5_creds * creds; - krb5_int32 * do_more; - krb5_int32 * done; +process_pw_salt(krb5_context context, krb5_pa_data *padata, krb5_kdc_req *request, krb5_kdc_rep *as_reply, git_key_proc key_proc, krb5_const_pointer keyseed, git_decrypt_proc decrypt_proc, krb5_keyblock **decrypt_key, krb5_creds *creds, krb5_int32 *do_more, krb5_int32 *done) { krb5_error_code retval; krb5_data salt; @@ -390,9 +350,7 @@ process_pw_salt(context, padata, request, as_reply, } static krb5_error_code -find_pa_system(type, preauth) - krb5_preauthtype type; - krb5_preauth_ops **preauth; +find_pa_system(krb5_preauthtype type, krb5_preauth_ops **preauth) { krb5_preauth_ops *ap = preauth_systems; @@ -408,15 +366,7 @@ find_pa_system(type, preauth) extern const char *krb5_default_pwd_prompt1; static krb5_error_code -sam_get_pass_from_user(context, etype_info, key_proc, key_seed, request, - new_enc_key, prompt) - krb5_context context; - krb5_etype_info etype_info; - git_key_proc key_proc; - krb5_const_pointer key_seed; - krb5_kdc_req * request; - krb5_keyblock ** new_enc_key; - const char * prompt; +sam_get_pass_from_user(krb5_context context, krb5_etype_info etype_info, git_key_proc key_proc, krb5_const_pointer key_seed, krb5_kdc_req *request, krb5_keyblock **new_enc_key, const char *prompt) { krb5_enctype enctype; krb5_error_code retval; @@ -439,8 +389,7 @@ sam_get_pass_from_user(context, etype_info, key_proc, key_seed, request, return retval; } static -char *handle_sam_labels(sc) - krb5_sam_challenge *sc; +char *handle_sam_labels(krb5_sam_challenge *sc) { char *label = sc->sam_challenge_label.data; unsigned int label_len = sc->sam_challenge_label.length; @@ -510,17 +459,7 @@ char *handle_sam_labels(sc) * preauthentication type. It presents the challenge... */ static krb5_error_code -obtain_sam_padata(context, in_padata, etype_info, def_enc_key, - key_proc, key_seed, creds, request, out_padata) - krb5_context context; - krb5_pa_data * in_padata; - krb5_etype_info etype_info; - krb5_keyblock * def_enc_key; - git_key_proc key_proc; - krb5_const_pointer key_seed; - krb5_creds * creds; - krb5_kdc_req * request; - krb5_pa_data ** out_padata; +obtain_sam_padata(krb5_context context, krb5_pa_data *in_padata, krb5_etype_info etype_info, krb5_keyblock *def_enc_key, git_key_proc key_proc, krb5_const_pointer key_seed, krb5_creds *creds, krb5_kdc_req *request, krb5_pa_data **out_padata) { krb5_error_code retval; krb5_data * scratch; diff --git a/src/lib/krb5/krb/preauth2.c b/src/lib/krb5/krb/preauth2.c index 47feeca8a..9ee5cdfc5 100644 --- a/src/lib/krb5/krb/preauth2.c +++ b/src/lib/krb5/krb/preauth2.c @@ -178,8 +178,7 @@ krb5_error_code pa_enc_timestamp(krb5_context context, } static -char *sam_challenge_banner(sam_type) - krb5_int32 sam_type; +char *sam_challenge_banner(krb5_int32 sam_type) { char *label; diff --git a/src/lib/krb5/krb/princ_comp.c b/src/lib/krb5/krb/princ_comp.c index a270c8756..b61f525f4 100644 --- a/src/lib/krb5/krb/princ_comp.c +++ b/src/lib/krb5/krb/princ_comp.c @@ -31,10 +31,7 @@ #include "k5-int.h" krb5_boolean KRB5_CALLCONV -krb5_realm_compare(context, princ1, princ2) - krb5_context context; - krb5_const_principal princ1; - krb5_const_principal princ2; +krb5_realm_compare(krb5_context context, krb5_const_principal princ1, krb5_const_principal princ2) { if (krb5_princ_realm(context, princ1)->length != krb5_princ_realm(context, princ2)->length || @@ -47,10 +44,7 @@ krb5_realm_compare(context, princ1, princ2) } krb5_boolean KRB5_CALLCONV -krb5_principal_compare(context, princ1, princ2) - krb5_context context; - krb5_const_principal princ1; - krb5_const_principal princ2; +krb5_principal_compare(krb5_context context, krb5_const_principal princ1, krb5_const_principal princ2) { register int i; krb5_int32 nelem; diff --git a/src/lib/krb5/krb/rd_cred.c b/src/lib/krb5/krb/rd_cred.c index d6fc23742..d930efc15 100644 --- a/src/lib/krb5/krb/rd_cred.c +++ b/src/lib/krb5/krb/rd_cred.c @@ -12,11 +12,7 @@ * decrypt the enc_part of a krb5_cred */ static krb5_error_code -decrypt_credencdata(context, pcred, pkeyblock, pcredenc) - krb5_context context; - krb5_cred * pcred; - krb5_keyblock * pkeyblock; - krb5_cred_enc_part * pcredenc; +decrypt_credencdata(krb5_context context, krb5_cred *pcred, krb5_keyblock *pkeyblock, krb5_cred_enc_part *pcredenc) { krb5_cred_enc_part * ppart; krb5_error_code retval; @@ -55,13 +51,7 @@ cleanup: /*----------------------- krb5_rd_cred_basic -----------------------*/ static krb5_error_code -krb5_rd_cred_basic(context, pcreddata, pkeyblock, - replaydata, pppcreds) - krb5_context context; - krb5_data * pcreddata; - krb5_keyblock * pkeyblock; - krb5_replay_data * replaydata; - krb5_creds *** pppcreds; +krb5_rd_cred_basic(krb5_context context, krb5_data *pcreddata, krb5_keyblock *pkeyblock, krb5_replay_data *replaydata, krb5_creds ***pppcreds) { krb5_error_code retval; krb5_cred * pcred; @@ -172,12 +162,7 @@ cleanup_cred: * outputs the nonce and an array of the forwarded credentials. */ krb5_error_code KRB5_CALLCONV -krb5_rd_cred(context, auth_context, pcreddata, pppcreds, outdata) - krb5_context context; - krb5_auth_context auth_context; - krb5_data * pcreddata; - krb5_creds *** pppcreds; - krb5_replay_data * outdata; +krb5_rd_cred(krb5_context context, krb5_auth_context auth_context, krb5_data *pcreddata, krb5_creds ***pppcreds, krb5_replay_data *outdata) { krb5_error_code retval; krb5_keyblock * keyblock; diff --git a/src/lib/krb5/krb/rd_error.c b/src/lib/krb5/krb/rd_error.c index aca18de4a..e81727c7c 100644 --- a/src/lib/krb5/krb/rd_error.c +++ b/src/lib/krb5/krb/rd_error.c @@ -40,10 +40,7 @@ */ krb5_error_code KRB5_CALLCONV -krb5_rd_error(context, enc_errbuf, dec_error) - krb5_context context; - const krb5_data *enc_errbuf; - krb5_error **dec_error; +krb5_rd_error(krb5_context context, const krb5_data *enc_errbuf, krb5_error **dec_error) { if (!krb5_is_krb_error(enc_errbuf)) return KRB5KRB_AP_ERR_MSG_TYPE; diff --git a/src/lib/krb5/krb/rd_priv.c b/src/lib/krb5/krb/rd_priv.c index d223782cc..813205662 100644 --- a/src/lib/krb5/krb/rd_priv.c +++ b/src/lib/krb5/krb/rd_priv.c @@ -55,16 +55,7 @@ Returns system errors, integrity errors. */ static krb5_error_code -krb5_rd_priv_basic(context, inbuf, keyblock, local_addr, remote_addr, - i_vector, replaydata, outbuf) - krb5_context context; - const krb5_data * inbuf; - const krb5_keyblock * keyblock; - const krb5_address * local_addr; - const krb5_address * remote_addr; - krb5_pointer i_vector; - krb5_replay_data * replaydata; - krb5_data * outbuf; +krb5_rd_priv_basic(krb5_context context, const krb5_data *inbuf, const krb5_keyblock *keyblock, const krb5_address *local_addr, const krb5_address *remote_addr, krb5_pointer i_vector, krb5_replay_data *replaydata, krb5_data *outbuf) { krb5_error_code retval; krb5_priv * privmsg; @@ -158,12 +149,7 @@ cleanup_privmsg:; } krb5_error_code KRB5_CALLCONV -krb5_rd_priv(context, auth_context, inbuf, outbuf, outdata) - krb5_context context; - krb5_auth_context auth_context; - const krb5_data * inbuf; - krb5_data * outbuf; - krb5_replay_data * outdata; +krb5_rd_priv(krb5_context context, krb5_auth_context auth_context, const krb5_data *inbuf, krb5_data *outbuf, krb5_replay_data *outdata) { krb5_error_code retval; krb5_keyblock * keyblock; diff --git a/src/lib/krb5/krb/rd_rep.c b/src/lib/krb5/krb/rd_rep.c index f6202df82..e35e43f5d 100644 --- a/src/lib/krb5/krb/rd_rep.c +++ b/src/lib/krb5/krb/rd_rep.c @@ -42,11 +42,7 @@ */ krb5_error_code KRB5_CALLCONV -krb5_rd_rep(context, auth_context, inbuf, repl) - krb5_context context; - krb5_auth_context auth_context; - const krb5_data * inbuf; - krb5_ap_rep_enc_part **repl; +krb5_rd_rep(krb5_context context, krb5_auth_context auth_context, const krb5_data *inbuf, krb5_ap_rep_enc_part **repl) { krb5_error_code retval; krb5_ap_rep * reply; diff --git a/src/lib/krb5/krb/rd_req.c b/src/lib/krb5/krb/rd_req.c index 0e64f9637..bc4586e28 100644 --- a/src/lib/krb5/krb/rd_req.c +++ b/src/lib/krb5/krb/rd_req.c @@ -46,15 +46,14 @@ */ krb5_error_code KRB5_CALLCONV -krb5_rd_req(context, auth_context, inbuf, server, keytab, - ap_req_options, ticket) - krb5_context context; - krb5_auth_context * auth_context; - const krb5_data * inbuf; - krb5_const_principal server; /* XXX do we really need this */ - krb5_keytab keytab; - krb5_flags * ap_req_options; - krb5_ticket ** ticket; +krb5_rd_req(krb5_context context, krb5_auth_context *auth_context, const krb5_data *inbuf, krb5_const_principal server, krb5_keytab keytab, krb5_flags *ap_req_options, krb5_ticket **ticket) + + + + /* XXX do we really need this */ + + + { krb5_error_code retval; krb5_ap_req * request; diff --git a/src/lib/krb5/krb/rd_req_dec.c b/src/lib/krb5/krb/rd_req_dec.c index 0eed509e1..fa126b4ab 100644 --- a/src/lib/krb5/krb/rd_req_dec.c +++ b/src/lib/krb5/krb/rd_req_dec.c @@ -66,11 +66,7 @@ static krb5_error_code decrypt_authenticator #define in_clock_skew(date) (labs((date)-currenttime) < context->clockskew) static krb5_error_code -krb5_rd_req_decrypt_tkt_part(context, req, keytab) - krb5_context context; - const krb5_ap_req * req; - krb5_keytab keytab; - +krb5_rd_req_decrypt_tkt_part(krb5_context context, const krb5_ap_req *req, krb5_keytab keytab) { krb5_error_code retval; krb5_enctype enctype; @@ -91,16 +87,7 @@ krb5_rd_req_decrypt_tkt_part(context, req, keytab) } static krb5_error_code -krb5_rd_req_decoded_opt(context, auth_context, req, server, keytab, - ap_req_options, ticket, check_valid_flag) - krb5_context context; - krb5_auth_context * auth_context; - const krb5_ap_req * req; - krb5_const_principal server; - krb5_keytab keytab; - krb5_flags * ap_req_options; - krb5_ticket ** ticket; - int check_valid_flag; +krb5_rd_req_decoded_opt(krb5_context context, krb5_auth_context *auth_context, const krb5_ap_req *req, krb5_const_principal server, krb5_keytab keytab, krb5_flags *ap_req_options, krb5_ticket **ticket, int check_valid_flag) { krb5_error_code retval = 0; krb5_timestamp currenttime; @@ -342,15 +329,7 @@ cleanup: } krb5_error_code -krb5_rd_req_decoded(context, auth_context, req, server, keytab, - ap_req_options, ticket) - krb5_context context; - krb5_auth_context * auth_context; - const krb5_ap_req * req; - krb5_const_principal server; - krb5_keytab keytab; - krb5_flags * ap_req_options; - krb5_ticket ** ticket; +krb5_rd_req_decoded(krb5_context context, krb5_auth_context *auth_context, const krb5_ap_req *req, krb5_const_principal server, krb5_keytab keytab, krb5_flags *ap_req_options, krb5_ticket **ticket) { krb5_error_code retval; retval = krb5_rd_req_decoded_opt(context, auth_context, @@ -361,15 +340,7 @@ krb5_rd_req_decoded(context, auth_context, req, server, keytab, } krb5_error_code -krb5_rd_req_decoded_anyflag(context, auth_context, req, server, keytab, - ap_req_options, ticket) - krb5_context context; - krb5_auth_context * auth_context; - const krb5_ap_req * req; - krb5_const_principal server; - krb5_keytab keytab; - krb5_flags * ap_req_options; - krb5_ticket ** ticket; +krb5_rd_req_decoded_anyflag(krb5_context context, krb5_auth_context *auth_context, const krb5_ap_req *req, krb5_const_principal server, krb5_keytab keytab, krb5_flags *ap_req_options, krb5_ticket **ticket) { krb5_error_code retval; retval = krb5_rd_req_decoded_opt(context, auth_context, @@ -380,11 +351,7 @@ krb5_rd_req_decoded_anyflag(context, auth_context, req, server, keytab, } static krb5_error_code -decrypt_authenticator(context, request, authpp, is_ap_req) - krb5_context context; - const krb5_ap_req *request; - krb5_authenticator **authpp; - int is_ap_req; +decrypt_authenticator(krb5_context context, const krb5_ap_req *request, krb5_authenticator **authpp, int is_ap_req) { krb5_authenticator *local_auth; krb5_error_code retval; diff --git a/src/lib/krb5/krb/rd_safe.c b/src/lib/krb5/krb/rd_safe.c index 61488ea82..0f6cec27f 100644 --- a/src/lib/krb5/krb/rd_safe.c +++ b/src/lib/krb5/krb/rd_safe.c @@ -47,15 +47,7 @@ returns system errors, integrity errors */ static krb5_error_code -krb5_rd_safe_basic(context, inbuf, keyblock, recv_addr, sender_addr, - replaydata, outbuf) - krb5_context context; - const krb5_data * inbuf; - const krb5_keyblock * keyblock; - const krb5_address * recv_addr; - const krb5_address * sender_addr; - krb5_replay_data * replaydata; - krb5_data * outbuf; +krb5_rd_safe_basic(krb5_context context, const krb5_data *inbuf, const krb5_keyblock *keyblock, const krb5_address *recv_addr, const krb5_address *sender_addr, krb5_replay_data *replaydata, krb5_data *outbuf) { krb5_error_code retval; krb5_safe * message; @@ -152,12 +144,7 @@ cleanup: } krb5_error_code KRB5_CALLCONV -krb5_rd_safe(context, auth_context, inbuf, outbuf, outdata) - krb5_context context; - krb5_auth_context auth_context; - const krb5_data * inbuf; - krb5_data * outbuf; - krb5_replay_data * outdata; +krb5_rd_safe(krb5_context context, krb5_auth_context auth_context, const krb5_data *inbuf, krb5_data *outbuf, krb5_replay_data *outdata) { krb5_error_code retval; krb5_keyblock * keyblock; diff --git a/src/lib/krb5/krb/recvauth.c b/src/lib/krb5/krb/recvauth.c index dbb1f4f72..3b001c178 100644 --- a/src/lib/krb5/krb/recvauth.c +++ b/src/lib/krb5/krb/recvauth.c @@ -246,19 +246,7 @@ cleanup:; } krb5_error_code KRB5_CALLCONV -krb5_recvauth(context, auth_context, - /* IN */ - fd, appl_version, server, flags, keytab, - /* OUT */ - ticket) - krb5_context context; - krb5_auth_context * auth_context; - krb5_pointer fd; - char * appl_version; - krb5_principal server; - krb5_int32 flags; - krb5_keytab keytab; - krb5_ticket ** ticket; +krb5_recvauth(krb5_context context, krb5_auth_context *auth_context, krb5_pointer fd, char *appl_version, krb5_principal server, krb5_int32 flags, krb5_keytab keytab, krb5_ticket **ticket) { return recvauth_common (context, auth_context, fd, appl_version, server, flags, keytab, ticket, 0); diff --git a/src/lib/krb5/krb/send_tgs.c b/src/lib/krb5/krb/send_tgs.c index 05c4b6322..800a2761d 100644 --- a/src/lib/krb5/krb/send_tgs.c +++ b/src/lib/krb5/krb/send_tgs.c @@ -48,11 +48,7 @@ returns system errors */ static krb5_error_code -krb5_send_tgs_basic(context, in_data, in_cred, outbuf) - krb5_context context; - krb5_data * in_data; - krb5_creds * in_cred; - krb5_data * outbuf; +krb5_send_tgs_basic(krb5_context context, krb5_data *in_data, krb5_creds *in_cred, krb5_data *outbuf) { krb5_error_code retval; krb5_checksum checksum; @@ -127,19 +123,12 @@ cleanup_data: } krb5_error_code -krb5_send_tgs(context, kdcoptions, timestruct, ktypes, sname, addrs, - authorization_data, padata, second_ticket, in_cred, rep) - krb5_context context; - const krb5_flags kdcoptions; - const krb5_ticket_times * timestruct; - const krb5_enctype * ktypes; - krb5_const_principal sname; - krb5_address * const * addrs; - krb5_authdata * const * authorization_data; - krb5_pa_data * const * padata; - const krb5_data * second_ticket; - krb5_creds * in_cred; - krb5_response * rep; +krb5_send_tgs(krb5_context context, krb5_flags kdcoptions, + const krb5_ticket_times *timestruct, const krb5_enctype *ktypes, + krb5_const_principal sname, krb5_address *const *addrs, + krb5_authdata *const *authorization_data, + krb5_pa_data *const *padata, const krb5_data *second_ticket, + krb5_creds *in_cred, krb5_response *rep) { krb5_error_code retval; krb5_kdc_req tgsreq; diff --git a/src/lib/krb5/krb/sendauth.c b/src/lib/krb5/krb/sendauth.c index 084d72ddb..f34e698d4 100644 --- a/src/lib/krb5/krb/sendauth.c +++ b/src/lib/krb5/krb/sendauth.c @@ -52,27 +52,7 @@ static const char sendauth_version[] = "KRB5_SENDAUTH_V1.0"; krb5_error_code KRB5_CALLCONV -krb5_sendauth(context, auth_context, - /* IN */ - fd, appl_version, client, server, ap_req_options, in_data, - in_creds, - /* IN/OUT */ - ccache, - /* OUT */ - error, rep_result, out_creds) - krb5_context context; - krb5_auth_context * auth_context; - krb5_pointer fd; - char * appl_version; - krb5_principal client; - krb5_principal server; - krb5_flags ap_req_options; - krb5_data * in_data; - krb5_creds * in_creds; - krb5_ccache ccache; - krb5_error ** error; - krb5_ap_rep_enc_part ** rep_result; - krb5_creds ** out_creds; +krb5_sendauth(krb5_context context, krb5_auth_context *auth_context, krb5_pointer fd, char *appl_version, krb5_principal client, krb5_principal server, krb5_flags ap_req_options, krb5_data *in_data, krb5_creds *in_creds, krb5_ccache ccache, krb5_error **error, krb5_ap_rep_enc_part **rep_result, krb5_creds **out_creds) { krb5_octet result; krb5_creds creds; diff --git a/src/lib/krb5/krb/ser_actx.c b/src/lib/krb5/krb/ser_actx.c index 7844a5e70..a8ec90ee6 100644 --- a/src/lib/krb5/krb/ser_actx.c +++ b/src/lib/krb5/krb/ser_actx.c @@ -70,10 +70,7 @@ static const krb5_ser_entry krb5_auth_context_ser_entry = { * the krb5_auth_context. */ static krb5_error_code -krb5_auth_context_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_auth_context_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_auth_context auth_context; @@ -191,11 +188,7 @@ krb5_auth_context_size(kcontext, arg, sizep) * krb5_auth_context_externalize() - Externalize the krb5_auth_context. */ static krb5_error_code -krb5_auth_context_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_auth_context_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_auth_context auth_context; @@ -356,11 +349,7 @@ krb5_auth_context_externalize(kcontext, arg, buffer, lenremain) * krb5_auth_context_internalize() - Internalize the krb5_auth_context. */ static krb5_error_code -krb5_auth_context_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_auth_context_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_auth_context auth_context; @@ -554,8 +543,7 @@ krb5_auth_context_internalize(kcontext, argp, buffer, lenremain) * Register the auth_context serializer. */ krb5_error_code KRB5_CALLCONV -krb5_ser_auth_context_init(kcontext) - krb5_context kcontext; +krb5_ser_auth_context_init(krb5_context kcontext) { krb5_error_code kret; kret = krb5_register_serializer(kcontext, &krb5_auth_context_ser_entry); diff --git a/src/lib/krb5/krb/ser_adata.c b/src/lib/krb5/krb/ser_adata.c index 0f27e8951..ebd4c3e10 100644 --- a/src/lib/krb5/krb/ser_adata.c +++ b/src/lib/krb5/krb/ser_adata.c @@ -57,10 +57,7 @@ static const krb5_ser_entry krb5_authdata_ser_entry = { * the krb5_authdata. */ static krb5_error_code -krb5_authdata_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_authdata_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_authdata *authdata; @@ -89,11 +86,7 @@ krb5_authdata_size(kcontext, arg, sizep) * krb5_authdata_externalize() - Externalize the krb5_authdata. */ static krb5_error_code -krb5_authdata_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_authdata_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_authdata *authdata; @@ -139,11 +132,7 @@ krb5_authdata_externalize(kcontext, arg, buffer, lenremain) * krb5_authdata_internalize() - Internalize the krb5_authdata. */ static krb5_error_code -krb5_authdata_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_authdata_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_authdata *authdata; @@ -204,8 +193,7 @@ krb5_authdata_internalize(kcontext, argp, buffer, lenremain) * Register the authdata serializer. */ krb5_error_code -krb5_ser_authdata_init(kcontext) - krb5_context kcontext; +krb5_ser_authdata_init(krb5_context kcontext) { return(krb5_register_serializer(kcontext, &krb5_authdata_ser_entry)); } diff --git a/src/lib/krb5/krb/ser_addr.c b/src/lib/krb5/krb/ser_addr.c index 098896036..079cc0fda 100644 --- a/src/lib/krb5/krb/ser_addr.c +++ b/src/lib/krb5/krb/ser_addr.c @@ -57,10 +57,7 @@ static const krb5_ser_entry krb5_address_ser_entry = { * the krb5_address. */ static krb5_error_code -krb5_address_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_address_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_address *address; @@ -89,11 +86,7 @@ krb5_address_size(kcontext, arg, sizep) * krb5_address_externalize() - Externalize the krb5_address. */ static krb5_error_code -krb5_address_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_address_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_address *address; @@ -140,11 +133,7 @@ krb5_address_externalize(kcontext, arg, buffer, lenremain) * krb5_address_internalize() - Internalize the krb5_address. */ static krb5_error_code -krb5_address_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_address_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_address *address; @@ -208,8 +197,7 @@ krb5_address_internalize(kcontext, argp, buffer, lenremain) * Register the address serializer. */ krb5_error_code -krb5_ser_address_init(kcontext) - krb5_context kcontext; +krb5_ser_address_init(krb5_context kcontext) { return(krb5_register_serializer(kcontext, &krb5_address_ser_entry)); } diff --git a/src/lib/krb5/krb/ser_auth.c b/src/lib/krb5/krb/ser_auth.c index 983ce8bac..814028e27 100644 --- a/src/lib/krb5/krb/ser_auth.c +++ b/src/lib/krb5/krb/ser_auth.c @@ -57,10 +57,7 @@ static const krb5_ser_entry krb5_authenticator_ser_entry = { * the krb5_authenticator. */ static krb5_error_code -krb5_authenticator_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_authenticator_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_authenticator *authenticator; @@ -124,11 +121,7 @@ krb5_authenticator_size(kcontext, arg, sizep) * krb5_authenticator_externalize() - Externalize the krb5_authenticator. */ static krb5_error_code -krb5_authenticator_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_authenticator_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_authenticator *authenticator; @@ -230,11 +223,7 @@ krb5_authenticator_externalize(kcontext, arg, buffer, lenremain) * krb5_authenticator_internalize() - Internalize the krb5_authenticator. */ static krb5_error_code -krb5_authenticator_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_authenticator_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_authenticator *authenticator; @@ -355,8 +344,7 @@ krb5_authenticator_internalize(kcontext, argp, buffer, lenremain) * Register the authenticator serializer. */ krb5_error_code -krb5_ser_authenticator_init(kcontext) - krb5_context kcontext; +krb5_ser_authenticator_init(krb5_context kcontext) { return(krb5_register_serializer(kcontext, &krb5_authenticator_ser_entry)); } diff --git a/src/lib/krb5/krb/ser_cksum.c b/src/lib/krb5/krb/ser_cksum.c index 101c853e2..8fb1a80da 100644 --- a/src/lib/krb5/krb/ser_cksum.c +++ b/src/lib/krb5/krb/ser_cksum.c @@ -57,10 +57,7 @@ static const krb5_ser_entry krb5_checksum_ser_entry = { * the krb5_checksum. */ static krb5_error_code -krb5_checksum_esize(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_checksum_esize(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_checksum *checksum; @@ -89,11 +86,7 @@ krb5_checksum_esize(kcontext, arg, sizep) * krb5_checksum_externalize() - Externalize the krb5_checksum. */ static krb5_error_code -krb5_checksum_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_checksum_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_checksum *checksum; @@ -140,11 +133,7 @@ krb5_checksum_externalize(kcontext, arg, buffer, lenremain) * krb5_checksum_internalize() - Internalize the krb5_checksum. */ static krb5_error_code -krb5_checksum_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_checksum_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_checksum *checksum; @@ -207,8 +196,7 @@ krb5_checksum_internalize(kcontext, argp, buffer, lenremain) * Register the checksum serializer. */ krb5_error_code -krb5_ser_checksum_init(kcontext) - krb5_context kcontext; +krb5_ser_checksum_init(krb5_context kcontext) { return(krb5_register_serializer(kcontext, &krb5_checksum_ser_entry)); } diff --git a/src/lib/krb5/krb/ser_ctx.c b/src/lib/krb5/krb/ser_ctx.c index 5c6647e86..014d232e7 100644 --- a/src/lib/krb5/krb/ser_ctx.c +++ b/src/lib/krb5/krb/ser_ctx.c @@ -94,10 +94,7 @@ static const krb5_ser_entry krb5_profile_ser_entry = { * krb5_context. */ static krb5_error_code -krb5_context_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_context_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; size_t required; @@ -165,11 +162,7 @@ krb5_context_size(kcontext, arg, sizep) * krb5_context_externalize() - Externalize the krb5_context. */ static krb5_error_code -krb5_context_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_context_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_context context; @@ -340,11 +333,7 @@ krb5_context_externalize(kcontext, arg, buffer, lenremain) * krb5_context_internalize() - Internalize the krb5_context. */ static krb5_error_code -krb5_context_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_context_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_context context; @@ -520,10 +509,7 @@ cleanup: * the krb5_os_context. */ static krb5_error_code -krb5_oscontext_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_oscontext_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { /* * We need five 32-bit integers: @@ -538,11 +524,7 @@ krb5_oscontext_size(kcontext, arg, sizep) * krb5_oscontext_externalize() - Externalize the krb5_os_context. */ static krb5_error_code -krb5_oscontext_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_oscontext_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_os_context os_ctx; @@ -579,11 +561,7 @@ krb5_oscontext_externalize(kcontext, arg, buffer, lenremain) * krb5_oscontext_internalize() - Internalize the krb5_os_context. */ static krb5_error_code -krb5_oscontext_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_oscontext_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_os_context os_ctx; @@ -637,8 +615,7 @@ krb5_oscontext_internalize(kcontext, argp, buffer, lenremain) * Register the context serializers. */ krb5_error_code KRB5_CALLCONV -krb5_ser_context_init(kcontext) - krb5_context kcontext; +krb5_ser_context_init(krb5_context kcontext) { krb5_error_code kret; kret = krb5_register_serializer(kcontext, &krb5_context_ser_entry); diff --git a/src/lib/krb5/krb/ser_key.c b/src/lib/krb5/krb/ser_key.c index a7ef5d0d4..5249006fc 100644 --- a/src/lib/krb5/krb/ser_key.c +++ b/src/lib/krb5/krb/ser_key.c @@ -57,10 +57,7 @@ static const krb5_ser_entry krb5_keyblock_ser_entry = { * the krb5_keyblock. */ static krb5_error_code -krb5_keyblock_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_keyblock_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_keyblock *keyblock; @@ -90,11 +87,7 @@ krb5_keyblock_size(kcontext, arg, sizep) * krb5_keyblock_externalize() - Externalize the krb5_keyblock. */ static krb5_error_code -krb5_keyblock_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_keyblock_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_keyblock *keyblock; @@ -141,11 +134,7 @@ krb5_keyblock_externalize(kcontext, arg, buffer, lenremain) * krb5_keyblock_internalize() - Internalize the krb5_keyblock. */ static krb5_error_code -krb5_keyblock_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_keyblock_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_keyblock *keyblock; @@ -205,8 +194,7 @@ krb5_keyblock_internalize(kcontext, argp, buffer, lenremain) * Register the keyblock serializer. */ krb5_error_code -krb5_ser_keyblock_init(kcontext) - krb5_context kcontext; +krb5_ser_keyblock_init(krb5_context kcontext) { return(krb5_register_serializer(kcontext, &krb5_keyblock_ser_entry)); } diff --git a/src/lib/krb5/krb/ser_princ.c b/src/lib/krb5/krb/ser_princ.c index 148c3d554..a4663c5f8 100644 --- a/src/lib/krb5/krb/ser_princ.c +++ b/src/lib/krb5/krb/ser_princ.c @@ -57,10 +57,7 @@ static const krb5_ser_entry krb5_principal_ser_entry = { * the krb5_principal. */ static krb5_error_code -krb5_principal_size(kcontext, arg, sizep) - krb5_context kcontext; - krb5_pointer arg; - size_t *sizep; +krb5_principal_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_principal principal; @@ -86,11 +83,7 @@ krb5_principal_size(kcontext, arg, sizep) * krb5_principal_externalize() - Externalize the krb5_principal. */ static krb5_error_code -krb5_principal_externalize(kcontext, arg, buffer, lenremain) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **buffer; - size_t *lenremain; +krb5_principal_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_principal principal; @@ -129,11 +122,7 @@ krb5_principal_externalize(kcontext, arg, buffer, lenremain) * krb5_principal_internalize() - Internalize the krb5_principal. */ static krb5_error_code -krb5_principal_internalize(kcontext, argp, buffer, lenremain) - krb5_context kcontext; - krb5_pointer *argp; - krb5_octet **buffer; - size_t *lenremain; +krb5_principal_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain) { krb5_error_code kret; krb5_principal principal; @@ -186,8 +175,7 @@ krb5_principal_internalize(kcontext, argp, buffer, lenremain) * Register the context serializer. */ krb5_error_code -krb5_ser_principal_init(kcontext) - krb5_context kcontext; +krb5_ser_principal_init(krb5_context kcontext) { return(krb5_register_serializer(kcontext, &krb5_principal_ser_entry)); } diff --git a/src/lib/krb5/krb/serialize.c b/src/lib/krb5/krb/serialize.c index 968a0ce9c..7c5f17a4c 100644 --- a/src/lib/krb5/krb/serialize.c +++ b/src/lib/krb5/krb/serialize.c @@ -34,9 +34,7 @@ * krb5_find_serializer() - See if a particular type is registered. */ krb5_ser_handle -krb5_find_serializer(kcontext, odtype) - krb5_context kcontext; - krb5_magic odtype; +krb5_find_serializer(krb5_context kcontext, krb5_magic odtype) { krb5_ser_handle res; krb5_ser_handle sctx; @@ -57,9 +55,7 @@ krb5_find_serializer(kcontext, odtype) * krb5_register_serializer() - Register a particular serializer. */ krb5_error_code -krb5_register_serializer(kcontext, entry) - krb5_context kcontext; - const krb5_ser_entry *entry; +krb5_register_serializer(krb5_context kcontext, const krb5_ser_entry *entry) { krb5_error_code kret; krb5_ser_handle stable; @@ -96,11 +92,7 @@ krb5_register_serializer(kcontext, entry) * piece of opaque data. */ krb5_error_code KRB5_CALLCONV -krb5_size_opaque(kcontext, odtype, arg, sizep) - krb5_context kcontext; - krb5_magic odtype; - krb5_pointer arg; - size_t *sizep; +krb5_size_opaque(krb5_context kcontext, krb5_magic odtype, krb5_pointer arg, size_t *sizep) { krb5_error_code kret; krb5_ser_handle shandle; @@ -116,12 +108,7 @@ krb5_size_opaque(kcontext, odtype, arg, sizep) * krb5_externalize_opaque() - Externalize a piece of opaque data. */ krb5_error_code KRB5_CALLCONV -krb5_externalize_opaque(kcontext, odtype, arg, bufpp, sizep) - krb5_context kcontext; - krb5_magic odtype; - krb5_pointer arg; - krb5_octet **bufpp; - size_t *sizep; +krb5_externalize_opaque(krb5_context kcontext, krb5_magic odtype, krb5_pointer arg, krb5_octet **bufpp, size_t *sizep) { krb5_error_code kret; krb5_ser_handle shandle; @@ -138,11 +125,7 @@ krb5_externalize_opaque(kcontext, odtype, arg, bufpp, sizep) * Externalize a piece of arbitrary data. */ krb5_error_code -krb5_externalize_data(kcontext, arg, bufpp, sizep) - krb5_context kcontext; - krb5_pointer arg; - krb5_octet **bufpp; - size_t *sizep; +krb5_externalize_data(krb5_context kcontext, krb5_pointer arg, krb5_octet **bufpp, size_t *sizep) { krb5_error_code kret; krb5_magic *mp; @@ -177,12 +160,7 @@ krb5_externalize_data(kcontext, arg, bufpp, sizep) * structure. */ krb5_error_code KRB5_CALLCONV -krb5_internalize_opaque(kcontext, odtype, argp, bufpp, sizep) - krb5_context kcontext; - krb5_magic odtype; - krb5_pointer *argp; - krb5_octet **bufpp; - size_t *sizep; +krb5_internalize_opaque(krb5_context kcontext, krb5_magic odtype, krb5_pointer *argp, krb5_octet **bufpp, size_t *sizep) { krb5_error_code kret; krb5_ser_handle shandle; @@ -200,10 +178,7 @@ krb5_internalize_opaque(kcontext, odtype, argp, bufpp, sizep) * Update buffer pointer and remaining space. */ krb5_error_code KRB5_CALLCONV -krb5_ser_pack_int32(iarg, bufp, remainp) - krb5_int32 iarg; - krb5_octet **bufp; - size_t *remainp; +krb5_ser_pack_int32(krb5_int32 iarg, krb5_octet **bufp, size_t *remainp) { if (*remainp >= sizeof(krb5_int32)) { (*bufp)[0] = (krb5_octet) ((iarg >> 24) & 0xff); @@ -222,11 +197,7 @@ krb5_ser_pack_int32(iarg, bufp, remainp) * krb5_ser_pack_bytes() - Pack a string of bytes. */ krb5_error_code KRB5_CALLCONV -krb5_ser_pack_bytes(ostring, osize, bufp, remainp) - krb5_octet *ostring; - size_t osize; - krb5_octet **bufp; - size_t *remainp; +krb5_ser_pack_bytes(krb5_octet *ostring, size_t osize, krb5_octet **bufp, size_t *remainp) { if (*remainp >= osize) { memcpy(*bufp, ostring, osize); @@ -242,10 +213,7 @@ krb5_ser_pack_bytes(ostring, osize, bufp, remainp) * krb5_ser_unpack_int32() - Unpack a 4-byte integer if it's there. */ krb5_error_code KRB5_CALLCONV -krb5_ser_unpack_int32(intp, bufp, remainp) - krb5_int32 *intp; - krb5_octet **bufp; - size_t *remainp; +krb5_ser_unpack_int32(krb5_int32 *intp, krb5_octet **bufp, size_t *remainp) { if (*remainp >= sizeof(krb5_int32)) { *intp = (((krb5_int32) ((unsigned char) (*bufp)[0]) << 24) | @@ -264,11 +232,7 @@ krb5_ser_unpack_int32(intp, bufp, remainp) * krb5_ser_unpack_bytes() - Unpack a byte string if it's there. */ krb5_error_code KRB5_CALLCONV -krb5_ser_unpack_bytes(istring, isize, bufp, remainp) - krb5_octet *istring; - size_t isize; - krb5_octet **bufp; - size_t *remainp; +krb5_ser_unpack_bytes(krb5_octet *istring, size_t isize, krb5_octet **bufp, size_t *remainp) { if (*remainp >= isize) { memcpy(istring, *bufp, isize); diff --git a/src/lib/krb5/krb/set_realm.c b/src/lib/krb5/krb/set_realm.c index 5324e1919..16112a8da 100644 --- a/src/lib/krb5/krb/set_realm.c +++ b/src/lib/krb5/krb/set_realm.c @@ -27,10 +27,7 @@ #include "k5-int.h" krb5_error_code KRB5_CALLCONV -krb5_set_principal_realm(context, principal, realm) - krb5_context context; - krb5_principal principal; - const char *realm; +krb5_set_principal_realm(krb5_context context, krb5_principal principal, const char *realm) { size_t length; char *newrealm; diff --git a/src/lib/krb5/krb/srv_rcache.c b/src/lib/krb5/krb/srv_rcache.c index f87c270f8..e6abcfb90 100644 --- a/src/lib/krb5/krb/srv_rcache.c +++ b/src/lib/krb5/krb/srv_rcache.c @@ -32,10 +32,7 @@ #include krb5_error_code KRB5_CALLCONV -krb5_get_server_rcache(context, piece, rcptr) - krb5_context context; - const krb5_data *piece; - krb5_rcache *rcptr; +krb5_get_server_rcache(krb5_context context, const krb5_data *piece, krb5_rcache *rcptr) { krb5_rcache rcache = 0; char *cachename = 0; diff --git a/src/lib/krb5/krb/str_conv.c b/src/lib/krb5/krb/str_conv.c index 8296157ec..5fe049c1a 100644 --- a/src/lib/krb5/krb/str_conv.c +++ b/src/lib/krb5/krb/str_conv.c @@ -78,9 +78,7 @@ static const int salttype_table_nents = sizeof(salttype_table)/ sizeof(salttype_table[0]); krb5_error_code KRB5_CALLCONV -krb5_string_to_salttype(string, salttypep) - char * string; - krb5_int32 * salttypep; +krb5_string_to_salttype(char *string, krb5_int32 *salttypep) { int i; int found; @@ -103,10 +101,7 @@ krb5_string_to_salttype(string, salttypep) * if the supplied buffer/length will not contain the output. */ krb5_error_code KRB5_CALLCONV -krb5_salttype_to_string(salttype, buffer, buflen) - krb5_int32 salttype; - char * buffer; - size_t buflen; +krb5_salttype_to_string(krb5_int32 salttype, char *buffer, size_t buflen) { int i; const char *out; @@ -140,7 +135,11 @@ static size_t strftime (char *, size_t, const char *, const struct tm *); #ifdef HAVE_STRPTIME #ifdef NEED_STRPTIME_PROTO extern char *strptime (const char *, const char *, - struct tm *); + struct tm *) +#ifdef __cplusplus + throw() +#endif + ; #endif #else /* HAVE_STRPTIME */ #undef strptime @@ -149,9 +148,7 @@ static char *strptime (const char *, const char *, struct tm *); #endif krb5_error_code KRB5_CALLCONV -krb5_string_to_timestamp(string, timestampp) - char * string; - krb5_timestamp * timestampp; +krb5_string_to_timestamp(char *string, krb5_timestamp *timestampp) { int i; struct tm timebuf; @@ -202,10 +199,7 @@ krb5_string_to_timestamp(string, timestampp) } krb5_error_code KRB5_CALLCONV -krb5_timestamp_to_string(timestamp, buffer, buflen) - krb5_timestamp timestamp; - char * buffer; - size_t buflen; +krb5_timestamp_to_string(krb5_timestamp timestamp, char *buffer, size_t buflen) { int ret; time_t timestamp2 = timestamp; @@ -219,11 +213,7 @@ krb5_timestamp_to_string(timestamp, buffer, buflen) } krb5_error_code KRB5_CALLCONV -krb5_timestamp_to_sfstring(timestamp, buffer, buflen, pad) - krb5_timestamp timestamp; - char * buffer; - size_t buflen; - char * pad; +krb5_timestamp_to_sfstring(krb5_timestamp timestamp, char *buffer, size_t buflen, char *pad) { struct tm *tmp; size_t i; @@ -267,10 +257,7 @@ krb5_timestamp_to_sfstring(timestamp, buffer, buflen, pad) /* string->deltat is in deltat.y */ krb5_error_code KRB5_CALLCONV -krb5_deltat_to_string(deltat, buffer, buflen) - krb5_deltat deltat; - char * buffer; - size_t buflen; +krb5_deltat_to_string(krb5_deltat deltat, char *buffer, size_t buflen) { int days, hours, minutes, seconds; krb5_deltat dt; diff --git a/src/lib/krb5/krb/t_deltat.c b/src/lib/krb5/krb/t_deltat.c index ebf1a64d2..4a7f83766 100644 --- a/src/lib/krb5/krb/t_deltat.c +++ b/src/lib/krb5/krb/t_deltat.c @@ -28,7 +28,7 @@ #include "k5-int.h" int -main () +main (void) { struct { char *string; diff --git a/src/lib/krb5/krb/t_kerb.c b/src/lib/krb5/krb/t_kerb.c index 485f58419..7f2ce752c 100644 --- a/src/lib/krb5/krb/t_kerb.c +++ b/src/lib/krb5/krb/t_kerb.c @@ -23,9 +23,7 @@ void test_parse_name (krb5_context, const char *); void test_set_realm (krb5_context, const char *, const char *); void usage (char *); -void test_string_to_timestamp(ctx, ktime) - krb5_context ctx; - char *ktime; +void test_string_to_timestamp(krb5_context ctx, char *ktime) { krb5_timestamp timestamp; time_t t; @@ -40,9 +38,7 @@ void test_string_to_timestamp(ctx, ktime) printf("Parsed time was %s", ctime(&t)); } -void test_425_conv_principal(ctx, name, inst, realm) - krb5_context ctx; - char *name, *inst, *realm; +void test_425_conv_principal(krb5_context ctx, char *name, char *inst, char *realm) { krb5_error_code retval; krb5_principal princ; @@ -64,9 +60,7 @@ void test_425_conv_principal(ctx, name, inst, realm) krb5_free_principal(ctx, princ); } -void test_524_conv_principal(ctx, name) - krb5_context ctx; - char *name; +void test_524_conv_principal(krb5_context ctx, char *name) { krb5_principal princ = 0; krb5_error_code retval; @@ -90,9 +84,7 @@ void test_524_conv_principal(ctx, name) krb5_free_principal (ctx, princ); } -void test_parse_name(ctx, name) - krb5_context ctx; - const char *name; +void test_parse_name(krb5_context ctx, const char *name) { krb5_error_code retval; krb5_principal princ = 0, princ2 = 0; @@ -127,10 +119,7 @@ fail: krb5_free_principal(ctx, princ2); } -void test_set_realm(ctx, name, realm) - krb5_context ctx; - const char *name; - const char *realm; +void test_set_realm(krb5_context ctx, const char *name, const char *realm) { krb5_error_code retval; krb5_principal princ = 0; @@ -160,8 +149,7 @@ fail: krb5_free_principal(ctx, princ); } -void usage(progname) - char *progname; +void usage(char *progname) { fprintf(stderr, "%s: Usage: %s 425_conv_principal length, client->data, KRB5_TGS_NAME_SIZE, KRB5_TGS_NAME, diff --git a/src/lib/krb5/krb/unparse.c b/src/lib/krb5/krb/unparse.c index f24d46808..f0e52dcee 100644 --- a/src/lib/krb5/krb/unparse.c +++ b/src/lib/krb5/krb/unparse.c @@ -58,11 +58,7 @@ #define COMPONENT_SEP '/' krb5_error_code KRB5_CALLCONV -krb5_unparse_name_ext(context, principal, name, size) - krb5_context context; - krb5_const_principal principal; - register char **name; - unsigned int *size; +krb5_unparse_name_ext(krb5_context context, krb5_const_principal principal, register char **name, unsigned int *size) { register char *cp, *q; register int i,j; @@ -192,10 +188,7 @@ krb5_unparse_name_ext(context, principal, name, size) } krb5_error_code KRB5_CALLCONV -krb5_unparse_name(context, principal, name) - krb5_context context; - krb5_const_principal principal; - register char **name; +krb5_unparse_name(krb5_context context, krb5_const_principal principal, register char **name) { *name = NULL; return(krb5_unparse_name_ext(context, principal, name, NULL)); diff --git a/src/lib/krb5/krb/valid_times.c b/src/lib/krb5/krb/valid_times.c index f5d2def5e..9c53d7d91 100644 --- a/src/lib/krb5/krb/valid_times.c +++ b/src/lib/krb5/krb/valid_times.c @@ -37,9 +37,7 @@ */ krb5_error_code -krb5_validate_times(context, times) - krb5_context context; - krb5_ticket_times * times; +krb5_validate_times(krb5_context context, krb5_ticket_times *times) { krb5_timestamp currenttime, starttime; krb5_error_code retval; diff --git a/src/lib/krb5/krb/vfy_increds.c b/src/lib/krb5/krb/vfy_increds.c index 78719fa24..62b535da9 100644 --- a/src/lib/krb5/krb/vfy_increds.c +++ b/src/lib/krb5/krb/vfy_increds.c @@ -2,11 +2,7 @@ #include "int-proto.h" static krb5_error_code -krb5_cc_copy_creds_except(context, incc, outcc, princ) - krb5_context context; - krb5_ccache incc; - krb5_ccache outcc; - krb5_principal princ; +krb5_cc_copy_creds_except(krb5_context context, krb5_ccache incc, krb5_ccache outcc, krb5_principal princ) { krb5_error_code code; krb5_flags flags; diff --git a/src/lib/krb5/krb/vic_opt.c b/src/lib/krb5/krb/vic_opt.c index 0d9660361..acdf49406 100644 --- a/src/lib/krb5/krb/vic_opt.c +++ b/src/lib/krb5/krb/vic_opt.c @@ -1,16 +1,13 @@ #include "k5-int.h" void KRB5_CALLCONV -krb5_verify_init_creds_opt_init(opt) - krb5_verify_init_creds_opt *opt; +krb5_verify_init_creds_opt_init(krb5_verify_init_creds_opt *opt) { opt->flags = 0; } void KRB5_CALLCONV -krb5_verify_init_creds_opt_set_ap_req_nofail(opt, ap_req_nofail) - krb5_verify_init_creds_opt *opt; - int ap_req_nofail; +krb5_verify_init_creds_opt_set_ap_req_nofail(krb5_verify_init_creds_opt *opt, int ap_req_nofail) { opt->flags |= KRB5_VERIFY_INIT_CREDS_OPT_AP_REQ_NOFAIL; opt->ap_req_nofail = ap_req_nofail; diff --git a/src/lib/krb5/krb/walk_rtree.c b/src/lib/krb5/krb/walk_rtree.c index 86e1a33d4..074c7e1d0 100644 --- a/src/lib/krb5/krb/walk_rtree.c +++ b/src/lib/krb5/krb/walk_rtree.c @@ -115,11 +115,7 @@ */ krb5_error_code -krb5_walk_realm_tree(context, client, server, tree, realm_branch_char) - krb5_context context; - const krb5_data *client, *server; - krb5_principal **tree; - int realm_branch_char; +krb5_walk_realm_tree(krb5_context context, const krb5_data *client, const krb5_data *server, krb5_principal **tree, int realm_branch_char) { krb5_error_code retval; krb5_principal *rettree; diff --git a/src/lib/krb5/krb/x-deltat.y b/src/lib/krb5/krb/x-deltat.y index 91da7b945..18c644f2a 100644 --- a/src/lib/krb5/krb/x-deltat.y +++ b/src/lib/krb5/krb/x-deltat.y @@ -216,9 +216,7 @@ mylex (krb5_int32 *intp, char **pp) } krb5_error_code KRB5_CALLCONV -krb5_string_to_deltat(string, deltatp) - char * string; - krb5_deltat * deltatp; +krb5_string_to_deltat(char *string, krb5_deltat *deltatp) { struct param p; p.delta = 0;