int main (int argc, char *argv[])
{
int s;
- register int retval, i;
+ int retval, i;
char *hname; /* full name of server */
char **srealms; /* realm(s) of server */
char *princ; /* principal in credentials cache */
int standard_shell(sh)
char *sh;
{
- register char *cp;
+ char *cp;
char *getusershell();
while ((cp = getusershell()) != NULL)
#ifndef HAVE_SETENV
int
setenv(name, value, rewrite)
- register char *name, *value;
+ char *name, *value;
int rewrite;
{
extern char **environ;
static int alloced; /* if allocated space before */
- register char *C;
+ char *C;
int l_value, offset;
if (*value == '=') /* no `=' in value */
}
}
else { /* create new slot */
- register int cnt;
- register char **P;
+ int cnt;
+ char **P;
for (P = environ, cnt = 0; *P; ++P, ++cnt);
if (alloced) { /* just increase size */
char *name;
{
extern char **environ;
- register char **P;
+ char **P;
int offset;
while (_findenv(name, &offset)) /* if set multiple times */
*/
static char *
_findenv(name, offset)
- register char *name;
+ char *name;
int *offset;
{
extern char **environ;
- register int len;
- register char **P, *C;
+ int len;
+ char **P, *C;
for (C = name, len = 0; *C && *C != '='; ++C, ++len);
for (P = environ; *P; ++P)
* struct sockaddr_in *raddr;
* rpcprog_t prog;
* rpcvers_t version;
- * register int *sockp;
+ * int *sockp;
* u_int sendsz;
* u_int recvsz;
*/
*/
krb5_error_code KRB5_CALLCONV
krb5_unparse_name(krb5_context context, krb5_const_principal principal,
- register char **name);
+ char **name);
/**
* Convert krb5_principal structure to string and length.
*/
krb5_error_code KRB5_CALLCONV_WRONG
krb5_principal2salt(krb5_context context,
- register krb5_const_principal pr, krb5_data *ret);
+ krb5_const_principal pr, krb5_data *ret);
/* librc.spec--see rcache.h */
/* libcc.spec */
* This function frees the contents of @a val and the structure itself.
*/
void KRB5_CALLCONV
-krb5_free_error(krb5_context context, register krb5_error *val);
+krb5_free_error(krb5_context context, krb5_error *val);
/**
* Free a krb5_creds structure.
* This function frees the contents of @a val and the structure itself.
*/
void KRB5_CALLCONV
-krb5_free_checksum(krb5_context context, register krb5_checksum *val);
+krb5_free_checksum(krb5_context context, krb5_checksum *val);
/**
* Free the contents of a krb5_checksum structure.
* This function frees the contents of @a val, but not the structure itself.
*/
void KRB5_CALLCONV
-krb5_free_checksum_contents(krb5_context context, register krb5_checksum *val);
+krb5_free_checksum_contents(krb5_context context, krb5_checksum *val);
/**
* Free a krb5_keyblock structure.
* This function frees the contents of @a val and the structure itself.
*/
void KRB5_CALLCONV
-krb5_free_keyblock(krb5_context context, register krb5_keyblock *val);
+krb5_free_keyblock(krb5_context context, krb5_keyblock *val);
/**
* Free the contents of a krb5_keyblock structure.
* This function frees the contents of @a key, but not the structure itself.
*/
void KRB5_CALLCONV
-krb5_free_keyblock_contents(krb5_context context, register krb5_keyblock *key);
+krb5_free_keyblock_contents(krb5_context context, krb5_keyblock *key);
/**
* Free a krb5_ap_rep_enc_part structure.
* Kerberos error codes
*/
krb5_error_code KRB5_CALLCONV
-krb5_timeofday(krb5_context context, register krb5_timestamp *timeret);
+krb5_timeofday(krb5_context context, krb5_timestamp *timeret);
/**
* Check if a timestamp is within the allowed clock skew of the current time.
static int
LookupWord(char *buff)
{
- register char *p;
- register char *q;
- register const TABLE *tp;
+ char *p;
+ char *q;
+ const TABLE *tp;
int i;
int abbrev;
static int
yylex()
{
- register char c;
- register char *p;
+ char c;
+ char *p;
char buff[20];
int Count;
int sign;
char *
nstrtok(s, delim)
- register char *s;
- register const char *delim;
+ char *s;
+ const char *delim;
{
- register const char *spanp;
- register int c, sc;
+ const char *spanp;
+ int c, sc;
char *tok;
static char *last;
void
krb5_iprop_prog_1(struct svc_req *rqstp,
- register SVCXPRT *transp)
+ SVCXPRT *transp)
{
union {
kdb_last_t iprop_get_updates_1_arg;
void kadm_1(rqstp, transp)
struct svc_req *rqstp;
- register SVCXPRT *transp;
+ SVCXPRT *transp;
{
union {
cprinc_arg create_principal_2_arg;
krb5_authdata **first, krb5_authdata **second,
krb5_authdata ***output)
{
- register int i, j;
- register krb5_authdata **ptr, **retdata;
+ int i, j;
+ krb5_authdata **ptr, **retdata;
/* count up the entries */
i = 0;
KDC_OPT_ENC_TKT_IN_SKEY | KDC_OPT_CNAME_IN_ADDL_TKT)
int
validate_as_request(kdc_realm_t *kdc_active_realm,
- register krb5_kdc_req *request, krb5_db_entry client,
+ krb5_kdc_req *request, krb5_db_entry client,
krb5_db_entry server, krb5_timestamp kdc_time,
const char **status, krb5_pa_data ***e_data)
{
int
validate_tgs_request(kdc_realm_t *kdc_active_realm,
- register krb5_kdc_req *request, krb5_db_entry server,
+ krb5_kdc_req *request, krb5_db_entry server,
krb5_ticket *ticket, krb5_timestamp kdc_time,
const char **status, krb5_pa_data ***e_data)
{
verto_ev_flag flags;
struct connection *conn;
fd_set fds;
- register int s;
+ int s;
conn = verto_get_private(ev);
char *text;
unsigned char cblock[];
{
- register int i;
+ int i;
for (i = 0; i < 8; i++) {
if (!isascii((unsigned char)text[i * 2]))
abort ();
FILE *fp;
{
unsigned char *y = (unsigned char *) x;
- register int i = 0;
+ int i = 0;
fprintf(fp," 0x { ");
while (i++ < 8) {
*/
int
mit_des_check_key_parity(key)
- register mit_des_cblock key;
+ mit_des_cblock key;
{
unsigned int i;
void
mit_des_fixup_key_parity(key)
- register mit_des_cblock key;
+ mit_des_cblock key;
{
unsigned int i;
for (i=0; i<sizeof(mit_des_cblock); i++)
int
string_to_key(str,key)
- register char *str;
- register C_Block *key;
+ char *str;
+ C_Block *key;
This routines converts an arbitrary length, null terminated string
to an 8 byte DES key, with each byte parity set to odd, per FIPS spec.
const unsigned DES_INT32 *kp;
const unsigned char *ip;
unsigned char *op;
- register DES_INT32 len;
+ DES_INT32 len;
/*
* Initialize left and right with the contents of the initial
int
mit_des_make_key_sched(mit_des_cblock key, mit_des_key_schedule schedule)
{
- register unsigned DES_INT32 c, d;
+ unsigned DES_INT32 c, d;
{
/*
* Need a pointer for the keys and a temporary DES_INT32
*/
const unsigned char *k;
- register unsigned DES_INT32 tmp;
+ unsigned DES_INT32 tmp;
/*
* Fetch the key into something we can work with
/*
* Need several temporaries in here
*/
- register unsigned DES_INT32 ltmp, rtmp;
- register unsigned DES_INT32 *k;
- register int two_bit_shifts;
- register int i;
+ unsigned DES_INT32 ltmp, rtmp;
+ unsigned DES_INT32 *k;
+ int two_bit_shifts;
+ int i;
/*
* Now iterate to compute the key schedule. Note that we
* record the entire set of subkeys in 6 bit chunks since
* temporary. Use this more as a guide for rolling your own, though.
* The best way to do the IP depends on the form of the data you
* are dealing with. If you use this, though, try to make left,
- * right and temp register unsigned DES_INT32s.
+ * right and temp unsigned DES_INT32s.
*/
#define DES_INITIAL_PERM(left, right, temp) do { \
(temp) = DES_IP_RIGHT_BITS((left), (right)); \
*/
#define DES_DO_ENCRYPT_1(left, right, kp) \
do { \
- register int i; \
- register unsigned DES_INT32 temp1; \
+ int i; \
+ unsigned DES_INT32 temp1; \
DEB (("do_encrypt %8lX %8lX \n", left, right)); \
DES_INITIAL_PERM((left), (right), (temp1)); \
DEB ((" after IP %8lX %8lX\n", left, right)); \
#define DES_DO_DECRYPT_1(left, right, kp) \
do { \
- register int i; \
- register unsigned DES_INT32 temp2; \
+ int i; \
+ unsigned DES_INT32 temp2; \
DES_INITIAL_PERM((left), (right), (temp2)); \
(kp) += (2 * 16); \
for (i = 0; i < 8; i++) { \
flip(array)
char *array;
{
- register int old,new,i,j;
+ int old,new,i,j;
/* flips the bit order within each byte from 0 lsb to 0 msb */
for (i = 0; i<=7; i++) {
old = *array;
*/
static void Transform (krb5_ui_4 *buf, krb5_ui_4 *in)
{
- register krb5_ui_4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
+ krb5_ui_4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
#if defined(CONFIG_SMALL) && !defined(CONFIG_SMALL_NO_CRYPTO)
int i;
*/
static void Transform (krb5_ui_4 *buf, krb5_ui_4 *in)
{
- register krb5_ui_4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
+ krb5_ui_4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
#if defined(CONFIG_SMALL) && !defined(CONFIG_SMALL_NO_CRYPTO)
void
mit_crc32(krb5_pointer in, size_t in_length, unsigned long *cksum)
{
- register u_char *data;
- register u_long c = *cksum;
- register int idx;
+ u_char *data;
+ u_long c = *cksum;
+ int idx;
size_t i;
data = (u_char *)in;
}
void
-krb5int_c_free_keyblock(krb5_context context, register krb5_keyblock *val)
+krb5int_c_free_keyblock(krb5_context context, krb5_keyblock *val)
{
krb5int_c_free_keyblock_contents(context, val);
free(val);
static bool_t
xdr_int16_t (XDR *xdrs, int16_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_short (xdrs, objp))
return FALSE;
static bool_t
xdr_int32_t (XDR *xdrs, int32_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_int (xdrs, objp))
return FALSE;
static bool_t
xdr_uint32_t (XDR *xdrs, uint32_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_u_int (xdrs, objp))
return FALSE;
bool_t
xdr_utf8str_t (XDR *xdrs, utf8str_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_bytes (xdrs, (char **)&objp->utf8str_t_val, (u_int *) &objp->utf8str_t_len, ~0))
return FALSE;
bool_t
xdr_kdb_sno_t (XDR *xdrs, kdb_sno_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_uint32_t (xdrs, objp))
return FALSE;
bool_t
xdr_kdbe_time_t (XDR *xdrs, kdbe_time_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_uint32_t (xdrs, &objp->seconds))
return FALSE;
bool_t
xdr_kdbe_key_t (XDR *xdrs, kdbe_key_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_int32_t (xdrs, &objp->k_ver))
return FALSE;
bool_t
xdr_kdbe_data_t (XDR *xdrs, kdbe_data_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_int32_t (xdrs, &objp->k_magic))
return FALSE;
bool_t
xdr_kdbe_princ_t (XDR *xdrs, kdbe_princ_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_utf8str_t (xdrs, &objp->k_realm))
return FALSE;
bool_t
xdr_kdbe_tl_t (XDR *xdrs, kdbe_tl_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_int16_t (xdrs, &objp->tl_type))
return FALSE;
bool_t
xdr_kdbe_pw_hist_t (XDR *xdrs, kdbe_pw_hist_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_array (xdrs, (char **)&objp->kdbe_pw_hist_t_val, (u_int *) &objp->kdbe_pw_hist_t_len, ~0,
sizeof (kdbe_key_t), (xdrproc_t) xdr_kdbe_key_t))
bool_t
xdr_kdbe_attr_type_t (XDR *xdrs, kdbe_attr_type_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_enum (xdrs, (enum_t *) objp))
return FALSE;
bool_t
xdr_kdbe_val_t (XDR *xdrs, kdbe_val_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_kdbe_attr_type_t (xdrs, &objp->av_type))
return FALSE;
bool_t
xdr_kdbe_t (XDR *xdrs, kdbe_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_array (xdrs, (char **)&objp->kdbe_t_val, (u_int *) &objp->kdbe_t_len, ~0,
sizeof (kdbe_val_t), (xdrproc_t) xdr_kdbe_val_t))
bool_t
xdr_kdb_incr_update_t (XDR *xdrs, kdb_incr_update_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_utf8str_t (xdrs, &objp->kdb_princ_name))
return FALSE;
bool_t
xdr_kdb_ulog_t (XDR *xdrs, kdb_ulog_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_array (xdrs, (char **)&objp->kdb_ulog_t_val, (u_int *) &objp->kdb_ulog_t_len, ~0,
sizeof (kdb_incr_update_t), (xdrproc_t) xdr_kdb_incr_update_t))
bool_t
xdr_update_status_t (XDR *xdrs, update_status_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_enum (xdrs, (enum_t *) objp))
return FALSE;
bool_t
xdr_kdb_last_t (XDR *xdrs, kdb_last_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_kdb_sno_t (xdrs, &objp->last_sno))
return FALSE;
bool_t
xdr_kdb_incr_result_t (XDR *xdrs, kdb_incr_result_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_kdb_last_t (xdrs, &objp->lastentry))
return FALSE;
bool_t
xdr_kdb_fullresync_result_t (XDR *xdrs, kdb_fullresync_result_t *objp)
{
- register int32_t *buf;
+ int32_t *buf;
if (!xdr_kdb_last_t (xdrs, &objp->lastentry))
return FALSE;
static krb5_error_code KRB5_CALLCONV
krb5_lcc_close(krb5_context context, krb5_ccache id)
{
- register int closeval = KRB5_OK;
- register krb5_lcc_data *data;
+ int closeval = KRB5_OK;
+ krb5_lcc_data *data;
if (id) {
data = (krb5_lcc_data *) id->data;
static krb5_error_code KRB5_CALLCONV
krb5_lcc_destroy(krb5_context context, krb5_ccache id)
{
- register krb5_lcc_data *data;
+ krb5_lcc_data *data;
if (id) {
data = (krb5_lcc_data *) id->data;
*/
static krb5_boolean
times_match(t1, t2)
- register const krb5_ticket_times *t1;
- register const krb5_ticket_times *t2;
+ const krb5_ticket_times *t1;
+ const krb5_ticket_times *t2;
{
if (t1->renew_till) {
if (ts_after(t1->renew_till, t2->renew_till))
static krb5_boolean
times_match_exact (t1, t2)
- register const krb5_ticket_times *t1, *t2;
+ const krb5_ticket_times *t1, *t2;
{
return (t1->authtime == t2->authtime
&& t1->starttime == t2->starttime
static krb5_boolean
standard_fields_match(context, mcreds, creds)
krb5_context context;
- register const krb5_creds *mcreds, *creds;
+ const krb5_creds *mcreds, *creds;
{
return (krb5_principal_compare(context, mcreds->client,creds->client) &&
krb5_principal_compare(context, mcreds->server,creds->server));
static krb5_boolean
srvname_match(context, mcreds, creds)
krb5_context context;
- register const krb5_creds *mcreds, *creds;
+ const krb5_creds *mcreds, *creds;
{
krb5_boolean retval;
krb5_principal_data p1, p2;
static krb5_boolean
data_match(data1, data2)
- register const krb5_data *data1, *data2;
+ const krb5_data *data1, *data2;
{
if (!data1) {
if (!data2)
unsigned int u_count, u_princ_size;
krb5_int16 enctype;
krb5_int16 princ_size;
- register int i;
+ int i;
krb5_int32 size;
krb5_int32 start_pos, pos;
krb5_error_code error;
krb5_address_order(krb5_context context, const krb5_address *addr1, const krb5_address *addr2)
{
int dir;
- register int i;
+ int i;
const int minlen = min(addr1->length, addr2->length);
if (addr1->addrtype != addr2->addrtype)
void KRB5_CALLCONV
krb5_free_authdata(krb5_context context, krb5_authdata **val)
{
- register krb5_authdata **temp;
+ krb5_authdata **temp;
if (val == NULL)
return;
* This falls in the "should have been in the ANSI C library"
* category. :-)
*/
-static char *strnchr(register char *s, register int c,
- register unsigned int n)
+static char *
+strnchr(char *s, int c, unsigned int n)
{
if (n < 1)
return 0;
{
krb5_error_code retval;
krb5_address ** tempaddr;
- register unsigned int nelems = 0;
+ unsigned int nelems = 0;
if (!inaddr) {
*outaddr = 0;
{
krb5_error_code retval;
krb5_authdata ** tempauthdat;
- register unsigned int nelems = 0, nelems2 = 0;
+ unsigned int nelems = 0, nelems2 = 0;
*outauthdat = NULL;
if (!inauthdat1 && !inauthdat2) {
krb5_error_code KRB5_CALLCONV
krb5_copy_principal(krb5_context context, krb5_const_principal inprinc, krb5_principal *outprinc)
{
- register krb5_principal tempprinc;
+ krb5_principal tempprinc;
krb5_int32 i;
tempprinc = (krb5_principal)malloc(sizeof(krb5_principal_data));
*/
krb5_error_code KRB5_CALLCONV
-krb5_decrypt_tkt_part(krb5_context context, const krb5_keyblock *srv_key, register krb5_ticket *ticket)
+krb5_decrypt_tkt_part(krb5_context context, const krb5_keyblock *srv_key,
+ krb5_ticket *ticket)
{
krb5_enc_tkt_part *dec_tkt_part;
krb5_data scratch;
*/
krb5_error_code
-krb5_encrypt_tkt_part(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,
+ krb5_ticket *dec_ticket)
{
krb5_data *scratch;
krb5_error_code retval;
- register krb5_enc_tkt_part *dec_tkt_part = dec_ticket->enc_part2;
+ krb5_enc_tkt_part *dec_tkt_part = dec_ticket->enc_part2;
/* start by encoding the to-be-encrypted part. */
if ((retval = encode_krb5_enc_tkt_part(dec_tkt_part, &scratch))) {
void KRB5_CALLCONV
krb5_free_addresses(krb5_context context, krb5_address **val)
{
- register krb5_address **temp;
+ krb5_address **temp;
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_ap_rep(krb5_context context, register krb5_ap_rep *val)
+krb5_free_ap_rep(krb5_context context, krb5_ap_rep *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_ap_req(krb5_context context, register krb5_ap_req *val)
+krb5_free_ap_req(krb5_context context, krb5_ap_req *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_checksum(krb5_context context, register krb5_checksum *val)
+krb5_free_checksum(krb5_context context, krb5_checksum *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_checksum_contents(krb5_context context, register krb5_checksum *val)
+krb5_free_checksum_contents(krb5_context context, krb5_checksum *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_cred(krb5_context context, register krb5_cred *val)
+krb5_free_cred(krb5_context context, krb5_cred *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_cred_enc_part(krb5_context context, register krb5_cred_enc_part *val)
+krb5_free_cred_enc_part(krb5_context context, krb5_cred_enc_part *val)
{
- register krb5_cred_info **temp;
+ krb5_cred_info **temp;
if (val == NULL)
return;
void KRB5_CALLCONV
-krb5_free_enc_kdc_rep_part(krb5_context context, register krb5_enc_kdc_rep_part *val)
+krb5_free_enc_kdc_rep_part(krb5_context context, krb5_enc_kdc_rep_part *val)
{
if (val == NULL)
return;
void KRB5_CALLCONV
-krb5_free_error(krb5_context context, register krb5_error *val)
+krb5_free_error(krb5_context context, krb5_error *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_keyblock_contents(krb5_context context, register krb5_keyblock *key)
+krb5_free_keyblock_contents(krb5_context context, krb5_keyblock *key)
{
krb5int_c_free_keyblock_contents (context, key);
}
void KRB5_CALLCONV
-krb5_free_keyblock(krb5_context context, register krb5_keyblock *val)
+krb5_free_keyblock(krb5_context context, krb5_keyblock *val)
{
krb5int_c_free_keyblock (context, val);
}
void KRB5_CALLCONV
krb5_free_last_req(krb5_context context, krb5_last_req_entry **val)
{
- register krb5_last_req_entry **temp;
+ krb5_last_req_entry **temp;
if (val == NULL)
return;
void KRB5_CALLCONV
krb5_free_pa_data(krb5_context context, krb5_pa_data **val)
{
- register krb5_pa_data **temp;
+ krb5_pa_data **temp;
if (val == NULL)
return;
void KRB5_CALLCONV
krb5_free_principal(krb5_context context, krb5_principal val)
{
- register krb5_int32 i;
+ krb5_int32 i;
if (!val)
return;
}
void KRB5_CALLCONV
-krb5_free_priv(krb5_context context, register krb5_priv *val)
+krb5_free_priv(krb5_context context, krb5_priv *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_priv_enc_part(krb5_context context, register krb5_priv_enc_part *val)
+krb5_free_priv_enc_part(krb5_context context, krb5_priv_enc_part *val)
{
if (val == NULL)
return;
}
void KRB5_CALLCONV
-krb5_free_safe(krb5_context context, register krb5_safe *val)
+krb5_free_safe(krb5_context context, krb5_safe *val)
{
if (val == NULL)
return;
void KRB5_CALLCONV
krb5_free_tickets(krb5_context context, krb5_ticket **val)
{
- register krb5_ticket **temp;
+ krb5_ticket **temp;
if (val == NULL)
return;
void KRB5_CALLCONV
krb5_free_tgt_creds(krb5_context context, krb5_creds **tgts)
{
- register krb5_creds **tgtpp;
+ krb5_creds **tgtpp;
if (tgts == NULL)
return;
for (tgtpp = tgts; *tgtpp; tgtpp++)
* Convert a krb5_principal into the default salt for that principal.
*/
static krb5_error_code
-principal2salt_internal(krb5_context context,
- register krb5_const_principal pr,
+principal2salt_internal(krb5_context context, krb5_const_principal pr,
krb5_data *ret, int use_realm)
{
unsigned int size = 0, offset=0;
}
krb5_error_code
-krb5_principal2salt(krb5_context context,
- register krb5_const_principal pr, krb5_data *ret)
+krb5_principal2salt(krb5_context context, krb5_const_principal pr,
+ krb5_data *ret)
{
return principal2salt_internal(context, pr, ret, 1);
}
krb5_error_code
-krb5_principal2salt_norealm(krb5_context context,
- register krb5_const_principal pr, krb5_data *ret)
+krb5_principal2salt_norealm(krb5_context context, krb5_const_principal pr,
+ krb5_data *ret)
{
return principal2salt_internal(context, pr, ret, 0);
}
}
krb5_error_code KRB5_CALLCONV
-krb5_unparse_name(krb5_context context, krb5_const_principal principal, register char **name)
+krb5_unparse_name(krb5_context context, krb5_const_principal principal,
+ char **name)
{
if (name != NULL) /* name == NULL will return error from _ext */
*name = NULL;
void
krb5_free_realm_tree(krb5_context context, krb5_principal *realms)
{
- register krb5_principal *nrealms = realms;
+ krb5_principal *nrealms = realms;
if (realms == NULL)
return;
while (*nrealms) {
{
unsigned long smushaddr = (unsigned long) adr; /* already in net order */
unsigned short smushport = (unsigned short) port; /* ditto */
- register krb5_address *retaddr;
- register krb5_octet *marshal;
+ krb5_address *retaddr;
+ krb5_octet *marshal;
krb5_addrtype temptype;
krb5_int32 templength;
krb5_make_fulladdr(krb5_context context, krb5_address *kaddr,
krb5_address *kport, krb5_address *raddr)
{
- register krb5_octet * marshal;
+ krb5_octet *marshal;
krb5_int32 tmp32;
krb5_int16 tmp16;
*/
int
-krb5_net_read(krb5_context context, int fd, register char *buf, register int len)
+krb5_net_read(krb5_context context, int fd, char *buf, int len)
{
int cc, len2 = 0;
{
unsigned long smushaddr;
unsigned short smushport;
- register krb5_octet *marshal;
+ krb5_octet *marshal;
krb5_addrtype temptype;
krb5_ui_4 templength;
#include <time.h>
krb5_error_code KRB5_CALLCONV
-krb5_timeofday(krb5_context context, register krb5_timestamp *timeret)
+krb5_timeofday(krb5_context context, krb5_timestamp *timeret)
{
krb5_os_context os_ctx;
time_t tval;
AUTH *
authnone_create(void)
{
- register struct authnone_private *ap = authnone_private;
+ struct authnone_private *ap = authnone_private;
XDR xdr_stream;
- register XDR *xdrs;
+ XDR *xdrs;
if (ap == 0) {
ap = (struct authnone_private *)calloc(1, sizeof (*ap));
static bool_t
authnone_marshal(AUTH *client, XDR *xdrs)
{
- register struct authnone_private *ap = authnone_private;
+ struct authnone_private *ap = authnone_private;
if (ap == 0)
return (0);
char *machname,
int uid,
int gid,
- register int len,
+ int len,
int *aup_gids)
{
struct authunix_parms aup;
char mymem[MAX_AUTH_BYTES];
struct timeval now;
XDR xdrs;
- register AUTH *auth;
- register struct audata *au;
+ AUTH *auth;
+ struct audata *au;
/*
* Allocate and set up auth handle
AUTH *
authunix_create_default(void)
{
- register int len;
+ int len;
char machname[MAX_MACHINE_NAME + 1];
- register int uid;
- register int gid;
+ int uid;
+ int gid;
GETGROUPS_T gids[NGRPS];
int igids[NGRPS], i;
static bool_t
authunix_marshal(AUTH *auth, XDR *xdrs)
{
- register struct audata *au = AUTH_PRIVATE(auth);
+ struct audata *au = AUTH_PRIVATE(auth);
return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos));
}
static bool_t
-authunix_validate(register AUTH *auth, struct opaque_auth *verf)
+authunix_validate(AUTH *auth, struct opaque_auth *verf)
{
- register struct audata *au;
+ struct audata *au;
XDR xdrs;
if (verf->oa_flavor == AUTH_SHORT) {
}
static bool_t
-authunix_refresh(register AUTH *auth, struct rpc_msg *msg)
+authunix_refresh(AUTH *auth, struct rpc_msg *msg)
{
- register struct audata *au = AUTH_PRIVATE(auth);
+ struct audata *au = AUTH_PRIVATE(auth);
struct authunix_parms aup;
struct timeval now;
XDR xdrs;
- register int stat;
+ int stat;
if (auth->ah_cred.oa_base == au->au_origcred.oa_base) {
/* there is no hope. Punt */
}
static void
-authunix_destroy(register AUTH *auth)
+authunix_destroy(AUTH *auth)
{
- register struct audata *au = AUTH_PRIVATE(auth);
+ struct audata *au = AUTH_PRIVATE(auth);
mem_free(au->au_origcred.oa_base, au->au_origcred.oa_length);
* sets private data, au_marshed and au_mpos
*/
static void
-marshal_new_auth(register AUTH *auth)
+marshal_new_auth(AUTH *auth)
{
XDR xdr_stream;
- register XDR *xdrs = &xdr_stream;
- register struct audata *au = AUTH_PRIVATE(auth);
+ XDR *xdrs = &xdr_stream;
+ struct audata *au = AUTH_PRIVATE(auth);
xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) ||
* XDR for unix authentication parameters.
*/
bool_t
-xdr_authunix_parms(register XDR *xdrs, register struct authunix_parms *p)
+xdr_authunix_parms(XDR *xdrs, struct authunix_parms *p)
{
if (xdr_u_int32(xdrs, &(p->aup_time))
void * resultsp,
struct timeval timeout)
{
- register struct clntraw_private *clp = clntraw_private;
- register XDR *xdrs = &clp->xdr_stream;
+ struct clntraw_private *clp = clntraw_private;
+ XDR *xdrs = &clp->xdr_stream;
struct rpc_msg msg;
enum clnt_stat status;
struct rpc_err error;
xdrproc_t xdr_res,
void *res_ptr)
{
- register struct clntraw_private *clp = clntraw_private;
- register XDR *xdrs = &clp->xdr_stream;
+ struct clntraw_private *clp = clntraw_private;
+ XDR *xdrs = &clp->xdr_stream;
bool_t rval;
if (clp == 0)
xdrproc_t outproc,
char *out)
{
- register struct callrpc_private *crp = callrpc_private;
+ struct callrpc_private *crp = callrpc_private;
struct sockaddr_in server_addr;
enum clnt_stat clnt_stat;
struct hostent *hp;
u_int recvsz)
{
CLIENT *h;
- register struct ct_data *ct = 0;
+ struct ct_data *ct = 0;
struct timeval now;
struct rpc_msg call_msg;
static enum clnt_stat
clnttcp_call(
- register CLIENT *h,
+ CLIENT *h,
rpcproc_t proc,
xdrproc_t xdr_args,
void * args_ptr,
void * results_ptr,
struct timeval timeout)
{
- register struct ct_data *ct = (struct ct_data *) h->cl_private;
- register XDR *xdrs = &(ct->ct_xdrs);
+ struct ct_data *ct = h->cl_private;
+ XDR *xdrs = &ct->ct_xdrs;
struct rpc_msg reply_msg;
uint32_t x_id;
uint32_t *msg_x_id = &ct->ct_u.ct_mcalli; /* yuk */
- register bool_t shipnow;
+ bool_t shipnow;
int refreshes = 2;
long procl = proc;
CLIENT *h,
struct rpc_err *errp)
{
- register struct ct_data *ct =
- (struct ct_data *) h->cl_private;
+ struct ct_data *ct = h->cl_private;
*errp = ct->ct_error;
}
xdrproc_t xdr_res,
void * res_ptr)
{
- register struct ct_data *ct = (struct ct_data *)cl->cl_private;
- register XDR *xdrs = &(ct->ct_xdrs);
+ struct ct_data *ct = cl->cl_private;
+ XDR *xdrs = &ct->ct_xdrs;
xdrs->x_op = XDR_FREE;
return ((*xdr_res)(xdrs, res_ptr));
int request,
void *info)
{
- register struct ct_data *ct = (struct ct_data *)cl->cl_private;
+ struct ct_data *ct = cl->cl_private;
GETSOCKNAME_ARG3_TYPE len;
switch (request) {
static void
clnttcp_destroy(CLIENT *h)
{
- register struct ct_data *ct =
- (struct ct_data *) h->cl_private;
+ struct ct_data *ct = h->cl_private;
if (ct->ct_closeit)
(void)closesocket(ct->ct_sock);
readtcp(
char *ctptr,
caddr_t buf,
- register int len)
+ int len)
{
- register struct ct_data *ct = (struct ct_data *)(void *)ctptr;
+ struct ct_data *ct = (void *)ctptr;
struct timeval tout;
#ifdef FD_SETSIZE
fd_set mask;
FD_ZERO(&mask);
FD_SET(ct->ct_sock, &mask);
#else
- register int mask = 1 << (ct->ct_sock);
+ int mask = 1 << (ct->ct_sock);
int readfds;
if (len == 0)
int len)
{
struct ct_data *ct = (struct ct_data *)(void *)ctptr;
- register int i, cnt;
+ int i, cnt;
for (cnt = len; cnt > 0; cnt -= i, buf += i) {
if ((i = write(ct->ct_sock, buf, (size_t) cnt)) == -1) {
rpcprog_t program,
rpcvers_t version,
struct timeval wait,
- register int *sockp,
+ int *sockp,
u_int sendsz,
u_int recvsz)
{
CLIENT *cl;
- register struct cu_data *cu = 0;
+ struct cu_data *cu = 0;
struct timeval now;
struct rpc_msg call_msg;
rpcprog_t program,
rpcvers_t version,
struct timeval wait,
- register int *sockp)
+ int *sockp)
{
return(clntudp_bufcreate(raddr, program, version, wait, sockp,
static enum clnt_stat
clntudp_call(
- register CLIENT *cl, /* client handle */
+ CLIENT *cl, /* client handle */
rpcproc_t proc, /* procedure number */
xdrproc_t xargs, /* xdr routine for args */
void * argsp, /* pointer to args */
* giving up */
)
{
- register struct cu_data *cu = (struct cu_data *)cl->cl_private;
- register XDR *xdrs;
- register int outlen;
- register ssize_t inlen;
+ struct cu_data *cu = (struct cu_data *)cl->cl_private;
+ XDR *xdrs;
+ int outlen;
+ ssize_t inlen;
GETSOCKNAME_ARG3_TYPE fromlen; /* Assumes recvfrom uses same type */
#ifdef FD_SETSIZE
fd_set readfds;
fd_set mask;
#else
int readfds;
- register int mask;
+ int mask;
#endif /* def FD_SETSIZE */
struct sockaddr_in from;
struct rpc_msg reply_msg;
CLIENT *cl,
struct rpc_err *errp)
{
- register struct cu_data *cu = (struct cu_data *)cl->cl_private;
+ struct cu_data *cu = (struct cu_data *)cl->cl_private;
*errp = cu->cu_error;
}
xdrproc_t xdr_res,
void *res_ptr)
{
- register struct cu_data *cu = (struct cu_data *)cl->cl_private;
- register XDR *xdrs = &(cu->cu_outxdrs);
+ struct cu_data *cu = cl->cl_private;
+ XDR *xdrs = &cu->cu_outxdrs;
xdrs->x_op = XDR_FREE;
return ((*xdr_res)(xdrs, res_ptr));
int request,
void *info)
{
- register struct cu_data *cu = (struct cu_data *)cl->cl_private;
+ struct cu_data *cu = cl->cl_private;
switch (request) {
case CLSET_TIMEOUT:
static void
clntudp_destroy(CLIENT *cl)
{
- register struct cu_data *cu = (struct cu_data *)cl->cl_private;
+ struct cu_data *cu = (struct cu_data *)cl->cl_private;
if (cu->cu_closeit)
(void)closesocket(cu->cu_sock);
static struct rpcdata *
get_rpcdata(void)
{
- register struct rpcdata *d = rpcdata;
+ struct rpcdata *d = rpcdata;
if (d == 0) {
d = (struct rpcdata *)calloc(1, sizeof (struct rpcdata));
}
struct rpcent *
-getrpcbynumber(register int number)
+getrpcbynumber(int number)
{
- register struct rpcdata *d = get_rpcdata();
- register struct rpcent *p;
+ struct rpcdata *d = get_rpcdata();
+ struct rpcent *p;
int reason;
char adrstr[16], *val = NULL;
int vallen;
SETRPCENT_TYPE setrpcent(int f)
{
- register struct rpcdata *d = _rpcdata();
+ struct rpcdata *d = _rpcdata();
if (d == 0)
return;
ENDRPCENT_TYPE endrpcent(void)
{
- register struct rpcdata *d = _rpcdata();
+ struct rpcdata *d = _rpcdata();
if (d == 0)
return;
int reason;
char *key = NULL, *val = NULL;
int keylen, vallen;
- register struct rpcdata *d = _rpcdata();
+ struct rpcdata *d = _rpcdata();
if (d == 0)
return(NULL);
static struct rpcent *
interpret(char *val, int len)
{
- register struct rpcdata *d = _rpcdata();
+ struct rpcdata *d = _rpcdata();
char *p;
- register char *cp, **q;
+ char *cp, **q;
if (d == 0)
return;
{
struct sockaddr_in myaddress;
int sock = -1;
- register CLIENT *client;
+ CLIENT *client;
struct pmap parms;
bool_t rslt;
{
struct sockaddr_in myaddress;
int sock = -1;
- register CLIENT *client;
+ CLIENT *client;
struct pmap parms;
bool_t rslt;
struct pmaplist *head = (struct pmaplist *)NULL;
int sock = -1;
struct timeval minutetimeout;
- register CLIENT *client;
+ CLIENT *client;
minutetimeout.tv_sec = 60;
minutetimeout.tv_usec = 0;
{
unsigned short port = 0;
int sock = -1;
- register CLIENT *client;
+ CLIENT *client;
struct pmap parms;
address->sin_port = htons(PMAPPORT);
* this sounds like a job for xdr_reference!
*/
bool_t
-xdr_pmaplist(register XDR *xdrs, register struct pmaplist **rp)
+xdr_pmaplist(XDR *xdrs, struct pmaplist **rp)
{
/*
* more_elements is pre-computed in case the direction is
* xdr_bool when the direction is XDR_DECODE.
*/
bool_t more_elements;
- register int freeing = (xdrs->x_op == XDR_FREE);
- register struct pmaplist **next = NULL;
+ int freeing = (xdrs->x_op == XDR_FREE);
+ struct pmaplist **next = NULL;
while (TRUE) {
more_elements = (bool_t)(*rp != NULL);
rpcport_t *port_ptr)
{
SOCKET sock = INVALID_SOCKET;
- register CLIENT *client;
+ CLIENT *client;
struct rmtcallargs a;
struct rmtcallres r;
enum clnt_stat stat;
*/
bool_t
xdr_rmtcall_args(
- register XDR *xdrs,
- register struct rmtcallargs *cap)
+ XDR *xdrs,
+ struct rmtcallargs *cap)
{
u_int lenposition, argposition, position;
*/
bool_t
xdr_rmtcallres(
- register XDR *xdrs,
- register struct rmtcallres *crp)
+ XDR *xdrs,
+ struct rmtcallres *crp)
{
caddr_t port_ptr;
enum clnt_stat stat;
AUTH *unix_auth = authunix_create_default();
XDR xdr_stream;
- register XDR *xdrs = &xdr_stream;
+ XDR *xdrs = &xdr_stream;
int outlen, nets;
ssize_t inlen;
GETSOCKNAME_ARG3_TYPE fromlen;
fd_set readfds;
#else
int readfds;
- register int mask;
+ int mask;
#endif /* def FD_SETSIZE */
- register int i;
+ int i;
bool_t done = FALSE;
- register uint32_t xid;
+ uint32_t xid;
rpcport_t port;
struct in_addr addrs[20];
struct sockaddr_in baddr, raddr; /* broadcast and response addresses */
* XDR a call message
*/
bool_t
-xdr_callmsg(register XDR *xdrs, register struct rpc_msg *cmsg)
+xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg)
{
- register rpc_inline_t *buf;
- register struct opaque_auth *oa;
+ rpc_inline_t *buf;
+ struct opaque_auth *oa;
if (xdrs->x_op == XDR_ENCODE) {
if (cmsg->rm_call.cb_cred.oa_length > MAX_AUTH_BYTES) {
void
xprt_register(SVCXPRT *xprt)
{
- register int sock = xprt->xp_sock;
+ int sock = xprt->xp_sock;
#ifdef FD_SETSIZE
if (gssrpc_svc_fdset_init == 0) {
void
xprt_unregister(SVCXPRT *xprt)
{
- register int sock = xprt->xp_sock;
+ int sock = xprt->xp_sock;
#ifdef FD_SETSIZE
if ((sock < FD_SETSIZE) && (xports[sock] == xprt)) {
int protocol)
{
struct svc_callout *prev;
- register struct svc_callout *s;
+ struct svc_callout *s;
if ((s = svc_find(prog, vers, &prev)) != NULL_SVC) {
if (s->sc_dispatch == dispatch)
rpcvers_t vers)
{
struct svc_callout *prev;
- register struct svc_callout *s;
+ struct svc_callout *s;
if ((s = svc_find(prog, vers, &prev)) == NULL_SVC)
return;
rpcvers_t vers,
struct svc_callout **prev)
{
- register struct svc_callout *s, *p;
+ struct svc_callout *s, *p;
p = NULL_SVC;
for (s = svc_head; s != NULL_SVC; s = s->sc_next) {
*/
bool_t
svc_sendreply(
- register SVCXPRT *xprt,
+ SVCXPRT *xprt,
xdrproc_t xdr_results,
caddr_t xdr_location)
{
* No procedure error reply
*/
void
-svcerr_noproc(register SVCXPRT *xprt)
+svcerr_noproc(SVCXPRT *xprt)
{
struct rpc_msg rply;
* Can't decode args error reply
*/
void
-svcerr_decode(register SVCXPRT *xprt)
+svcerr_decode(SVCXPRT *xprt)
{
struct rpc_msg rply;
* Some system error
*/
void
-svcerr_systemerr(register SVCXPRT *xprt)
+svcerr_systemerr(SVCXPRT *xprt)
{
struct rpc_msg rply;
* Program unavailable error reply
*/
void
-svcerr_noprog(register SVCXPRT *xprt)
+svcerr_noprog(SVCXPRT *xprt)
{
struct rpc_msg rply;
*/
void
svcerr_progvers(
- register SVCXPRT *xprt,
+ SVCXPRT *xprt,
rpcvers_t low_vers,
rpcvers_t high_vers)
{
#ifndef FD_SETSIZE
int readfds_local = *readfds;
#endif
- register SVCXPRT *xprt;
- register int sock;
+ SVCXPRT *xprt;
+ int sock;
#ifdef FD_SETSIZE
for (sock = 0; sock <= svc_maxfd; sock++) {
r.rq_clntcred = cookedcred;
do {
- register struct svc_callout *s;
+ struct svc_callout *s;
enum auth_stat why;
if (!SVC_RECV(xprt, &msg))
*
* enum auth_stat
* flavorx_auth(rqst, msg)
- * register struct svc_req *rqst;
- * register struct rpc_msg *msg;
+ * struct svc_req *rqst;
+ * struct rpc_msg *msg;
*
*/
*/
enum auth_stat
gssrpc__authenticate(
- register struct svc_req *rqst,
+ struct svc_req *rqst,
struct rpc_msg *msg,
bool_t *no_dispatch)
{
- register int cred_flavor, i;
+ int cred_flavor, i;
rqst->rq_cred = msg->rm_call.cb_cred;
rqst->rq_xprt->xp_verf.oa_flavor = gssrpc__null_auth.oa_flavor;
}
enum auth_stat gssrpc__svcauth_gssapi(
- register struct svc_req *rqst,
- register struct rpc_msg *msg,
+ struct svc_req *rqst,
+ struct rpc_msg *msg,
bool_t *no_dispatch)
{
XDR xdrs;
*/
enum auth_stat
gssrpc__svcauth_unix(
- register struct svc_req *rqst,
- register struct rpc_msg *msg,
+ struct svc_req *rqst,
+ struct rpc_msg *msg,
bool_t *dispatch)
{
- register enum auth_stat stat;
+ enum auth_stat stat;
XDR xdrs;
- register struct authunix_parms *aup;
- register rpc_inline_t *buf;
+ struct authunix_parms *aup;
+ rpc_inline_t *buf;
struct area {
struct authunix_parms area_aup;
char area_machname[MAX_MACHINE_NAME+1];
SVCXPRT *
svcraw_create(void)
{
- register struct svcraw_private *srp = svcraw_private;
+ struct svcraw_private *srp = svcraw_private;
if (srp == 0) {
srp = (struct svcraw_private *)calloc(1, sizeof (*srp));
static bool_t
svcraw_recv(SVCXPRT *xprt, struct rpc_msg *msg)
{
- register struct svcraw_private *srp = svcraw_private;
- register XDR *xdrs;
+ struct svcraw_private *srp = svcraw_private;
+ XDR *xdrs;
if (srp == 0)
return (0);
static bool_t
svcraw_reply(SVCXPRT *xprt, struct rpc_msg *msg)
{
- register struct svcraw_private *srp = svcraw_private;
- register XDR *xdrs;
+ struct svcraw_private *srp = svcraw_private;
+ XDR *xdrs;
if (srp == 0)
return (FALSE);
static bool_t
svcraw_getargs(SVCXPRT *xprt, xdrproc_t xdr_args, void *args_ptr)
{
- register struct svcraw_private *srp = svcraw_private;
+ struct svcraw_private *srp = svcraw_private;
if (srp == 0)
return (FALSE);
static bool_t
svcraw_freeargs(SVCXPRT *xprt, xdrproc_t xdr_args, void *args_ptr)
{
- register struct svcraw_private *srp = svcraw_private;
- register XDR *xdrs;
+ struct svcraw_private *srp = svcraw_private;
+ XDR *xdrs;
if (srp == 0)
return (FALSE);
u_int recvsize)
{
bool_t madesock = FALSE;
- register SVCXPRT *xprt;
- register struct tcp_rendezvous *r;
+ SVCXPRT *xprt;
+ struct tcp_rendezvous *r;
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t len;
u_int sendsize,
u_int recvsize)
{
- register SVCXPRT *xprt;
- register struct tcp_conn *cd;
+ SVCXPRT *xprt;
+ struct tcp_conn *cd;
#ifdef FD_SETSIZE
if (fd >= FD_SETSIZE) {
static bool_t
rendezvous_request(
- register SVCXPRT *xprt,
+ SVCXPRT *xprt,
struct rpc_msg *msg)
{
SOCKET sock;
}
static enum xprt_stat
-rendezvous_stat(register SVCXPRT *xprt)
+rendezvous_stat(SVCXPRT *xprt)
{
return (XPRT_IDLE);
}
static void
-svctcp_destroy(register SVCXPRT *xprt)
+svctcp_destroy(SVCXPRT *xprt)
{
- register struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
+ struct tcp_conn *cd = xprt->xp_p1;
xprt_unregister(xprt);
(void)closesocket(xprt->xp_sock);
readtcp(
char *xprtptr,
caddr_t buf,
- register int len)
+ int len)
{
- register SVCXPRT *xprt = (SVCXPRT *)(void *)xprtptr;
- register int sock = xprt->xp_sock;
+ SVCXPRT *xprt = (void *)xprtptr;
+ int sock = xprt->xp_sock;
struct timeval tout;
#ifdef FD_SETSIZE
fd_set mask;
FD_ZERO(&mask);
FD_SET(sock, &mask);
#else
- register int mask = 1 << sock;
+ int mask = 1 << sock;
int readfds;
#endif /* def FD_SETSIZE */
#ifdef FD_SETSIZE
caddr_t buf,
int len)
{
- register SVCXPRT *xprt = (SVCXPRT *)(void *) xprtptr;
- register int i, cnt;
+ SVCXPRT *xprt = (void *)xprtptr;
+ int i, cnt;
for (cnt = len; cnt > 0; cnt -= i, buf += i) {
if ((i = write(xprt->xp_sock, buf, (size_t) cnt)) < 0) {
static enum xprt_stat
svctcp_stat(SVCXPRT *xprt)
{
- register struct tcp_conn *cd =
- (struct tcp_conn *)(xprt->xp_p1);
+ struct tcp_conn *cd = xprt->xp_p1;
if (cd->strm_stat == XPRT_DIED)
return (XPRT_DIED);
static bool_t
svctcp_recv(
SVCXPRT *xprt,
- register struct rpc_msg *msg)
+ struct rpc_msg *msg)
{
- register struct tcp_conn *cd =
- (struct tcp_conn *)(xprt->xp_p1);
- register XDR *xdrs = &(cd->xdrs);
+ struct tcp_conn *cd = xprt->xp_p1;
+ XDR *xdrs = &cd->xdrs;
xdrs->x_op = XDR_DECODE;
(void)xdrrec_skiprecord(xdrs);
xdrproc_t xdr_args,
void * args_ptr)
{
- register XDR *xdrs =
- &(((struct tcp_conn *)(xprt->xp_p1))->xdrs);
+ XDR *xdrs = &((struct tcp_conn *)(xprt->xp_p1))->xdrs;
xdrs->x_op = XDR_FREE;
return ((*xdr_args)(xdrs, args_ptr));
static bool_t svctcp_reply(
SVCXPRT *xprt,
- register struct rpc_msg *msg)
+ struct rpc_msg *msg)
{
- register struct tcp_conn *cd =
- (struct tcp_conn *)(xprt->xp_p1);
- register XDR *xdrs = &(cd->xdrs);
- register bool_t stat;
+ struct tcp_conn *cd = xprt->xp_p1;
+ XDR *xdrs = &cd->xdrs;
+ bool_t stat;
xdrproc_t xdr_results = NULL;
caddr_t xdr_location = 0;
*/
SVCXPRT *
svcudp_bufcreate(
- register int sock,
+ int sock,
u_int sendsz,
u_int recvsz)
{
bool_t madesock = FALSE;
- register SVCXPRT *xprt;
- register struct svcudp_data *su;
+ SVCXPRT *xprt;
+ struct svcudp_data *su;
struct sockaddr_storage ss;
struct sockaddr *sa = (struct sockaddr *)&ss;
socklen_t len;
static bool_t
svcudp_recv(
- register SVCXPRT *xprt,
+ SVCXPRT *xprt,
struct rpc_msg *msg)
{
struct msghdr dummy;
struct iovec dummy_iov[1];
- register struct svcudp_data *su = su_data(xprt);
- register XDR *xdrs = &(su->su_xdrs);
- register int rlen;
+ struct svcudp_data *su = su_data(xprt);
+ XDR *xdrs = &su->su_xdrs;
+ int rlen;
char *reply;
uint32_t replylen;
socklen_t addrlen;
}
static bool_t svcudp_reply(
- register SVCXPRT *xprt,
+ SVCXPRT *xprt,
struct rpc_msg *msg)
{
- register struct svcudp_data *su = su_data(xprt);
- register XDR *xdrs = &(su->su_xdrs);
- register int slen;
- register bool_t stat = FALSE;
+ struct svcudp_data *su = su_data(xprt);
+ XDR *xdrs = &su->su_xdrs;
+ int slen;
+ bool_t stat = FALSE;
xdrproc_t xdr_results = NULL;
caddr_t xdr_location = 0;
xdrproc_t xdr_args,
void * args_ptr)
{
- register XDR *xdrs = &(su_data(xprt)->su_xdrs);
+ XDR *xdrs = &su_data(xprt)->su_xdrs;
xdrs->x_op = XDR_FREE;
return ((*xdr_args)(xdrs, args_ptr));
}
static void
-svcudp_destroy(register SVCXPRT *xprt)
+svcudp_destroy(SVCXPRT *xprt)
{
- register struct svcudp_data *su = su_data(xprt);
+ struct svcudp_data *su = su_data(xprt);
xprt_unregister(xprt);
if (xprt->xp_sock != INVALID_SOCKET)
SVCXPRT *xprt,
uint32_t replylen)
{
- register cache_ptr victim;
- register cache_ptr *vicp;
- register struct svcudp_data *su = su_data(xprt);
+ cache_ptr victim;
+ cache_ptr *vicp;
+ struct svcudp_data *su = su_data(xprt);
struct udp_cache *uc = (struct udp_cache *) su->su_cache;
u_int loc;
char *newbuf;
uint32_t *replylenp)
{
u_int loc;
- register cache_ptr ent;
- register struct svcudp_data *su = su_data(xprt);
- register struct udp_cache *uc = (struct udp_cache *) su->su_cache;
+ cache_ptr ent;
+ struct svcudp_data *su = su_data(xprt);
+ struct udp_cache *uc = su->su_cache;
# define EQADDR(a1, a2) (memcmp((char*)&a1, (char*)&a2, sizeof(a1)) == 0)
void
rpc_test_prog_1_svc(rqstp, transp)
struct svc_req *rqstp;
- register SVCXPRT *transp;
+ SVCXPRT *transp;
{
union {
char *rpc_test_echo_1_arg;
{
int c, prot;
auth_gssapi_name names[2];
- register SVCXPRT *transp;
+ SVCXPRT *transp;
extern int optind;
#ifdef POSIX_SIGNALS
struct sigaction sa;
* XDR short integers
*/
bool_t
-xdr_short(register XDR *xdrs, short *sp)
+xdr_short(XDR *xdrs, short *sp)
{
long l;
* XDR unsigned short integers
*/
bool_t
-xdr_u_short(register XDR *xdrs, u_short *usp)
+xdr_u_short(XDR *xdrs, u_short *usp)
{
u_long l;
* XDR booleans
*/
bool_t
-xdr_bool(register XDR *xdrs, bool_t *bp)
+xdr_bool(XDR *xdrs, bool_t *bp)
{
long lb;
bool_t
xdr_opaque(XDR *xdrs, caddr_t cp, u_int cnt)
{
- register u_int rndup;
+ u_int rndup;
static int crud[BYTES_PER_XDR_UNIT];
/*
u_int *sizep,
u_int maxsize)
{
- register char *sp = *cpp; /* sp is the actual string pointer */
- register u_int nodesize;
+ char *sp = *cpp; /* sp is the actual string pointer */
+ u_int nodesize;
/*
* first deal with the length since xdr bytes are counted
xdrproc_t dfault /* default xdr routine */
)
{
- register enum_t dscm;
+ enum_t dscm;
/*
* we deal with the discriminator; it's an enum
bool_t
xdr_string(XDR *xdrs, char **cpp, u_int maxsize)
{
- register char *sp = *cpp; /* sp is the actual string pointer */
+ char *sp = *cpp; /* sp is the actual string pointer */
u_int size;
u_int nodesize;
}
static bool_t xdralloc_notsup_getlong(
- register XDR *xdrs,
+ XDR *xdrs,
long *lp)
{
return FALSE;
}
static bool_t xdralloc_putlong(
- register XDR *xdrs,
+ XDR *xdrs,
long *lp)
{
int l = htonl((uint32_t) *lp); /* XXX need bounds checking */
static bool_t xdralloc_notsup_getbytes(
- register XDR *xdrs,
+ XDR *xdrs,
caddr_t addr,
- register unsigned int len)
+ unsigned int len)
{
return FALSE;
}
static bool_t xdralloc_putbytes(
- register XDR *xdrs,
+ XDR *xdrs,
caddr_t addr,
- register unsigned int len)
+ unsigned int len)
{
if (DynInsert((DynObject) xdrs->x_private,
DynSize((DynObject) xdrs->x_private),
}
static bool_t xdralloc_notsup_setpos(
- register XDR *xdrs,
+ XDR *xdrs,
unsigned int lp)
{
return FALSE;
static rpc_inline_t *xdralloc_inline(
- register XDR *xdrs,
+ XDR *xdrs,
int len)
{
return (rpc_inline_t *) 0;
*/
bool_t
xdr_array(
- register XDR *xdrs,
+ XDR *xdrs,
caddr_t *addrp, /* array pointer */
u_int *sizep, /* number of elements */
u_int maxsize, /* max numberof elements */
xdrproc_t elproc /* xdr routine to handle each element */
)
{
- register u_int i;
- register caddr_t target = *addrp;
- register u_int c; /* the actual element count */
- register bool_t stat = TRUE;
- register u_int nodesize;
+ u_int i;
+ caddr_t target = *addrp;
+ u_int c; /* the actual element count */
+ bool_t stat = TRUE;
+ u_int nodesize;
/* like strings, arrays are really counted arrays */
if (! xdr_u_int(xdrs, sizep)) {
*/
bool_t
xdr_vector(
- register XDR *xdrs,
- register char *basep,
- register u_int nelem,
- register u_int elemsize,
- register xdrproc_t xdr_elem)
+ XDR *xdrs,
+ char *basep,
+ u_int nelem,
+ u_int elemsize,
+ xdrproc_t xdr_elem)
{
- register u_int i;
- register char *elptr;
+ u_int i;
+ char *elptr;
elptr = basep;
for (i = 0; i < nelem; i++) {
bool_t
xdr_double(XDR *xdrs, double *dp)
{
- register int32_t *lp;
+ int32_t *lp;
#if defined(vax)
struct ieee_double id;
struct vax_double vd;
- register struct dbl_limits *lim;
+ struct dbl_limits *lim;
int i;
#endif
static bool_t
xdrmem_setpos(XDR *xdrs, u_int pos)
{
- register caddr_t newaddr = xdrs->x_base + pos;
- register caddr_t lastaddr = (char *) xdrs->x_private + xdrs->x_handy;
+ caddr_t newaddr = xdrs->x_base + pos;
+ caddr_t lastaddr = (char *)xdrs->x_private + xdrs->x_handy;
if ((long)newaddr > (long)lastaddr)
return (FALSE);
int (*writeit)() /* like write, but pass it a tcp_handle, not sock */
)
{
- register RECSTREAM *rstrm =
- (RECSTREAM *)mem_alloc(sizeof(RECSTREAM));
+ RECSTREAM *rstrm = mem_alloc(sizeof(RECSTREAM));
if (rstrm == NULL) {
(void)fprintf(stderr, "xdrrec_create: out of memory\n");
static bool_t
xdrrec_getlong(XDR *xdrs, long *lp)
{
- register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
- register int32_t *buflp = (int32_t *)(void *)(rstrm->in_finger);
+ RECSTREAM *rstrm = xdrs->x_private;
+ int32_t *buflp = (void *)(rstrm->in_finger);
uint32_t mylong;
/* first try the inline, fast case */
static bool_t
xdrrec_putlong(XDR *xdrs, long *lp)
{
- register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
- register int32_t *dest_lp = ((int32_t *)(void *)(rstrm->out_finger));
+ RECSTREAM *rstrm = xdrs->x_private;
+ int32_t *dest_lp = (void *)(rstrm->out_finger);
if (rstrm->out_boundry - rstrm->out_finger < BYTES_PER_XDR_UNIT) {
/*
static bool_t /* must manage buffers, fragments, and records */
xdrrec_getbytes(XDR *xdrs, caddr_t addr, u_int len)
{
- register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
- register u_int current;
+ RECSTREAM *rstrm = xdrs->x_private;
+ u_int current;
while (len > 0) {
current = rstrm->fbtbc;
static bool_t
xdrrec_putbytes(XDR *xdrs, caddr_t addr, u_int len)
{
- register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
- register size_t current;
+ RECSTREAM *rstrm = xdrs->x_private;
+ size_t current;
while (len > 0) {
current = (size_t) ((long)rstrm->out_boundry -
static u_int
xdrrec_getpos(XDR *xdrs)
{
- register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
- register int pos;
+ RECSTREAM *rstrm = xdrs->x_private;
+ int pos;
switch (xdrs->x_op) {
static bool_t
xdrrec_setpos(XDR *xdrs, u_int pos)
{
- register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
+ RECSTREAM *rstrm = xdrs->x_private;
u_int currpos = xdrrec_getpos(xdrs);
int delta = currpos - pos;
caddr_t newpos;
static rpc_inline_t *
xdrrec_inline(XDR *xdrs, int len)
{
- register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
+ RECSTREAM *rstrm = xdrs->x_private;
rpc_inline_t * buf = NULL;
if (len < 0)
static void
xdrrec_destroy(XDR *xdrs)
{
- register RECSTREAM *rstrm = (RECSTREAM *)xdrs->x_private;
+ RECSTREAM *rstrm = xdrs->x_private;
mem_free(rstrm->the_buffer,
rstrm->sendsize + rstrm->recvsize + BYTES_PER_XDR_UNIT);
bool_t
xdrrec_skiprecord(XDR *xdrs)
{
- register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
+ RECSTREAM *rstrm = xdrs->x_private;
while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
if (! skip_input_bytes(rstrm, rstrm->fbtbc))
bool_t
xdrrec_eof(XDR *xdrs)
{
- register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
+ RECSTREAM *rstrm = xdrs->x_private;
while (rstrm->fbtbc > 0 || (! rstrm->last_frag)) {
if (! skip_input_bytes(rstrm, rstrm->fbtbc))
bool_t
xdrrec_endofrecord(XDR *xdrs, bool_t sendnow)
{
- register RECSTREAM *rstrm = (RECSTREAM *)(xdrs->x_private);
- register uint32_t len; /* fragment length */
+ RECSTREAM *rstrm = xdrs->x_private;
+ uint32_t len; /* fragment length */
if (sendnow || rstrm->frag_sent ||
((long)rstrm->out_finger + BYTES_PER_XDR_UNIT >=
static bool_t
flush_out(RECSTREAM *rstrm, bool_t eor)
{
- register uint32_t eormask = (eor == TRUE) ? LAST_FRAG : 0;
- register uint32_t len = (u_long)(rstrm->out_finger) -
+ uint32_t eormask = (eor == TRUE) ? LAST_FRAG : 0;
+ uint32_t len = (u_long)(rstrm->out_finger) -
(u_long)(rstrm->frag_header) - BYTES_PER_XDR_UNIT;
*(rstrm->frag_header) = htonl(len | eormask);
static bool_t /* knows nothing about records! Only about input buffers */
fill_input_buf(RECSTREAM *rstrm)
{
- register caddr_t where;
+ caddr_t where;
u_int i;
- register int len;
+ int len;
where = rstrm->in_base;
i = (u_int)((u_long)rstrm->in_boundry % BYTES_PER_XDR_UNIT);
static bool_t /* knows nothing about records! Only about input buffers */
get_input_bytes(RECSTREAM *rstrm, caddr_t addr, int len)
{
- register size_t current;
+ size_t current;
while (len > 0) {
current = (size_t)((long)rstrm->in_boundry -
static bool_t /* next four bytes of input stream are treated as a header */
set_input_fragment(rstrm)
- register RECSTREAM *rstrm;
+ RECSTREAM *rstrm;
{
uint32_t header;
static bool_t /* consumes input bytes; knows nothing about records! */
skip_input_bytes(RECSTREAM *rstrm, int32_t cnt)
{
- register int current;
+ int current;
while (cnt > 0) {
current = (int)((long)rstrm->in_boundry -
xdrproc_t proc /* xdr routine to handle the object */
)
{
- register caddr_t loc = *pp;
- register bool_t stat;
+ caddr_t loc = *pp;
+ bool_t stat;
if (loc == NULL)
switch (xdrs->x_op) {
__bt_defcmp(a, b)
const DBT *a, *b;
{
- register size_t len;
- register u_char *p1, *p2;
+ size_t len;
+ u_char *p1, *p2;
/*
* XXX
__bt_defpfx(a, b)
const DBT *a, *b;
{
- register u_char *p1, *p2;
- register size_t cnt, len;
+ u_char *p1, *p2;
+ size_t cnt, len;
cnt = 1;
len = MIN(a->size, b->size);
recno_t recno;
enum SRCHOP op;
{
- register indx_t idx;
- register PAGE *h;
+ indx_t idx;
+ PAGE *h;
EPGNO *parent;
RINTERNAL *r;
db_pgno_t pg;
DB *db;
char **argv;
{
- register char *p, *t;
+ char *p, *t;
FILE *fp;
DBT data, key;
recno_t cnt;
compare(db1, db2)
DBT *db1, *db2;
{
- register size_t len;
- register u_char *p1, *p2;
+ size_t len;
+ u_char *p1, *p2;
if (db1->size != db2->size) {
printf("compare failed: key->data len %lu != data len %lu\n",
swig_module_info *iter = start;
do {
if (iter->size) {
- register size_t l = 0;
- register size_t r = iter->size - 1;
+ size_t l = 0;
+ size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
- register size_t i = (l + r) >> 1;
+ size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
- register int compare = strcmp(name, iname);
+ int compare = strcmp(name, iname);
if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
- register size_t i = 0;
+ size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
- register const unsigned char *u = (unsigned char *) ptr;
- register const unsigned char *eu = u + sz;
+ const unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register unsigned char uu = *u;
+ unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
- register unsigned char *u = (unsigned char *) ptr;
- register const unsigned char *eu = u + sz;
+ unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register char d = *(c++);
- register unsigned char uu;
+ char d = *(c++);
+ unsigned char uu;
if ((d >= '0') && (d <= '9'))
uu = ((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
static l_quoted_string()
{
- register char *p;
+ char *p;
yylval.dynstr = strdup(yytext+1);
if (p=strrchr(yylval.dynstr, '"'))
*p='\0';
char * ss_name(sci_idx)
int sci_idx;
{
- register ss_data *infop;
+ ss_data *infop;
infop = ss_info(sci_idx);
if (infop->current_request == (char const *)NULL) {
void ss_error (int sci_idx, long code, const char * fmt, ...)
{
- register char *whoami;
+ char *whoami;
va_list pvar;
va_start (pvar, fmt);
whoami = ss_name (sci_idx);
*/
static int check_request_table (rqtbl, argc, argv, sci_idx)
- register ss_request_table *rqtbl;
+ ss_request_table *rqtbl;
int argc;
char *argv[];
int sci_idx;
{
- register ss_request_entry *request;
- register ss_data *info;
- register char const * const * name;
+ ss_request_entry *request;
+ ss_data *info;
+ char const *const *name;
char *string = argv[0];
int i;
int argc;
char **argv[];
{
- register ss_request_table **rqtbl;
- register ss_data *info;
+ ss_request_table **rqtbl;
+ ss_data *info;
info = ss_info(sci_idx);
int
ss_execute_command(sci_idx, argv)
int sci_idx;
- register char *argv[];
+ char *argv[];
{
- register unsigned int i, argc;
+ unsigned int i, argc;
char **argp;
int ret;
char const *request_name;
int code;
int fd, child;
- register int idx;
- register ss_data *info;
+ int idx;
+ ss_data *info;
request_name = ss_current_request(sci_idx, &code);
if (code != 0) {
char *info_dir;
int *code_ptr;
{
- register ss_data *info;
+ ss_data *info;
DIR *d;
int n_dirs;
- register char **dirs;
+ char **dirs;
info = ss_info(sci_idx);
if ((info_dir == NULL) || (*info_dir == '\0')) {
char *info_dir;
int *code_ptr;
{
- register char **i_d;
- register char **info_dirs;
+ char **i_d;
+ char **info_dirs;
info_dirs = ss_info(sci_idx)->info_dirs;
for (i_d = info_dirs; *i_d; i_d++) {
ss_request_table *request_table_ptr;
int *code_ptr;
{
- register int sci_idx;
- register ss_data *new_table;
- register ss_data **table, **tmp;
+ int sci_idx;
+ ss_data *new_table;
+ ss_data **table, **tmp;
*code_ptr = 0;
table = _ss_table;
ss_delete_invocation(sci_idx)
int sci_idx;
{
- register ss_data *t;
+ ss_data *t;
int ignored_code;
t = ss_info(sci_idx);
char *info_ptr;
#endif
{
- register ss_request_entry *entry;
- register char const * const *name;
- register int spacing;
- register ss_request_table **table;
+ ss_request_entry *entry;
+ char const *const *name;
+ int spacing;
+ ss_request_table **table;
char buffer[BUFSIZ];
FILE *output;
continue;
buffer[sizeof(buffer) - 1] = '\0';
for (name = entry->command_names; *name; name++) {
- register int len = strlen(*name);
+ int len = strlen(*name);
strncat(buffer, *name, sizeof(buffer) - 1 - strlen(buffer));
spacing += len + 2;
if (name[1]) {
int ss_listen (sci_idx)
int sci_idx;
{
- register char *cp;
- register ss_data *info;
+ char *cp;
+ ss_data *info;
char *input;
int code;
jmp_buf old_jmpb;
struct sigaction isig, csig, nsig, osig;
sigset_t nmask, omask;
#else
- register RETSIGTYPE (*sig_cont)();
+ RETSIGTYPE (*sig_cont)();
RETSIGTYPE (*sig_int)(), (*old_sig_cont)();
int mask;
#endif
code = ss_execute_line (sci_idx, input);
if (code == SS_ET_COMMAND_NOT_FOUND) {
- register char *c = input;
+ char *c = input;
while (*c == ' ' || *c == '\t')
c++;
cp = strchr (c, ' ');
long
flag_val(string)
- register char *string;
+ char *string;
{
- register struct option *opt;
+ struct option *opt;
for (opt = options; opt->text; opt++)
if (!strcmp(opt->text, string))
return(opt->value);
{
/* minimal recovery if pager program isn't found */
char buf[80];
- register int n;
+ int n;
while ((n = read(0, buf, 80)) > 0)
write(1, buf, (unsigned) n);
}
char **ss_parse (sci_idx, line_ptr, argc_ptr)
int sci_idx;
- register char *line_ptr;
+ char *line_ptr;
int *argc_ptr;
{
- register char **argv, *cp;
+ char **argv, *cp;
char **newargv;
- register int argc;
- register enum parse_mode parse_mode;
+ int argc;
+ enum parse_mode parse_mode;
argv = (char **) malloc (sizeof(char *));
if (argv == (char **)NULL) {
int position; /* 1 -> becomes second... */
int *code_ptr;
{
- register ss_data *info;
- register int i, size;
+ ss_data *info;
+ int i, size;
info = ss_info(sci_idx);
for (size=0; info->rqt_tables[size] != (ssrt *)NULL; size++)
ssrt *rqtbl_ptr;
int *code_ptr;
{
- register ss_data *info;
- register ssrt **rt1, **rt2;
+ ss_data *info;
+ ssrt **rt1, **rt2;
*code_ptr = SS_ET_TABLE_NOT_FOUND;
info = ss_info(sci_idx);
*/
DECLARE(ss_self_identify)
{
- register ss_data *info = ss_info(sci_idx);
+ ss_data *info = ss_info(sci_idx);
printf("%s version %s\n", info->subsystem_name,
info->subsystem_version);
}
/* concatenate three strings and return the result */
char *str_concat3(a, b, c)
- register char *a, *b, *c;
+ char *a, *b, *c;
{
char *result;
/* return copy of string enclosed in double-quotes */
char *quote(string)
- register char *string;
+ char *string;
{
- register char *result;
+ char *result;
asprintf(&result, "\"%s\"", string);
return(result);
#ifndef HAVE_STRDUP
/* make duplicate of string and return pointer */
char *strdup(s)
- register char *s;
+ char *s;
{
- register int len = strlen(s) + 1;
- register char *new;
+ int len = strlen(s) + 1;
+ char *new;
new = malloc(len);
strncpy(new, s, len);
return(new);
static int
_gettemp(path, doopen)
char *path;
- register int *doopen;
+ int *doopen;
{
- register char *start, *trv;
+ char *start, *trv;
struct stat sbuf;
u_int pid;
{
char buffer[512];
int cc;
- register long *nettime;
- register int s;
+ long *nettime;
+ int s;
long hosttime;
struct hostent *host;
struct timeval tv;
projects / thirdparty / krb5.git / commitdiff
