exit(2);
}
- bzero((char *) &sin,sizeof(sin));
+ memset((char *) &sin, 0,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(debug_port);
sin.sin_addr.s_addr = INADDR_ANY;
exit(2);
}
- bzero((char *) &sin,sizeof(sin));
+ memset((char *) &sin, 0,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(debug_port);
sin.sin_addr.s_addr = INADDR_ANY;
(void) strncpy(pp, pp2, sizeof(pp));
pp[8]='\0';
namep = crypt(pp, pwd->pw_passwd);
- bzero (pp, sizeof(pp)); /* To the best of my recollection, Senator... */
+ memset (pp, 0, sizeof(pp)); /* To the best of my recollection, Senator... */
lpass_ok = !strcmp (namep, pwd->pw_passwd);
if (pwd->pw_uid != 0) { /* Don't get tickets for root */
realm, "krbtgt",
realm,
DEFAULT_TKT_LIFE, pp2);
- bzero (pp2, sizeof(pp2));
+ memset (pp2, 0, sizeof(pp2));
(void) setpriority(PRIO_PROCESS, 0, 0 + PRIO_OFFSET);
switch (krbval) {
case INTK_OK:
break;
}
} else {
- (void) bzero (pp2, sizeof(pp2));
+ (void) memset (pp2, 0, sizeof(pp2));
(void) setpriority(PRIO_PROCESS, 0, 0 + PRIO_OFFSET);
}
{
struct utmp utmp;
- bzero((char *)&utmp, sizeof(utmp));
+ memset((char *)&utmp, 0, sizeof(utmp));
login_time = time(&utmp.ut_time);
(void) strncpy(utmp.ut_name, username, sizeof(utmp.ut_name));
if (hostname)
(void) strncpy(utmp.ut_host, hostname,
sizeof(utmp.ut_host));
else
- bzero(utmp.ut_host, sizeof(utmp.ut_host));
+ memset(utmp.ut_host, 0, sizeof(utmp.ut_host));
(void) strncpy(utmp.ut_line, tty, sizeof(utmp.ut_line));
login(&utmp);
}
if (hostname)
(void) strncpy(ll.ll_host, hostname, sizeof(ll.ll_host));
else
- (void) bzero(ll.ll_host, sizeof(ll.ll_host));
+ (void) memset(ll.ll_host, 0, sizeof(ll.ll_host));
(void)write(fd, (char *)&ll, sizeof(ll));
(void)close(fd);
}
* Kerberos autologin protocol.
*/
- (void) bzero((char *) &sin, (int) sizeof(sin));
+ (void) memset((char *) &sin, 0, (int) sizeof(sin));
if (hp)
(void) bcopy (hp->h_addr, (char *)&sin.sin_addr,
(void) strncpy(ut->ut_id, ut->ut_line, sizeof(ut->ut_id));
(void) setutent();
- (void) bzero((char *)&utmp, sizeof(utmp));
+ (void) memset((char *)&utmp, 0, sizeof(utmp));
(void) strncpy(utmp.ut_id, ut->ut_id, sizeof(utmp.ut_id));
utmp.ut_type = DEAD_PROCESS;
(void) getutid(&utmp);
if ((ret = ZInitialize()) == ZERR_NONE)
init = 0;
- bzero(¬ice, sizeof(notice));
+ memset(¬ice, 0, sizeof(notice));
notice.z_kind = UNSAFE;
notice.z_class = "message";
notice.z_class_inst = "pop";
char * trace_file_name;
/* Initialize the POP parameter block */
- bzero ((char *)p,(int)sizeof(POP));
+ memset ((char *)p, 0,(int)sizeof(POP));
/* Save my name in a global variable */
p->myname = argmessage[0];
fb64_init(fbp)
register struct fb *fbp;
{
- bzero((void *)fbp, sizeof(*fbp));
+ memset((void *)fbp, 0, sizeof(*fbp));
fbp->state[0] = fbp->state[1] = FAILED;
fbp->fb_feed[0] = IAC;
fbp->fb_feed[1] = SB;
break;
case FB64_IV_BAD:
- bzero(fbp->temp_feed, sizeof(Block));
+ memset(fbp->temp_feed, 0, sizeof(Block));
fb64_stream_iv(fbp->temp_feed, &fbp->streams[DIR_ENCRYPT-1]);
state = FAILED;
break;
return(0);
}
- bzero(instance, sizeof(instance));
+ memset(instance, 0, sizeof(instance));
if (realm = krb_get_phost(RemoteHostName))
strncpy(instance, realm, sizeof(instance));
ksum.checksum_type = CKSUMTYPE_CRC32;
ksum.contents = sum;
ksum.length = sizeof(sum);
- bzero((Voidptr )sum, sizeof(sum));
+ memset((Voidptr )sum, 0, sizeof(sum));
if (!UserNameRequested) {
if (auth_debug_mode) {
return(0);
}
- bzero((char *)&creds, sizeof(creds));
+ memset((char *)&creds, 0, sizeof(creds));
if (r = krb5_sname_to_principal(RemoteHostName,"host",KRB5_NT_SRV_HST,
&creds.server)) {
if (auth_debug_mode)
gethostname(hostname, sizeof(hostname));
realm = krb_realmofhost(hostname);
bcopy((void *)data, (void *)challenge, cnt);
- bzero(user_passwd, sizeof(user_passwd));
+ memset(user_passwd, 0, sizeof(user_passwd));
local_des_read_pw_string(user_passwd, sizeof(user_passwd)-1, "Password: ", 0);
UserPassword = user_passwd;
Challenge = challenge;
#define WIDEVAL 0
void
-bzero(dst0, length)
+memset(dst0, 0, length)
void *dst0;
register size_t length;
#else
lose:
if (!ok)
- bzero(s, max);
+ memset(s, 0, max);
printf("\n");
/* turn echo back on */
tty_state.sg_flags |= ECHO;
*/
bcopy((char *)env, (char *)old_env, sizeof(env));
if (verify)
- bzero(key_string, sizeof (key_string));
+ memset(key_string, 0, sizeof (key_string));
s[max-1] = 0; /* force termination */
return !ok; /* return nonzero if not okay */
}
if (server) {
str_data[3] = TELQUAL_REPLY;
- bzero(key_file, sizeof(key_file));
+ memset(key_file, 0, sizeof(key_file));
gethostname(lhostname, sizeof(lhostname));
if ((cp = index(lhostname, '.')) != 0) *cp = '\0';
strcpy(key_file, "/etc/.");
pubkey_len = DecodeValueLength(ptr);
ptr += NumEncodeLengthOctets(pubkey_len);
bcopy(ptr, pubkey, pubkey_len);
- bzero(user_passwd, sizeof(user_passwd));
+ memset(user_passwd, 0, sizeof(user_passwd));
local_des_read_pw_string(user_passwd, sizeof(user_passwd)-1, "Password: ", 0);
UserPassword = user_passwd;
Challenge = challenge;
char *cmd, *hostp = 0, *portp = 0, *user = 0;
/* clear the socket address prior to use */
- bzero((char *)&sin, sizeof(sin));
+ memset((char *)&sin, 0, sizeof(sin));
if (connected) {
printf("?Already connected to %s\n", hostname);
init_termbuf();
# ifdef TIOCGWINSZ
if (def_row || def_col) {
- bzero((char *)&ws, sizeof(ws));
+ memset((char *)&ws, 0, sizeof(ws));
ws.ws_col = def_col;
ws.ws_row = def_row;
(void)ioctl(t, TIOCSWINSZ, (char *)&ws);
* Create utmp entry for child
*/
- bzero(&utmpx, sizeof(utmpx));
+ memset(&utmpx, 0, sizeof(utmpx));
SCPYN(utmpx.ut_user, ".telnet");
SCPYN(utmpx.ut_line, line + sizeof("/dev/") - 1);
utmpx.ut_pid = pid;
if (secflag) {
int sz = sizeof(ss);
- bzero((char *)&dv, sizeof(dv));
+ memset((char *)&dv, 0, sizeof(dv));
if (getsysv(&sysv, sizeof(struct sysv)) != 0) {
perror("getsysv");
int szi = sizeof(int);
#endif /* SO_SEC_MULTI */
- bzero((char *)&dv, sizeof(dv));
+ memset((char *)&dv, 0, sizeof(dv));
if (getsysv(&sysv, sizeof(struct sysv)) != 0) {
perror("getsysv");
if (def_col || def_row) {
struct winsize ws;
- bzero((char *)&ws, sizeof(ws));
+ memset((char *)&ws, 0, sizeof(ws));
ws.ws_col = def_col;
ws.ws_row = def_row;
(void) ioctl(pty, TIOCSWINSZ, (char *)&ws);
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:08 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:26:54 eichin
* autoconfed isode for kerberos work
*
#ifndef VSPRINTF
#ifdef pyr
- bzero ((char *) &iob, sizeof iob);
+ memset ((char *) &iob, 0, sizeof iob);
iob._file = _NFILE;
#endif
iob._flag = _IOWRT | _IOSTRG;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:09 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:26:59 eichin
* autoconfed isode for kerberos work
*
return NOTOK;
}
- bzero ((char *) isock, sizeof *isock);
+ memset ((char *) isock, 0, sizeof *isock);
isock -> sin_family = hp -> h_addrtype;
isock -> sin_port = port;
inaddr_copy (hp, isock);
return NOTOK;
}
- bzero ((char *) lsock, sizeof *lsock);
+ memset ((char *) lsock, 0, sizeof *lsock);
lsock -> sin_family = hp -> h_addrtype;
inaddr_copy (hp, lsock);
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:11 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:01 eichin
* autoconfed isode for kerberos work
*
(void) gen2if (remote, sck, ADDR_REMOTE);
if ((r = connect (fd, sck, sizeof (CONN_DB))) >= 0)
ioctl (fd, CCL_SEND_TYPE, 0);
- bzero(calling_dte, sizeof calling_dte );
+ memset(calling_dte, 0, sizeof calling_dte );
return (r);
}
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:12 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:11 eichin
* autoconfed isode for kerberos work
*
}
if (sock == NULL) {
- bzero ((caddr_t) &up -> dgram_peer, sizeof up -> dgram_peer);
+ memset ((caddr_t) &up -> dgram_peer, 0, sizeof up -> dgram_peer);
return OK;
}
action ("CLOSE", fd, &up -> dgram_peer.sa);
up -> dgram_parent = NOTOK;
- bzero ((char *) &up -> dgram_peer, sizeof up -> dgram_peer);
+ memset ((char *) &up -> dgram_peer, 0, sizeof up -> dgram_peer);
QBFREE (&up -> dgram_queue);
for (vp = (up = peers) + maxpeers; up < vp; up++)
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:14 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:18 eichin
* autoconfed isode for kerberos work
*
int sd, onoff, pgrp;
char cudfbuf [NPSIZE + CUDFSIZE];
- bzero(&sbuf, sizeof(CONN_DB));
+ memset(&sbuf, 0, sizeof(CONN_DB));
sbuf.addr.x25_family = AF_CCITT;
if ((sd = socket (AF_CCITT, SOCK_STREAM, 0)) == NOTOK) {
SLOG (compat_log, LLOG_EXCEPTIONS, "failed", ("socket"));
CONN_DB *sock = &sbuf;
register int nfd;
- bzero(&sbuf, sizeof(CONN_DB));
+ memset(&sbuf, 0, sizeof(CONN_DB));
sbuf.addr.x25_family = AF_CCITT;
sock = gen2if (remote, sock, ADDR_REMOTE);
int len = sizeof *sock;
int nfd;
- bzero(&sbuf, sizeof(CONN_DB));
+ memset(&sbuf, 0, sizeof(CONN_DB));
sbuf.addr.x25_family = AF_CCITT;
if ((nfd = accept (fd, (X25_ADDR *) &sock->addr, &len)) == NOTOK) {
return nfd;
FACILITY_DB facilities;
CCITT_FACILITY_DB ccitt_facilities;
- bzero ((char *) &facilities, sizeof (FACILITY_DB));
- bzero ((char *) &ccitt_facilities, sizeof (CCITT_FACILITY_DB));
+ memset ((char *) &facilities, 0, sizeof (FACILITY_DB));
+ memset ((char *) &ccitt_facilities, 0, sizeof (CCITT_FACILITY_DB));
if (ioctl (sd, X25_RD_FACILITIES, (char *) &ccitt_facilities) == NOTOK) {
SLOG (x25_log, LLOG_EXCEPTIONS, "failed", ("X25_RD_FACILITIES"));
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:16 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:24 eichin
* autoconfed isode for kerberos work
*
h -> h_length = sizeof (iaddr);
#ifdef h_addr
h -> h_addr_list = addrs;
- bzero ((char *) addrs, sizeof addrs);
+ memset ((char *) addrs, 0, sizeof addrs);
#endif
h -> h_addr = (char *) &iaddr;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:18 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:26 eichin
* autoconfed isode for kerberos work
*
return;
inited = 1;
- bzero ((char *) Mbuckets, sizeof Mbuckets);
+ memset ((char *) Mbuckets, 0, sizeof Mbuckets);
read_file (isodefile (isomacros, 0));
LLOG (addr_log, LLOG_DEBUG, ("str2paddr: %s", str));
i = i % 2;
- bzero ((char *) pa, sizeof *pa);
+ memset ((char *) pa, 0, sizeof *pa);
(void) strcpy (buf1, str);
state = PS_INIT;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:20 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:36 eichin
* autoconfed isode for kerberos work
*
&& (servf = fopen (isodefile (isoservices, 0), "r")) == NULL)
return NULL;
- bzero ((char *) is, sizeof *is);
+ memset ((char *) is, 0, sizeof *is);
while (fgets (buffer, sizeof buffer, servf) != NULL) {
if (*buffer == '#')
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:21 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:46 eichin
* autoconfed isode for kerberos work
*
return ca;
}
- bzero ((char *) ca, sizeof *ca);
+ memset ((char *) ca, 0, sizeof *ca);
ca -> na_stack = NA_NSAP;
for (ts = ts_interim; ts -> ts_name; ts++)
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:23 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:54 eichin
* autoconfed isode for kerberos work
*
n > 2 && n <= m - 2)
{ /* encoded! */
tz = &px -> pa_addr.sa_addr;
- bzero ((char *)ta, sizeof *ta);
+ memset ((char *)ta, 0, sizeof *ta);
if ((ta -> ta_selectlen = m - n - 2) > 0)
bcopy (&tz -> ta_selector[n+2], ta -> ta_selector,
ta -> ta_selectlen);
paddr2str (pa, NULLNA));
bp += strlen (bp);
- bzero ((char *) pa, sizeof *pa);
+ memset ((char *) pa, 0, sizeof *pa);
*ta = px -> pa_addr.sa_addr; /* struct copy */
ta -> ta_selectlen = 0;
}
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:24 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:27:59 eichin
* autoconfed isode for kerberos work
*
if (!sa)
return NULL;
- bzero ((char *) pa, sizeof *pa);
+ memset ((char *) pa, 0, sizeof *pa);
pa -> pa_addr = *sa; /* struct copy */
return paddr2str (pa, NULLNA);
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:26 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:28:26 eichin
* autoconfed isode for kerberos work
*
if (srcptr == 0)
return (NOTOK);
- bzero (idex, sizeof idex);
+ memset (idex, 0, sizeof idex);
for (destptr = dlmstr; *destptr; destptr++)
idex[*destptr] = 1;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:27 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:28:31 eichin
* autoconfed isode for kerberos work
*
i = r;
i = implode ((u_char *) sel, s, i);
if ((r = (n - i)) > 0)
- bzero (sel + i, r);
+ memset (sel + i, 0, r);
return i;
}
if (*s == '#') { /* gosip style, network byte-order */
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:28 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:28:39 eichin
* autoconfed isode for kerberos work
*
return NOTOK;
if (ioctl (sd, X25_SET_FACILITY, &f) == NOTOK)
return NOTOK;
- bzero ((char *)xs, sizeof *xs);
+ memset ((char *)xs, 0, sizeof *xs);
if (bind (sd, (struct sockaddr *)xs, sizeof *xs) == NOTOK) {
SLOG (compat_log, LLOG_EXCEPTIONS, "failed", ("bind"));
(void) close_x25_socket (sd);
if (local -> na_pidlen > NPSIZE)
local -> na_pidlen = NPSIZE;
*sock = *xs; /* struct copy */
- bzero((char *) sock -> data, NPSIZE);
+ memset((char *) sock -> data, 0, NPSIZE);
bcopy (local -> na_pid, (char *) sock -> data, local -> na_pidlen);
bcopy (local -> na_cudf, (char *) sock -> data + NPSIZE,
local -> na_cudflen);
{
FACILITY_DB facilities;
- bzero ((char *) &facilities, sizeof facilities);
+ memset ((char *) &facilities, 0, sizeof facilities);
if (coc != CALLED
&& ioctl (sd, X25_RD_FACILITY, (char *) &facilities) == NOTOK) {
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:31 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:28:41 eichin
* autoconfed isode for kerberos work
*
if (!ta)
return NULL;
- bzero ((char *) pa, sizeof *pa);
+ memset ((char *) pa, 0, sizeof *pa);
pa -> pa_addr.sa_addr = *ta; /* struct copy */
return paddr2str (pa, NULLNA);
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:33 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:28:53 eichin
* autoconfed isode for kerberos work
*
*/
if (generic -> na_stack == NA_NSAP) {
- bzero ((char *)specific, sizeof *specific);
+ memset ((char *)specific, 0, sizeof *specific);
return specific;
}
#endif
#if !defined(CAMTEC_CCL) && !defined(HPUX_X25)
- bzero ((char *)specific, sizeof *specific);
+ memset ((char *)specific, 0, sizeof *specific);
#endif
#ifdef UBC_X25
("PID too long (%d > %d)", generic -> na_pidlen, NPSIZE));
return (CONN_DB *)0;
} else {
- bzero((char *)specific -> addr.x25pid, NPSIZE);
+ memset((char *)specific -> addr.x25pid, 0, NPSIZE);
bcopy (generic -> na_pid, (char *)specific -> addr.x25pid,
specific -> addr.x25pidlen = generic -> na_pidlen);
bcopy (generic -> na_pid, (char *)specific -> cudf.x25_cu_data,
("PID too long (%d > %d)", generic -> na_pidlen, NPSIZE));
return (CONN_DB *)0;
} else {
- bzero((char *)specific -> data, NPSIZE);
+ memset((char *)specific -> data, 0, NPSIZE);
bcopy (generic -> na_pid, (char *)specific -> data,
generic -> na_pidlen);
bcopy (generic -> na_cudf, (char *) specific -> data + NPSIZE,
int i;
iov -> iov_len = dtelen + 4;
- bzero(iov -> iov_base, iov -> iov_len + 1);
+ memset(iov -> iov_base, 0, iov -> iov_len + 1);
a = iov -> iov_base;
b = dte;
*a++ = '#';
}
/*
* CUDF & PID must be merged. malloc initailly PIDsize space
- * and bzero it. this may be UK net specific action which
+ * and zero it. this may be UK net specific action which
* ensures we do NOT fall foul of listeners which use pid
* to match as well as "true" cudf & DTE.
*/
(iov = &(specific -> ccl_iovec[2])) -> iov_len = 0;
if (generic -> na_faclen != 0)
- bcopy (generic -> na_fac, iov -> iov_base,
+ bcopy (generic -> na_fac, 0, iov -> iov_base,
iov -> iov_len = min( generic -> na_faclen, FACSIZE) );
iov++;
if ( (iov -> iov_len = generic -> na_pidlen) != 0)
if (generic == NULLNA || specific == (CONN_DB *) 0)
return NULLNA;
- bzero ((char *)generic, sizeof *generic);
- bzero (dte, sizeof dte);
+ memset ((char *)generic, 0, sizeof *generic);
+ memset (dte, 0, sizeof dte);
dtelen = 0;
generic -> na_stack = NA_X25;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:41 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:30:33 eichin
* autoconfed isode for kerberos work
*
char *buf;
buf = malloc(NBPI / NBPC + 1);
- bzero(buf, NBPI / NBPC + 1);
+ memset(buf, 0, NBPI / NBPC + 1);
lastb = -1;
ibits = yv->yv_number;
for (i = 0; i < NBPI; i++) {
if ((buf = malloc((unsigned)size)) == NULL) {
ferrd(1, "valisttobs:malloc:failed on %d\n", size);
}
- bzero(buf, size);
+ memset(buf, 0, size);
for (yv1 = yv->yv_idlist; yv1 != NULL; yv1 = yv1->yv_next) {
if ((yv2 = calc_yv(yp, yv1->yv_identifier)) == NULL) {
return (-1);
if ((buf = realloc(buf, (unsigned)nsize)) == NULL) {
ferrd(1, "valisttobs:realloc:failed on %d\n", nsize);
}
- bzero(buf + size, nsize - size);
+ memset(buf + size, 0, nsize - size);
size = nsize;
}
buf[val / NBPC] |= 1 << (NBPC - 1 - (val % NBPC));
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:52 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:32:22 eichin
* autoconfed isode for kerberos work
*
static struct SSAPref srs;
register struct SSAPref *sr = &srs;
- bzero ((char *) sr, sizeof *sr);
+ memset ((char *) sr, 0, sizeof *sr);
if ((pe = t61s2prim (addr, strlen (addr))) == NULLPE)
return NULL;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:53 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:32:25 eichin
* autoconfed isode for kerberos work
*
if (pe -> pe_len < (PElementLen) (len = i + 1)) {
if ((bp = PEDalloc (len)) == NULLPED)
return NULLPED;
- bzero ((char *) bp, len);
+ memset ((char *) bp, 0, len);
if (pe -> pe_prim) {
PEDcpy (pe -> pe_prim, bp, pe -> pe_len);
if (pe -> pe_inline)
pe_free (r);
return NULLPED;
}
- bzero ((char *) r -> pe_prim, len);
+ memset ((char *) r -> pe_prim, 0, len);
r -> pe_nbits = j + 1;
*mask = 1 << (7 - (j % 8));
for (p = &pe -> pe_cons; q = *p; p = &q -> pe_next)
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:55 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:32:42 eichin
* autoconfed isode for kerberos work
*
register int i;
static char buffer[sizeof (int) + 1];
- bzero (buffer, sizeof (buffer));
+ memset (buffer, 0, sizeof (buffer));
for (i = 0; i < len; i++)
if (n & (1 << i))
buffer[i / 8] |= (1 << (7 - (i % 8)));
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:56 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:33:20 eichin
* autoconfed isode for kerberos work
*
pe_list = pe -> pe_next;
}
- bzero ((char *)pe, sizeof *pe);
+ memset ((char *)pe, 0, sizeof *pe);
pe -> pe_class = class;
pe -> pe_form = form;
pe -> pe_id = id;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:57 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:33:45 eichin
* autoconfed isode for kerberos work
*
register OID o = &oid;
if (once_only) {
- bzero ((char *) o, sizeof *o);
+ memset ((char *) o, 0, sizeof *o);
once_only = 0;
}
*
*
* $Log$
+ * Revision 1.2 1994/06/15 20:59:59 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:33:56 eichin
* autoconfed isode for kerberos work
*
static UTCtime ut;
register UTC u = &ut;
- bzero ((char *) u, sizeof *u);
+ memset ((char *) u, 0, sizeof *u);
if (sscanf (cp, "%2d%2d%2d%2d%2d", &year, &u -> ut_mon,
&u -> ut_mday, &u -> ut_hour, &u -> ut_min) != 5)
static UTCtime ut;
register UTC u = &ut;
- bzero ((char *) u, sizeof *u);
+ memset ((char *) u, 0, sizeof *u);
if (sscanf (cp, "%4d%2d%2d%2d", &u -> ut_year, &u -> ut_mon,
&u -> ut_mday, &u -> ut_hour) != 4)
*
*
* $Log$
+ * Revision 1.2 1994/06/15 21:00:01 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:35:19 eichin
* autoconfed isode for kerberos work
*
register struct tm *tm;
register UTC ut;
{
- bzero ((char *) ut, sizeof *ut);
+ memset ((char *) ut, 0, sizeof *ut);
ut -> ut_year = YEAR (tm -> tm_year);
ut -> ut_mon = tm -> tm_mon + 1;
*
*
* $Log$
+ * Revision 1.2 1994/06/15 21:00:04 eichin
+ * step 1: bzero->memset(,0,)
+ *
* Revision 1.1 1994/06/10 03:35:24 eichin
* autoconfed isode for kerberos work
*
static struct tm tms;
register struct tm *tm = &tms;
- bzero ((char *) tm, sizeof *tm);
+ memset ((char *) tm, 0, sizeof *tm);
tm -> tm_sec = ut -> ut_sec;
tm -> tm_min = ut -> ut_min;
kerror = kdb_verify_master_key (master_key, master_key_schedule, stdout);
if (kerror < 0) {
klog (L_KRB_PERR, "Can't verify master key.");
- bzero (master_key, sizeof (master_key));
- bzero (master_key_schedule, sizeof (master_key_schedule));
+ memset (master_key, 0, sizeof (master_key));
+ memset (master_key_schedule, 0, sizeof (master_key_schedule));
exit (-1);
}
static krb5_error_code retval;
static krb5_data *response;
-#ifndef bzero
-void bzero();
-#endif
#ifndef bcopy
void bcopy();
#endif
client_sockaddr.sin_port = client_fulladdr->port;
bcopy( addr->contents, &client_sockaddr.sin_addr,
sizeof client_sockaddr.sin_addr);
- bzero( client_sockaddr.sin_zero, sizeof client_sockaddr.sin_zero);
+ memset( client_sockaddr.sin_zero, 0, sizeof client_sockaddr.sin_zero);
/* convert v5 packet structure to v5's.
* this copy is gross, but necessary:
retval = 0;
bcopy( out5.contents, out4, out5.length);
}
- bzero( out5.contents, out5.length);
+ memset( out5.contents, 0, out5.length);
krb5_xfree( out5.contents);
return( retval);
}
lifetime = min(req_life, ((u_long) s_name_data.max_life));
lifetime = min(lifetime, ((u_long) a_name_data.max_life));
#ifdef NOENCRYPTION
- bzero(session_key, sizeof(C_Block));
+ memset(session_key, 0, sizeof(C_Block));
#else
/* random session key */
random_key(session_key);
a_name_data.instance, local_realm,
client_host.s_addr, session_key, lifetime, kerb_time.tv_sec,
s_name_data.name, s_name_data.instance, key);
- bzero(key, sizeof(key));
- bzero(key_s, sizeof(key_s));
+ memset(key, 0, sizeof(key));
+ memset(key_s, 0, sizeof(key_s));
/*
* get the user's key, unseal it from the server's key, and
s_name_data.key_version, tk, kerb_time.tv_sec, key);
/* clear session key */
- bzero(session_key, sizeof(session_key));
+ memset(session_key, 0, sizeof(session_key));
- bzero(key, sizeof(key));
+ memset(key, 0, sizeof(key));
a_name_data.key_version, ciph);
krb4_sendto(f, (char *) rpkt->dat, rpkt->length, 0,
(struct sockaddr *) client, S_AD_SZ);
- bzero(&a_name_data, sizeof(a_name_data));
- bzero(&s_name_data, sizeof(s_name_data));
+ memset(&a_name_data, 0, sizeof(a_name_data));
+ memset(&s_name_data, 0, sizeof(s_name_data));
break;
}
case AUTH_MSG_APPL_REQUEST:
/* construct and seal the ticket */
#ifdef NOENCRYPTION
- bzero(session_key, sizeof(C_Block));
+ memset(session_key, 0, sizeof(C_Block));
#else
/* random session key */
random_key(session_key);
session_key, lifetime, kerb_time.tv_sec,
s_name_data.name, s_name_data.instance,
key);
- bzero(key, sizeof(key));
- bzero(key_s, sizeof(key_s));
+ memset(key, 0, sizeof(key));
+ memset(key_s, 0, sizeof(key_s));
create_ciph(ciph, session_key, service, instance,
local_realm,
kerb_time.tv_sec, ad->session);
/* clear session key */
- bzero(session_key, sizeof(session_key));
+ memset(session_key, 0, sizeof(session_key));
- bzero(ad->session, sizeof(ad->session));
+ memset(ad->session, 0, sizeof(ad->session));
rpkt = create_auth_reply(ad->pname, ad->pinst,
ad->prealm, time_ws,
0, 0, 0, ciph);
krb4_sendto(f, (char *) rpkt->dat, rpkt->length, 0,
(struct sockaddr *) client, S_AD_SZ);
- bzero(&s_name_data, sizeof(s_name_data));
+ memset(&s_name_data, 0, sizeof(s_name_data));
break;
}
krb5_data *comp;
int ret;
- bzero((char *) v4creds, sizeof(CREDENTIALS));
+ memset((char *) v4creds, 0, sizeof(CREDENTIALS));
if (ret = krb524_convert_princs(v5creds->client, v5creds->server,
v4creds->pname, v4creds->pinst,
exit(1);
}
- bzero((char *) &v5creds, sizeof(v5creds));
+ memset((char *) &v5creds, 0, sizeof(v5creds));
v5creds.client = client;
v5creds.server = server;
v5creds.times.endtime = 0;
}
}
- bzero((char *) &v5creds, sizeof(v5creds));
+ memset((char *) &v5creds, 0, sizeof(v5creds));
v5creds.client = client;
v5creds.server = server;
v5creds.times.endtime = 0;
if (use_master)
init_master();
- bzero((char *) &saddr, sizeof(struct sockaddr_in));
+ memset((char *) &saddr, 0, sizeof(struct sockaddr_in));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = INADDR_ANY;
serv = getservbyname(KRB524_SERVICE, "udp");
exit(1);
}
- bzero((char *) &v5creds, sizeof(v5creds));
+ memset((char *) &v5creds, 0, sizeof(v5creds));
v5creds.client = client;
v5creds.server = server;
v5creds.times.endtime = 0;
fprintf(stderr, "test: host %s does not exist.\n", server);
exit(1);
}
- bzero((char *) &saddr, sizeof(struct sockaddr_in));
+ memset((char *) &saddr, 0, sizeof(struct sockaddr_in));
saddr.sin_family = AF_INET;
bcopy(hp->h_addr, (char *) &saddr.sin_addr.s_addr,
sizeof(struct in_addr));
mit_des_random_key_seed p_seed;
mit_des_cblock nullkey;
- bzero(nullkey, sizeof(mit_des_cblock));
+ memset(nullkey, 0, sizeof(mit_des_cblock));
mit_des_fixup_key_parity(key);
mit_des_init_random_number_generator(nullkey,&p_seed);
do {
if (ok == 0)
des_string_to_key(key_string, k);
- bzero(key_string, sizeof (key_string));
+ memset(key_string, 0, sizeof (key_string));
return ok;
}
length = strlen(str);
/* init key array for bits */
- bzero(k_char,sizeof(k_char));
+ memset(k_char, 0,sizeof(k_char));
#ifdef DEBUG
if (mit_des_debug)
(void) des_key_sched(key,key_sked);
(void) des_cbc_cksum((des_cblock *)in_str,key,length,key_sked,key);
/* erase key_sked */
- bzero((char *)key_sked,sizeof(key_sked));
+ memset((char *)key_sked, 0,sizeof(key_sked));
/* now fix up key parity again */
des_fixup_key_parity(key);
*error = ENOMEM;
return 0;
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
if (qb_pullup(val->address) != OK) {
krb5_xfree(retval);
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
temp = KRB5_EncryptedData2krb5_enc_data(val->enc__part, error);
if (temp) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->ap_options = KRB5_APOptions2krb5_apoptions(val->ap__options,
error);
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->ctime = gentime2unix(val->ctime, error);
if (*error) {
/* to keep lint happy */
#define xbcopy(src,dst,size) memcpy((char *)(dst), (char *)(src), size)
-#define xbzero(targ, size) memset((char *)(targ), 0, size)
#define xmalloc(n) malloc((unsigned) (n))
#define xcalloc(n,s) calloc((unsigned)(n), (unsigned)(s))
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->client = KRB5_PrincipalName2krb5_principal(val->cname,
val->crealm,
*error = ENOMEM;
return(0);
}
- xbzero((char *)retval, sizeof(*retval));
+ memset((char *)retval, 0, sizeof(*retval));
/* Count tickets */
for (i = 0, rv = val->tickets; rv; i++, rv = rv->next);
krb5_xfree(retval);
return(0);
}
- xbzero((char *)retval->tickets[i], sizeof(*retval->tickets[i]));
+ memset((char *)retval->tickets[i], 0, sizeof(*retval->tickets[i]));
retval->tickets[i] = KRB5_Ticket2krb5_ticket(rv->Ticket, error);
if (!retval->tickets[i]) {
*error = ENOMEM;
return(0);
}
- xbzero((char *)retval, sizeof(*retval));
+ memset((char *)retval, 0, sizeof(*retval));
/* Count ticket_info */
for (i = 0, rv = val->ticket__info; rv; i++, rv = rv->next);
*error = ENOMEM;
goto errout;
}
- xbzero((char *)retval->ticket_info[i],
+ memset((char *)retval->ticket_info[i], 0,
sizeof(*retval->ticket_info[i]));
retval->ticket_info[i]->session =
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
temp = qbuf2krb5_data(val->cipher, error);
if (temp) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->session = KRB5_EncryptionKey2krb5_keyblock(val->key, error);
if (!retval->session) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
if (val->ctime) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->flags = KRB5_TicketFlags2krb5_flags(val->flags, error);
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->nelem = i;
for (i = 0; i < retval->nelem; i++) {
retval->element_KRB5_2[i] = (struct element_KRB5_3 *)
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!retval)
retval = rv2;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->nelem = i;
for (i = 0; i < retval->nelem; i++) {
retval->element_KRB5_0[i] = (struct element_KRB5_1 *)
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!retval)
retval = rv2;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->addr__type = val->addrtype;
retval->address = str2qb((char *)val->contents, val->length, 1);
if (!retval->address) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->pvno = KRB5_PVNO;
retval->msg__type = KRB5_AP_REP;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->pvno = KRB5_PVNO;
retval->msg__type = KRB5_AP_REQ;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->ctime = unix2gentime(val->ctime, error);
if (!retval->ctime) {
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->authenticator__vno = KRB5_PVNO;
retval->crealm = krb5_data2qbuf(krb5_princ_realm(val->client));
if (!retval->crealm) {
*error = ENOMEM;
return(0);
}
- xbzero((char *)retval, sizeof(*retval));
+ memset((char *)retval, 0, sizeof(*retval));
retval->pvno = KRB5_PVNO;
retval->msg__type = KRB5_CRED;
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!retval->tickets)
retval->tickets = rv2;
*error = ENOMEM;
return(0);
}
- xbzero((char *)retval, sizeof (*retval));
+ memset((char *)retval, 0, sizeof (*retval));
if (val->nonce) {
retval->nonce = val->nonce;
if (!rv2)
goto errout;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (rv1)
rv1->next = rv2;
xmalloc(sizeof(*(rv2->KRB__CRED__INFO)));
if (!rv2->KRB__CRED__INFO)
goto errout;
- xbzero((char *)rv2->KRB__CRED__INFO, sizeof (*rv2->KRB__CRED__INFO));
+ memset((char *)rv2->KRB__CRED__INFO, 0, sizeof (*rv2->KRB__CRED__INFO));
rv2->KRB__CRED__INFO->key =
krb5_keyblock2KRB5_EncryptionKey(val->ticket_info[i]->session,
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->msg_type = val->msg__type;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->etype = val->etype;
retval->cipher = krb5_data2qbuf(&(val->ciphertext));
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->key = krb5_keyblock2KRB5_EncryptionKey(val->session, error);
if (!retval->key) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->pvno = KRB5_PVNO;
retval->msg__type = KRB5_ERROR;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->flags = krb5_flags2KRB5_TicketFlags(val->flags, error);
if (*error) {
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!retval)
retval = rv2;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->pvno = KRB5_PVNO;
retval->msg__type = val->msg_type;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->nelem = i;
for (i = 0; i < retval->nelem; i++) {
retval->element_KRB5_4[i] = (struct element_KRB5_5 *)
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!retval)
retval = rv2;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->user__data = krb5_data2qbuf(&(val->user_data));
if (!retval->user__data) {
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!namestring)
namestring = rv2;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->pvno = KRB5_PVNO;
retval->msg__type = KRB5_PRIV;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
rv2 = (struct type_KRB5_KRB__SAFE__BODY *)xmalloc(sizeof(*rv2));
if (!rv2) {
*error = ENOMEM;
return(0);
}
- xbzero(rv2, sizeof(*rv2));
+ memset(rv2, 0, sizeof(*rv2));
retval->pvno = KRB5_PVNO;
retval->msg__type = KRB5_SAFE;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->kdc__options =
krb5_kdcoptions2KRB5_KDCOptions(val->kdc_options,
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!retval->etype)
retval->etype = rv2;
rv2->element_KRB5_9 = val->etype[i];
*error = ENOMEM;
goto errout;
}
- xbzero(adtk, sizeof(*adtk));
+ memset(adtk, 0, sizeof(*adtk));
adtk->nelem = i;
for (i = 0; i < adtk->nelem; i++) {
adtk->Ticket[i] = krb5_ticket2KRB5_Ticket(val->second_ticket[i],
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!adtk)
adtk = rv2;
*error = ENOMEM;
goto errout;
}
- xbzero(adtk, sizeof(*adtk));
+ memset(adtk, 0, sizeof(*adtk));
adtk->nelem = 0;
retval->additional__tickets = adtk;
#endif
}
if (rv1)
rv1->next = rv2;
- xbzero((char *)rv2, sizeof (*rv2));
+ memset((char *)rv2, 0, sizeof (*rv2));
if (!retval)
retval = rv2;
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->pvno = KRB5_PVNO;
retval->msg__type = val->msg_type;
if (val->padata) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->tkt__vno = KRB5_PVNO;
retval->realm = krb5_data2qbuf(krb5_princ_realm(val->server));
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->tr__type = val->tr_type;
retval->contents = krb5_data2qbuf(&val->tr_contents);
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
temp = qbuf2krb5_data(val->user__data, error);
if (temp) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
temp = KRB5_EncryptedData2krb5_enc_data(val->enc__part, error);
if (temp) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
temp = qbuf2krb5_data(val->safe__body->user__data, error);
if (temp) {
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->kdc_options =
KRB5_KDCOptions2krb5_kdcoptions(val->kdc__options,
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->server = KRB5_PrincipalName2krb5_principal(val->sname,
*error = ENOMEM;
return(0);
}
- xbzero(retval, sizeof(*retval));
+ memset(retval, 0, sizeof(*retval));
retval->tr_type = val->tr__type;
temp = qbuf2krb5_data(val->contents, error);
(failed) syscall */
if (ret == EOF && !errno) ret = 0;
#endif
- bzero (data->stdio_buffer, sizeof (data->stdio_buffer));
+ memset (data->stdio_buffer, 0, sizeof (data->stdio_buffer));
if (ret == EOF) {
int errsave = errno;
(void) krb5_unlock_file(data->file, data->filename);