+2002-09-02 Ken Raeburn <raeburn@mit.edu>
+
+ * 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 <raeburn@mit.edu>
* Makefile.in: Revert $(S)=>/ change, for Windows support.
* 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);
* < 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;
* 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;
0,
};
-static int conf_boolean(s)
- char *s;
+static int conf_boolean(char *s)
{
const char **p;
for(p=conf_yes; *p; p++) {
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];
}
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;
}
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;
#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;
}
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));
}
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);
}
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;
}
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;
}
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;
* 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);
}
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);
}
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);
}
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);
}
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;
}
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;
}
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;
* Build a principal from a list of strings
*/
-/* Need <krb5/k5-config.h> for HAVE_STDARG_H */
-#include "k5-int.h"
-
#include <stdarg.h>
+#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;
#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;
}
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;
}
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:
struct cleanup {
void * arg;
- void (*func)();
+ void (*func)(void *);
};
#define CLEANUP_INIT(x) \
* 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;
#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;
}
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 */
#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;
* 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;
#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;
#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;
* 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;
#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;
*/
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;
* 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;
* 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;
* 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;
#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;
}
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;
* 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);
*/
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;
*/
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;
-
-/* 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"
#line 125 "../../../../src/lib/krb5/krb/x-deltat.y"
-typedef union { int val; } YYSTYPE;
-#include <stdio.h>
-
-#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
#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
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 <stdlib.h> /* 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 <alloca.h>
-#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 <malloc.h>
#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 <malloc.h> */
- #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 <stddef.h> /* 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)
#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 <stdio.h> /* 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
\f
-/* 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
\f
-#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 *.
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;
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. */
if (yychar == YYEMPTY)
{
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Reading a token: ");
-#endif
+ YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
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
}
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:
{ 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"
+
\f
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];
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;
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;
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"
}
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;
#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;
/* 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;
*/
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;
#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) {
/* 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;
#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;
}
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,
}
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,
}
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,
#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;
}
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;
#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;
#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;
#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;
}
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;
#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;
}
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,
}
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,
}
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 */
}
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));
* 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;
}
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;
}
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;
}
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;
}
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;
#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;
};
int
-_krb5_conf_boolean(s)
- const char *s;
+_krb5_conf_boolean(const char *s)
{
const char **p;
}
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];
/* 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;
}
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;
}
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;
#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;
}
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;
}
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;
}
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;
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;
*/
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;
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;
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;
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;
*/
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,
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 */
}
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;
}
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);
* 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;
}
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;
}
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,
}
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;
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,
}
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,
}
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;
/*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;
#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);
}
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;
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);
}
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);
}
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);
}
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);
}
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;
}
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);
}
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);
*/
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);
}
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;
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);
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);
}
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);
}
}
-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;
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);
}
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);
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);
}
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);
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);
}
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);
}
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);
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;
}
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;
}
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;
}
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);
}
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);
}
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);
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);
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);
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);
}
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;
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++)
}
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);
}
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);
* 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;
/*----------------------- 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;
* 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;
* 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;
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;
#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;
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;
*/
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;
*/
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;
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;
}
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;
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;
}
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;
* 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;
* 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;
}
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);
}
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;
}
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;
* 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;
}
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;
}
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;
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;
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;
* 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;
}
static
-char *sam_challenge_banner(sam_type)
- krb5_int32 sam_type;
+char *sam_challenge_banner(krb5_int32 sam_type)
{
char *label;
#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 ||
}
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;
* 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;
/*----------------------- 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;
* 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;
*/
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;
*/
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;
}
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;
*/
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;
*/
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;
#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;
}
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;
}
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,
}
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,
}
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;
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;
}
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;
}
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);
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;
}
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;
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;
* 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;
* 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;
* 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;
* 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);
* 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;
* 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;
* 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;
* 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));
}
* 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;
* 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;
* 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;
* 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));
}
* 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;
* 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;
* 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;
* 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));
}
* 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;
* 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;
* 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;
* 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));
}
* 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;
* 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;
* 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;
* 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:
* 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;
* 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;
* 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);
* 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;
* 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;
* 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;
* 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));
}
* 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;
* 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;
* 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;
* 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));
}
* 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;
* 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;
* 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;
* 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;
* 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;
* 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;
* 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);
* 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);
* 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) |
* 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);
#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;
#include <stdio.h>
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;
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;
* 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;
#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
#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;
}
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;
}
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;
/* 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;
#include "k5-int.h"
int
-main ()
+main (void)
{
struct {
char *string;
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;
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;
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;
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;
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;
krb5_free_principal(ctx, princ);
}
-void usage(progname)
- char *progname;
+void usage(char *progname)
{
fprintf(stderr, "%s: Usage: %s 425_conv_principal <name> <inst> <realm\n",
progname, progname);
}
int
-main(argc, argv)
- int argc;
- char **argv;
+main(int argc, char **argv)
{
krb5_context ctx;
krb5_error_code retval;
* Dump an external representation.
*/
static void
-print_erep(erep, elen)
- krb5_octet *erep;
- size_t elen;
+print_erep(krb5_octet *erep, size_t elen)
{
int i, j;
* Do a serialization test.
*/
static krb5_error_code
-ser_data(verbose, msg, ctx, dtype)
- int verbose;
- char *msg;
- krb5_pointer ctx;
- krb5_magic dtype;
+ser_data(int verbose, char *msg, krb5_pointer ctx, krb5_magic dtype)
{
krb5_error_code kret;
krb5_context ser_ctx;
* Serialize krb5_context.
*/
static krb5_error_code
-ser_kcontext_test(kcontext, verbose)
- krb5_context kcontext;
- int verbose;
+ser_kcontext_test(krb5_context kcontext, int verbose)
{
krb5_error_code kret;
profile_t sprofile;
* Serialize krb5_auth_context.
*/
static krb5_error_code
-ser_acontext_test(kcontext, verbose)
- krb5_context kcontext;
- int verbose;
+ser_acontext_test(krb5_context kcontext, int verbose)
{
krb5_error_code kret;
krb5_auth_context actx;
* Serialize krb5_ccache
*/
static krb5_error_code
-ser_ccache_test(kcontext, verbose)
- krb5_context kcontext;
- int verbose;
+ser_ccache_test(krb5_context kcontext, int verbose)
{
krb5_error_code kret;
char ccname[128];
* Serialize krb5_keytab.
*/
static krb5_error_code
-ser_keytab_test(kcontext, verbose)
- krb5_context kcontext;
- int verbose;
+ser_keytab_test(krb5_context kcontext, int verbose)
{
krb5_error_code kret;
char ccname[128];
* Serialize krb5_rcache.
*/
static krb5_error_code
-ser_rcache_test(kcontext, verbose)
- krb5_context kcontext;
- int verbose;
+ser_rcache_test(krb5_context kcontext, int verbose)
{
krb5_error_code kret;
char rcname[128];
* Serialize krb5_principal
*/
static krb5_error_code
-ser_princ_test(kcontext, verbose)
- krb5_context kcontext;
- int verbose;
+ser_princ_test(krb5_context kcontext, int verbose)
{
krb5_error_code kret;
krb5_principal princ;
* Serialize krb5_checksum.
*/
static krb5_error_code
-ser_cksum_test(kcontext, verbose)
- krb5_context kcontext;
- int verbose;
+ser_cksum_test(krb5_context kcontext, int verbose)
{
krb5_error_code kret;
krb5_checksum checksum;
* Main procedure.
*/
int
-main(argc, argv)
- int argc;
- char *argv[];
+main(int argc, char **argv)
{
krb5_error_code kret;
krb5_context kcontext;
#include "com_err.h"
int
-main(argc, argv)
- int argc;
- char **argv;
+main(int argc, char **argv)
{
krb5_data client, server;
char realm_branch_char = '.';
/* This is an internal-only function, used by krb5_get_cred_from_kdc() */
krb5_error_code
-krb5_tgtname(context, server, client, tgtprinc)
- krb5_context context;
- const krb5_data *server, *client;
- krb5_principal *tgtprinc;
+krb5_tgtname(krb5_context context, const krb5_data *server, const krb5_data *client, krb5_principal *tgtprinc)
{
return krb5_build_principal_ext(context, tgtprinc, client->length, client->data,
KRB5_TGS_NAME_SIZE, KRB5_TGS_NAME,
#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;
}
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));
*/
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;
#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;
#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;
*/
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;
}
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;
projects / krb5.git / commitdiff