bcopy, bcmp, bzero, index, rindex, you're all cut.
memcpy, memcmp, memset, strchr, strrchr, show us how it's done
====================
This delta was composed from multiple commits as part of the CVS->Git migration.
The checkin message with each commit was inconsistent.
The following are the additional commit messages.
====================
fix reference to memset the right thing
====================
make change to arguments globally and not just for e.g. linux/darwin/fbsd
====================
fix a minor flub in how this was done
====================
correct another bad memcpy coversion
====================
fix up more inadvertant turds
====================
fix two errors found by chas williams
t_name = (char *)malloc(AFSNAMEMAX);
t_name[0] = '\0';
*a_name = t_name;
- bzero(a_hosts, AFSMAXCELLHOSTS * sizeof(afs_int32));
+ memset(a_hosts, 0, AFSMAXCELLHOSTS * sizeof(afs_int32));
return 0;
}
if (code) Die(code, (char *) 0);
else {
tp = space;
- bcopy(tp, &flag, sizeof(afs_int32));
+ memcpy(&flag, tp, sizeof(afs_int32));
printf("Security level is currently ");
if (flag == 1)
printf("crypt (data security).\n");
swab(((char *) x) +10,((char *) _krb_swap_tmp) +4 ,2); \
swab(((char *) x) +12,((char *) _krb_swap_tmp) +2 ,2); \
swab(((char *) x) +14,((char *) _krb_swap_tmp) +0 ,2); \
- bcopy((char *)_krb_swap_tmp,(char *)x,16);\
+ memcpy((char *)x, (char *)_krb_swap_tmp, 16);\
}
#define swap_u_12(x) {\
swab(((char *) x) +6, ((char *) _krb_swap_tmp) +4 ,2); \
swab(((char *) x) +8, ((char *) _krb_swap_tmp) +2 ,2); \
swab(((char *) x) +10,((char *) _krb_swap_tmp) +0 ,2); \
- bcopy((char *)_krb_swap_tmp,(char *)x,12);\
+ memcpy((char *)x, (char *)_krb_swap_tmp, 12);\
}
#define swap_C_Block(x) {\
swab(((char *) x) +2,((char *) _krb_swap_tmp) +4 ,2); \
swab(((char *) x) +4,((char *) _krb_swap_tmp) +2 ,2); \
swab(((char *) x) +6,((char *) _krb_swap_tmp) ,2); \
- bcopy((char *)_krb_swap_tmp,(char *)x,8);\
+ memcpy((char *)x, (char *)_krb_swap_tmp, 8);\
}
#define swap_u_quad(x) {\
unsigned long _krb_swap_tmp[4];\
swab(((char *) &x) +2,((char *) _krb_swap_tmp) +4 ,2); \
swab(((char *) &x) +4,((char *) _krb_swap_tmp) +2 ,2); \
swab(((char *) &x) +6,((char *) _krb_swap_tmp) ,2); \
- bcopy((char *)_krb_swap_tmp,(char *)&x,8);\
+ memcpy((char *)&x, (char *)_krb_swap_tmp, 8);\
}
#define swap_u_long(x) {\
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
break;
}
else {
- bzero(tos, sizeof(struct tos));
+ memset(tos, 0, sizeof(struct tos));
}
/* The trb and the tos were both allocated. */
AFS_STATCNT(afs_gn_fclear);
if (!fclear_init) {
- bzero(zero_buffer, PAGESIZE);
+ memset(zero_buffer, 0, PAGESIZE);
fclear_init = 1;
}
/*
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
afs_osi_cred.cr_ref++;
afs_osi_cred.cr_ngroups=1;
afs_osicred_initialized = 1;
printf("AFS_SYSCALL in use. aborting\n");
return KERN_FAILURE;
}
- bzero(&afs_vfsconf, sizeof(struct vfsconf));
+ memset(&afs_vfsconf, 0, sizeof(struct vfsconf));
strcpy(afs_vfsconf.vfc_name, "afs");
afs_vfsconf.vfc_vfsops=&afs_vfsops;
afs_vfsconf.vfc_typenum=VT_AFS;
mp->mnt_stat.f_iosize=8192;
(void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN-1, &size);
- bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
- bzero(mp->mnt_stat.f_mntfromname, MNAMELEN);
+ memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
+ memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
strcpy(mp->mnt_stat.f_mntfromname, "AFS");
/* null terminated string "AFS" will fit, just leave it be. */
strcpy(mp->mnt_stat.f_fstypename, "afs");
abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
if (abp != &mp->mnt_stat) {
abp->f_type = mp->mnt_vfc->vfc_typenum;
- bcopy((caddr_t)mp->mnt_stat.f_mntonname,
- (caddr_t)&abp->f_mntonname[0], MNAMELEN);
- bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
- (caddr_t)&abp->f_mntfromname[0], MNAMELEN);
+ memcpy((caddr_t)&abp->f_mntonname[0], (caddr_t)mp->mnt_stat.f_mntonname, MNAMELEN);
+ memcpy((caddr_t)&abp->f_mntfromname[0], (caddr_t)mp->mnt_stat.f_mntfromname, MNAMELEN);
}
AFS_GUNLOCK();
MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops*sizeof(PFI), M_TEMP, M_WAITOK);
- bzero (afs_vnodeop_p, vfs_opv_numops*sizeof(PFI));
+ memset(afs_vnodeop_p, 0, vfs_opv_numops*sizeof(PFI));
opv_desc_vector = afs_vnodeop_p;
for (j=0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
struct componentname *cnp = ap->a_cnp; \
char *name; \
MALLOC(name, char *, cnp->cn_namelen+1, M_TEMP, M_WAITOK); \
- bcopy(cnp->cn_nameptr, name, cnp->cn_namelen); \
+ memcpy(name, cnp->cn_nameptr, cnp->cn_namelen); \
name[cnp->cn_namelen] = '\0'
#define DROPNAME() FREE(name, M_TEMP)
if ((f_offset < tvc->m.Length) && (f_offset + size) > tvc->m.Length) {
size_t io = tvc->m.Length - f_offset;
- bzero((caddr_t)(ioaddr + pl_offset + io), size - io);
+ memset((caddr_t)(ioaddr + pl_offset + io), 0, size - io);
}
}
#endif /* ] USV */
goto abortit;
MALLOC(fname, char *, fcnp->cn_namelen+1, M_TEMP, M_WAITOK);
- bcopy(fcnp->cn_nameptr, fname, fcnp->cn_namelen);
+ memcpy(fname, fcnp->cn_nameptr, fcnp->cn_namelen);
fname[fcnp->cn_namelen] = '\0';
MALLOC(tname, char *, tcnp->cn_namelen+1, M_TEMP, M_WAITOK);
- bcopy(tcnp->cn_nameptr, tname, tcnp->cn_namelen);
+ memcpy(tname, tcnp->cn_nameptr, tcnp->cn_namelen);
tname[tcnp->cn_namelen] = '\0';
struct utask_nd utnd = { NULL, NULL };
struct vattr attr;
- bzero(&nd, sizeof(nd));
+ memset(&nd, 0, sizeof(nd));
ndp->ni_utnd = &utnd;
ndp->ni_nameiop = LOOKUP;
ndp->ni_cred = &afs_osi_cred;
if ( !afsp->m_stat.f_mntonname || !afsp->m_stat.f_mntfromname)
panic("malloc failure in afs_mount\n");
- bzero(afsp->m_stat.f_mntonname, MNAMELEN);
- bzero(afsp->m_stat.f_mntfromname, MNAMELEN);
+ memset(afsp->m_stat.f_mntonname, 0, MNAMELEN);
+ memset(afsp->m_stat.f_mntfromname, 0, MNAMELEN);
AFS_COPYINSTR(path, (caddr_t)afsp->m_stat.f_mntonname, MNAMELEN, &size, code);
- bcopy("AFS", afsp->m_stat.f_mntfromname, 4);
+ memcpy(afsp->m_stat.f_mntfromname, "AFS", 4);
AFS_GUNLOCK();
(void) mp_afs_statfs(afsp);
AFS_GLOCK();
fidp->fid_len = AFS_SIZEOFSMALLFID;
if (afs_NFSRootOnly) {
if (rootvp) {
- bcopy((caddr_t)&Sfid, fidp->fid_data, AFS_FIDDATASIZE);
+ memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
} else {
- bcopy((caddr_t)addr, fidp->fid_data, AFS_FIDDATASIZE);
+ memcpy(fidp->fid_data, (caddr_t)addr, AFS_FIDDATASIZE);
}
} else {
- bcopy((caddr_t)&Sfid, fidp->fid_data, AFS_FIDDATASIZE);
+ memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
}
AFS_GUNLOCK();
return 0;
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
afs_osi_cred.cr_ref++;
afs_osicred_initialized = 1;
}
if ( !afsp->m_stat.f_mntonname || !afsp->m_stat.f_mntfromname)
panic("malloc failure in afs_mount\n");
- bzero(afsp->m_stat.f_mntonname, MNAMELEN);
- bzero(afsp->m_stat.f_mntfromname, MNAMELEN);
+ memset(afsp->m_stat.f_mntonname, 0, MNAMELEN);
+ memset(afsp->m_stat.f_mntfromname, 0, MNAMELEN);
AFS_COPYINSTR(path, (caddr_t)afsp->m_stat.f_mntonname, MNAMELEN, &size, code);
- bcopy("AFS", afsp->m_stat.f_mntfromname, 4);
+ memcpy(afsp->m_stat.f_mntfromname, "AFS", 4);
AFS_GUNLOCK();
(void) mp_afs_statfs(afsp);
AFS_GLOCK();
fidp->fid_len = AFS_SIZEOFSMALLFID;
if (afs_NFSRootOnly) {
if (rootvp) {
- bcopy((caddr_t)&Sfid, fidp->fid_data, AFS_FIDDATASIZE);
+ memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
} else {
- bcopy((caddr_t)addr, fidp->fid_data, AFS_FIDDATASIZE);
+ memcpy(fidp->fid_data, (caddr_t)addr, AFS_FIDDATASIZE);
}
} else {
- bcopy((caddr_t)&Sfid, fidp->fid_data, AFS_FIDDATASIZE);
+ memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
}
AFS_GUNLOCK();
return 0;
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
return (len);
ml = MIN(len, m->m_len - off);
- bcopy(mtod(m, caddr_t)+off, cp, (u_int)ml);
+ memcpy(cp, mtod(m, caddr_t)+off, (u_int)ml);
cp += ml;
len -= ml;
m = m->m_next;
while (len && m) {
ml = m->m_len;
- bcopy(mtod(m, caddr_t), cp, (u_int)ml);
+ memcpy(cp, mtod(m, caddr_t), (u_int)ml);
cp += ml;
len -= ml;
m = m->m_next;
filevp = VM_GET_PAGEOUT_VNODE(&vm_info); /* always page out to back store */
VASSERT(filevp != NULL);
- bzero((caddr_t)&args, sizeof(fsdata_t));
+ memset((caddr_t)&args, 0, sizeof(fsdata_t));
args.remote_down = 0; /* assume remote file servers are up */
args.remote = 1; /* we are remote */
args.bsize = 0; /* filled up later by afs_vm_checkpage() */
if ((caddr_t) odp + odp->d_reclen > obufend)
break;
/* record offset *after* we're sure to use this entry */
- bcopy((char *)&idp->__d_off, (char *)&tmp_offset, sizeof tmp_offset);
+ memcpy((char *)&tmp_offset, (char *)&idp->__d_off, sizeof tmp_offset);
offset = tmp_offset;
}
(caddr_t)idp < ibufend;
idp = (struct __dirent32 *) ((caddr_t) idp + idp->__d_reclen),
odp = (struct __dirent64 *) ((caddr_t) odp + odp->__d_reclen)) {
- bcopy((char *)&idp->__d_off, (char *)&odp->__d_off, sizeof odp->__d_off);
+ memcpy((char *)&odp->__d_off, (char *)&idp->__d_off, sizeof odp->__d_off);
odp->__d_ino = idp->__d_ino;
odp->__d_namlen = idp->__d_namlen;
(void) strcpy(odp->__d_name, idp->__d_name);
osi_Panic("afs: cannot create SEMA Hashtable\n");
/* initialize the hash table and associated locks */
- bzero((char *)hashTable, sizeOfHashTable * sizeof(Bucket ));
+ memset((char *)hashTable, 0, sizeOfHashTable * sizeof(Bucket ));
for ( i=0;i < sizeOfHashTable; i ++)
hashLockInit( hashTable[i].lock);
hashLockInit(afsHashLock);
osi_Panic("afs: SEMA Hashtable cannot create new entry\n");
/* create new entry */
ptr->key = key;
- bzero((char *)&ptr->element, sizeof(ptr->element));
+ memset((char *)&ptr->element, 0, sizeof(ptr->element));
ptr->refCnt = 1; /* this guy */
/* insert new entry in bucket */
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
return EINVAL; /* sorry */
cr = crdup(OSI_GET_CURRENT_CRED()); /* we will replace all the groups. */
- bzero((char*)&cr->cr_groups, ngroups_max * sizeof(gid_t));
+ memset((char*)&cr->cr_groups, 0, ngroups_max * sizeof(gid_t));
/* Now cobble the new groups list together. */
new = 0;
}
else
createdDir = 1;
- bzero((char*)&dattr, sizeof(dattr));
+ memset((char*)&dattr, 0, sizeof(dattr));
dattr.atd_version = AFS_XFS_ATD_VERS;
dattr.atd_volume = rw_vno;
AFS_VOP_ATTR_SET(dvp, AFS_XFS_DATTR, (char*)&dattr,
return code;
}
- bzero((char*)&attrs, sizeof(attrs));
+ memset((char*)&attrs, 0, sizeof(attrs));
attrs.at_pino = vattr.va_nodeid;
VN_RELE(dvp);
if (!code) {
/* Set attributes. */
- bcopy((char*)params, (char*)attrs.at_param,
- sizeof(afs_inode_params_t));
+ memcpy((char*)attrs.at_param, (char*)params, sizeof(afs_inode_params_t));
attrs.at_attr_version = AFS_XFS_ATTR_VERS;
attrs.at_name_version = name_version;
AFS_VOP_ATTR_SET(vp, AFS_XFS_ATTR, (char*)&attrs,
}
if (!code) {
- bzero((char*)&data, sizeof(data));
+ memset((char*)&data, 0, sizeof(data));
data.ili_info.inodeNumber = inode;
data.ili_info.byteCount = vattr.va_size;
data.ili_info.linkCount = (vattr.va_mode & AFS_XFS_MODE_LINK_MASK);
- bcopy((char*)attrs.at_param, (char*)data.ili_info.param,
- sizeof(data.ili_info.param));
+ memcpy((char*)data.ili_info.param, (char*)attrs.at_param, sizeof(data.ili_info.param));
data.ili_attr_version = attrs.at_attr_version;
data.ili_name_version = attrs.at_name_version;
data.ili_tag = attrs.at_tag;
/* we are responsible for zero'ing the page */
caddr_t c;
c = bp_mapin(bp);
- bzero(c, bp->b_bcount);
+ memset(c, 0, bp->b_bcount);
iodone(bp);
ReleaseReadLock(&avc->lock);
return;
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
((vc)->v_op == &afs_dir_iops) ? 1 : \
((vc)->v_op == &afs_symlink_iops))
-/* bcopy is in stds.h, just so fcrpyt.c can pick it up. */
+#if 0
+/* bcopy is in stds.h, just so fcrypt.c can pick it up. */
#define bzero(D,C) memset((D), 0, (C))
#define bcmp(A,B,C) memcmp((A), (B), (C))
+#endif
/* We often need to pretend we're in user space to get memory transfers
* right for the kernel calls we use.
}
if (!afs_osicred_initialized) {
/* valid for alpha_osf, SunOS, Ultrix */
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
crhold(&afs_osi_cred); /* don't let it evaporate, since it is static */
afs_osicred_initialized = 1;
}
/* build address list */
for(i=0;i<MAXHOSTSPERCELL;i++)
- bcopy(&aci->hostAddr[i].sin_addr, &hosts[i], sizeof(afs_int32));
+ memcpy(&hosts[i], &aci->hostAddr[i].sin_addr, sizeof(afs_int32));
if (aci->linkedCell) cellFlags |= 4; /* Flag that linkedCell arg exists,
for upwards compatibility */
rn, cacheFiles);
exit(1);
}
- bzero(pathname_for_V, (cacheFiles * sizeof(char *)));
+ memset(pathname_for_V, 0, (cacheFiles * sizeof(char *)));
if (afsd_debug)
printf("%s: %d pathname_for_V entries at 0x%x, %d bytes\n",
rn, cacheFiles, (cacheFiles * sizeof(AFSD_INO_T)));
" flags = 0x%x, dcache entries %d\n",
rn, cacheStatEntries, cacheFiles, cacheBlocks, cacheFlags,
dCacheSize);
- bzero(&cparams, sizeof(cparams));
+ memset(&cparams, 0, sizeof(cparams));
cparams.cacheScaches = cacheStatEntries;
cparams.cacheFiles = cacheFiles;
cparams.cacheBlocks = cacheBlocks;
|| USE_SMALLFID(credp)
#endif
) {
- bcopy((caddr_t)&Sfid, fidpp->fid_data, SizeOfSmallFid);
+ memcpy(fidpp->fid_data, (caddr_t)&Sfid, SizeOfSmallFid);
} else {
- bcopy((caddr_t)addr, fidpp->fid_data, SizeOfSmallFid);
+ memcpy(fidpp->fid_data, (caddr_t)addr, SizeOfSmallFid);
}
} else {
- bcopy((caddr_t)&Sfid, fidpp->fid_data, SizeOfSmallFid);
+ memcpy(fidpp->fid_data, (caddr_t)&Sfid, SizeOfSmallFid);
}
#else
/* malloc a fid pointer ourselves. */
(*fidpp)->fid_len = SizeOfSmallFid;
if (afs_NFSRootOnly) {
if (rootvp) {
- bcopy((char *)&Sfid, (*fidpp)->fid_data, SizeOfSmallFid);
+ memcpy((*fidpp)->fid_data, (char *)&Sfid, SizeOfSmallFid);
} else {
- bcopy((char *)addr, (*fidpp)->fid_data, SizeOfSmallFid);
+ memcpy((*fidpp)->fid_data, (char *)addr, SizeOfSmallFid);
}
} else {
- bcopy((char *)&Sfid, (*fidpp)->fid_data, SizeOfSmallFid);
+ memcpy((*fidpp)->fid_data, (char *)&Sfid, SizeOfSmallFid);
}
#endif
return (0);
* preserve the value of the file size. We could
* flush the pages, but it wouldn't be worthwhile.
*/
- bcopy((char *) &tfid.Fid, (char *)(fidsp+fidIndex),
- sizeof(*fidsp));
+ memcpy((char *)(fidsp+fidIndex), (char *) &tfid.Fid, sizeof(*fidsp));
tvcp->states |= CBulkFetching;
tvcp->m.Length = statSeqNo;
fidIndex++;
AFS_STATCNT(afs_lookup);
#ifdef AFS_OSF_ENV
ndp->ni_dvp = (struct vnode *)adp;
- bcopy(ndp->ni_ptr, aname, ndp->ni_namelen);
+ memcpy(aname, ndp->ni_ptr, ndp->ni_namelen);
aname[ndp->ni_namelen] = '\0';
#endif /* AFS_OSF_ENV */
if (code == 0) {
if (tuio.afsio_resid > 0)
#if defined(AFS_FBSD_ENV)
- bzero(abp->b_saveaddr + abp->b_bcount - tuio.afsio_resid, tuio.afsio_resid);
+ memset(abp->b_saveaddr + abp->b_bcount - tuio.afsio_resid, 0, tuio.afsio_resid);
#else
- bzero(abp->b_un.b_addr + abp->b_bcount - tuio.afsio_resid, tuio.afsio_resid);
+ memset(abp->b_un.b_addr + abp->b_bcount - tuio.afsio_resid, 0, tuio.afsio_resid);
#endif /* AFS_FBSD_ENV */
#ifdef AFS_AIX32_ENV
/*
nbuffers = 0;
timecounter = 1;
for(i=0;i<PHSIZE;i++) phTable[i] = 0;
- bzero((char *)&afs_bufferLock, sizeof(afs_lock_t));
+ memset((char *)&afs_bufferLock, 0, sizeof(afs_lock_t));
}
}
afs_InitStats();
#endif /* AFS_NOSTATS */
- bzero(afs_zeros, AFS_ZEROS);
+ memset(afs_zeros, 0, AFS_ZEROS);
/* start RX */
rx_extraPackets = AFS_NRXPACKETS; /* smaller # of packets */
shutdown_afstest();
/* The following hold the cm stats */
/*
- bzero(&afs_cmstats, sizeof(struct afs_CMStats));
- bzero(&afs_stats_cmperf, sizeof(struct afs_stats_CMPerf));
- bzero(&afs_stats_cmfullperf, sizeof(struct afs_stats_CMFullPerf));
+ memset(&afs_cmstats, 0, sizeof(struct afs_CMStats));
+ memset(&afs_stats_cmperf, 0, sizeof(struct afs_stats_CMPerf));
+ memset(&afs_stats_cmfullperf, 0, sizeof(struct afs_stats_CMFullPerf));
*/
afs_warn(" ALL allocated tables\n");
afs_shuttingdown = 0;
logp = (struct afs_icl_log *)
osi_AllocSmallSpace(sizeof(struct afs_icl_log));
- bzero((caddr_t)logp, sizeof(*logp));
+ memset((caddr_t)logp, 0, sizeof(*logp));
logp->refCount = 1;
logp->name = osi_AllocSmallSpace(strlen(name)+1);
if (end - ix < nwords)
nwords = end - ix;
if (nwords > 0) {
- bcopy((char *) &logp->datap[ix], (char *) bufferp,
- sizeof(afs_int32) * nwords);
+ memcpy((char *) bufferp, (char *) &logp->datap[ix], sizeof(afs_int32) * nwords);
outWords += nwords;
inWords -= nwords;
bufferp += nwords;
nwords = inWords;
if (logp->firstFree - ix < nwords)
nwords = logp->firstFree - ix;
- bcopy((char *) &logp->datap[ix], (char *) bufferp,
- sizeof(afs_int32) * nwords);
+ memcpy((char *) bufferp, (char *) &logp->datap[ix], sizeof(afs_int32) * nwords);
outWords += nwords;
inWords -= nwords;
bufferp += nwords;
states |= ICL_SETF_PERSISTENT;
setp = (struct afs_icl_set *) afs_osi_Alloc(sizeof(struct afs_icl_set));
- bzero((caddr_t)setp, sizeof(*setp));
+ memset((caddr_t)setp, 0, sizeof(*setp));
setp->refCount = 1;
if (states & ICL_SETF_FREED)
states &= ~ICL_SETF_ACTIVE; /* if freed, can't be active */
*/
dataBytes = sizeof(struct afs_CMStats);
dataBuffP = (afs_int32 *)afs_osi_Alloc(dataBytes);
- bcopy((char *)&afs_cmstats, (char *)dataBuffP, dataBytes);
+ memcpy((char *)dataBuffP, (char *)&afs_cmstats, dataBytes);
a_dataP->AFSCB_CollData_len = dataBytes>>2;
a_dataP->AFSCB_CollData_val = dataBuffP;
break;
afs_CountServers();
dataBytes = sizeof(afs_stats_cmperf);
dataBuffP = (afs_int32 *)afs_osi_Alloc(dataBytes);
- bcopy((char *)&afs_stats_cmperf, (char *)dataBuffP, dataBytes);
+ memcpy((char *)dataBuffP, (char *)&afs_stats_cmperf, dataBytes);
a_dataP->AFSCB_CollData_len = dataBytes>>2;
a_dataP->AFSCB_CollData_val = dataBuffP;
break;
*/
afs_stats_cmperf.numPerfCalls++;
afs_CountServers();
- bcopy((char *)(&afs_stats_cmperf),
- (char *)(&(afs_stats_cmfullperf.perf)),
- sizeof(struct afs_stats_CMPerf));
+ memcpy((char *)(&(afs_stats_cmfullperf.perf)), (char *)(&afs_stats_cmperf), sizeof(struct afs_stats_CMPerf));
afs_stats_cmfullperf.numFullPerfCalls++;
dataBytes = sizeof(afs_stats_cmfullperf);
dataBuffP = (afs_int32 *)afs_osi_Alloc(dataBytes);
- bcopy((char *)(&afs_stats_cmfullperf), (char *)dataBuffP, dataBytes);
+ memcpy((char *)dataBuffP, (char *)(&afs_stats_cmfullperf), dataBytes);
a_dataP->AFSCB_CollData_len = dataBytes>>2;
a_dataP->AFSCB_CollData_val = dataBuffP;
break;
}
t_name[0] = '\0';
- bzero(a_hosts, AFSMAXCELLHOSTS * sizeof(afs_int32));
+ memset(a_hosts, 0, AFSMAXCELLHOSTS * sizeof(afs_int32));
/* search the list for the cell with this index */
ObtainReadLock(&afs_xcell);
{
register int i;
-bzero((char *)cbHashT, CBHTSIZE*sizeof(struct bucket));
+memset((char *)cbHashT, 0, CBHTSIZE*sizeof(struct bucket));
for (i=0;i<CBHTSIZE;i++) {
QInit(&(cbHashT[i].head));
/* Lock_Init(&(cbHashT[i].lock)); only if you want lots of locks, which
tc->states |= aflags;
tc->timeout = timeout;
- bzero((char *)tc->cellHosts, sizeof(tc->cellHosts));
+ memset((char *)tc->cellHosts, 0, sizeof(tc->cellHosts));
for (i=0; i<MAXCELLHOSTS; i++) {
struct server *ts;
afs_uint32 temp = acellHosts[i];
*/
UpgradeSToWLock(&afs_xconn,37);
tc = (struct conn *) afs_osi_Alloc(sizeof(struct conn));
- bzero((char *)tc, sizeof(struct conn));
+ memset((char *)tc, 0, sizeof(struct conn));
tc->user = tu;
tc->port = aport;
/* Initialize a token (self) to use in the queue of sleeping processes. */
self = (struct afs_bioqueue *) afs_osi_Alloc (sizeof (struct afs_bioqueue));
pin (self, sizeof (struct afs_bioqueue)); /* fix in memory */
- bzero(self, sizeof(*self));
+ memset(self, 0, sizeof(*self));
QInit (&(self->lruq)); /* initialize queue entry pointers */
/* initialize subsystem */
if (brsInit == 0) {
LOCK_INIT(&afs_xbrs, "afs_xbrs");
- bzero((char *)afs_brs, sizeof(afs_brs));
+ memset((char *)afs_brs, 0, sizeof(afs_brs));
brsInit = 1;
#if defined (AFS_SGI_ENV) && defined(AFS_SGI_SHORTSTACK)
/*
if (afs_cold_shutdown) {
afs_brsDaemons = brsInit = 0;
rxepoch_checked = afs_nbrs = 0;
- bzero((char *)afs_brs, sizeof(afs_brs));
- bzero((char *)&afs_xbrs, sizeof(afs_lock_t));
+ memset((char *)afs_brs, 0, sizeof(afs_brs));
+ memset((char *)&afs_xbrs, 0, sizeof(afs_lock_t));
afs_brsWaiters = 0;
#ifdef AFS_AIX32_ENV
#ifdef AFS_AIX41_ENV
#else /* AFS_AIX41_ENV */
afs_busyq = NULL;
afs_biodcnt = 0;
- bzero((char *)&afs_bioqueue, sizeof(struct afs_bioqueue));
+ memset((char *)&afs_bioqueue, 0, sizeof(struct afs_bioqueue));
#endif
afs_initbiod = 0;
#endif
/* Allocate and zero the pointer array to the dcache entries */
afs_indexTable = (struct dcache **)
afs_osi_Alloc(sizeof(struct dcache *) * afiles);
- bzero((char *)afs_indexTable, sizeof(struct dcache *) * afiles);
+ memset((char *)afs_indexTable, 0, sizeof(struct dcache *) * afiles);
afs_indexTimes = (afs_hyper_t *) afs_osi_Alloc(afiles * sizeof(afs_hyper_t));
- bzero((char *)afs_indexTimes, afiles * sizeof(afs_hyper_t));
+ memset((char *)afs_indexTimes, 0, afiles * sizeof(afs_hyper_t));
afs_indexUnique = (afs_int32 *) afs_osi_Alloc(afiles * sizeof(afs_uint32));
- bzero((char *)afs_indexUnique, afiles * sizeof(afs_uint32));
+ memset((char *)afs_indexUnique, 0, afiles * sizeof(afs_uint32));
afs_indexFlags = (u_char *) afs_osi_Alloc(afiles * sizeof(u_char));
- bzero((char *)afs_indexFlags, afiles * sizeof(char));
+ memset((char *)afs_indexFlags, 0, afiles * sizeof(char));
/* Allocate and thread the struct dcache entries themselves */
tdp = afs_Initial_freeDSList =
(struct dcache *) afs_osi_Alloc(aDentries * sizeof(struct dcache));
- bzero((char *)tdp, aDentries * sizeof(struct dcache));
+ memset((char *)tdp, 0, aDentries * sizeof(struct dcache));
#ifdef AFS_AIX32_ENV
pin((char *)afs_indexTable, sizeof(struct dcache *) * afiles);/* XXX */
pin((char *)afs_indexTimes, sizeof(afs_hyper_t) * afiles); /* XXX */
}
length = (size ? size : sizeof(struct afs_exporter));
ex = (struct afs_exporter *) afs_osi_Alloc(length);
- bzero((char *)ex, length);
+ memset((char *)ex, 0, length);
MObtainWriteLock(&afs_xexp,308);
for (op = root_exported; op; op = op->exp_next) {
if (!op->exp_next)
cacheInfoModTime = 0;
afs_fsfragsize = 1023;
- bzero((char *)&afs_stats_cmperf, sizeof(afs_stats_cmperf));
- bzero((char *)&cacheDev, sizeof(struct osi_dev));
+ memset((char *)&afs_stats_cmperf, 0, sizeof(afs_stats_cmperf));
+ memset((char *)&cacheDev, 0, sizeof(struct osi_dev));
osi_dnlc_shutdown();
}
} /*shutdown_cache*/
afs_FVIndex = -1;
afs_server = (struct rx_service *)0;
RWLOCK_INIT(&afs_xconn, "afs_xconn");
- bzero((char *)&afs_rootFid, sizeof(struct VenusFid));
+ memset((char *)&afs_rootFid, 0, sizeof(struct VenusFid));
RWLOCK_INIT(&afs_xuser, "afs_xuser");
RWLOCK_INIT(&afs_xvolume, "afs_xvolume"), RWLOCK_INIT(&afs_xcell, "afs_xcell");
RWLOCK_INIT(&afs_xserver, "afs_xserver"), LOCK_INIT(&afs_puttofileLock, "afs_puttofileLock");
if (blk == NULL)
goto nomem;
(memCache+index)->data = blk;
- bzero((memCache+index)->data, memCacheBlkSize);
+ memset((memCache+index)->data, 0, memCacheBlkSize);
}
#if defined(AFS_SGI62_ENV) || defined(AFS_HAVE_VXFS)
afs_InitDualFSCacheOps((struct vnode*)0);
if(bytesRead > 0) {
AFS_GUNLOCK();
- bcopy(mceP->data + offset, dest, bytesRead);
+ memcpy(dest, mceP->data + offset, bytesRead);
AFS_GLOCK();
}
else
for (i = 0 , size = bytesRead ; i < nio && size > 0 ; i++) {
bytesToRead = (size < iov[i].iov_len) ? size : iov[i].iov_len;
AFS_GUNLOCK();
- bcopy(mceP->data + offset, iov[i].iov_base, bytesToRead);
+ memcpy(iov[i].iov_base, mceP->data + offset, bytesToRead);
AFS_GLOCK();
offset += bytesToRead;
size -= bytesToRead;
/* may overlap, but this is OK */
AFS_GUNLOCK();
- bcopy(oldData, mceP->data, mceP->size);
+ memcpy(mceP->data, oldData, mceP->size);
AFS_GLOCK();
afs_osi_Free(oldData,mceP->dataSize);
mceP->dataSize = size+offset;
}
AFS_GUNLOCK();
if (mceP->size < offset)
- bzero(mceP->data+mceP->size, offset-mceP->size);
- bcopy(src, mceP->data + offset, size);
+ memset(mceP->data+mceP->size, 0, offset-mceP->size);
+ memcpy(mceP->data + offset, src, size);
AFS_GLOCK();
mceP->size = (size+offset < mceP->size) ? mceP->size :
size + offset;
/* may overlap, but this is OK */
AFS_GUNLOCK();
- bcopy(oldData, mceP->data, mceP->size);
+ memcpy(mceP->data, oldData, mceP->size);
AFS_GLOCK();
afs_osi_Free(oldData,mceP->dataSize);
mceP->dataSize = size+offset;
}
if (mceP->size < offset)
- bzero(mceP->data+mceP->size, offset-mceP->size);
+ memset(mceP->data+mceP->size, 0, offset-mceP->size);
for (bytesWritten = 0, i = 0 ; i < nio && size > 0 ; i++) {
bytesToWrite = (size < iov[i].iov_len) ? size : iov[i].iov_len;
AFS_GUNLOCK();
- bcopy(iov[i].iov_base, mceP->data + offset, bytesToWrite);
+ memcpy(mceP->data + offset, iov[i].iov_base, bytesToWrite);
AFS_GLOCK();
offset += bytesToWrite;
bytesWritten += bytesToWrite;
mceP->data = afs_osi_Alloc(uioP->uio_resid + uioP->uio_offset);
AFS_GUNLOCK();
- bcopy(oldData, mceP->data, mceP->size);
+ memcpy(mceP->data, oldData, mceP->size);
AFS_GLOCK();
afs_osi_Free(oldData,mceP->dataSize);
mceP->dataSize = uioP->uio_resid + uioP->uio_offset;
}
if (mceP->size < uioP->uio_offset)
- bzero(mceP->data+mceP->size, (int)(uioP->uio_offset-mceP->size));
+ memset(mceP->data+mceP->size, 0, (int)(uioP->uio_offset-mceP->size));
AFS_UIOMOVE(mceP->data+uioP->uio_offset, uioP->uio_resid, UIO_WRITE, uioP, code);
if (uioP->uio_offset > mceP->size)
mceP->size = uioP->uio_offset;
}
}
np = (struct nfsclientpag *) afs_osi_Alloc(sizeof (struct nfsclientpag));
- bzero((char *)np, sizeof(struct nfsclientpag));
+ memset((char *)np, 0, sizeof(struct nfsclientpag));
/* Copy the necessary afs_exporter fields */
- bcopy((char *)afs_nfsexporter, (char *)np, sizeof(struct afs_exporter));
+ memcpy((char *)np, (char *)afs_nfsexporter, sizeof(struct afs_exporter));
np->next = afs_nfspags[i];
afs_nfspags[i] = np;
np->uid = uid;
if ( !afs_osicred_initialized )
{
- bzero((char *)&afs_osi_cred, sizeof(struct AFS_UCRED));
+ memset((char *)&afs_osi_cred, 0, sizeof(struct AFS_UCRED));
crhold(&afs_osi_cred); /* don't let it evaporate */
afs_osicred_initialized = 1;
}
cr.cr_ref=1;
cr.cr_uid=pr->p_cred->pc_ucred->cr_uid;
cr.cr_ngroups=pr->p_cred->pc_ucred->cr_ngroups;
- bcopy(pr->p_cred->pc_ucred->cr_groups, cr.cr_groups,NGROUPS *
+ memcpy(cr.cr_groups, pr->p_cred->pc_ucred->cr_groups, NGROUPS *
sizeof(gid_t));
pcred_unlock(pr);
rv = &cr;
AFS_STATCNT(afsio_copy);
if (ainuio->afsio_iovcnt > AFS_MAXIOVCNT) return EINVAL;
- bcopy((char *)ainuio, (char *)aoutuio, sizeof(struct uio));
+ memcpy((char *)aoutuio, (char *)ainuio, sizeof(struct uio));
tvec = ainuio->afsio_iov;
aoutuio->afsio_iov = aoutvec;
for(i=0;i<ainuio->afsio_iovcnt;i++){
- bcopy((char *)tvec, (char *)aoutvec, sizeof(struct iovec));
+ memcpy((char *)aoutvec, (char *)tvec, sizeof(struct iovec));
tvec++; /* too many compiler bugs to do this as one expr */
aoutvec++;
}
register afs_int32 code = 0, cellindex;
afs_int32 ret;
- bcopy(afidp->fid_data, (char *)&Sfid, SIZEOF_SMALLFID);
+ memcpy((char *)&Sfid, afidp->fid_data, SIZEOF_SMALLFID);
#ifdef AFS_OSF_ENV
Sfid.Vnode = afidp->fid_reserved;
#endif
tnc->dirp = adp;
tnc->vp = avc;
tnc->key = key;
- bcopy (aname, (char *)tnc->name, ts-aname+1); /* include the NULL */
+ memcpy((char *)tnc->name, aname, ts-aname+1); /* include the NULL */
InsertEntry(tnc);
} else {
}
else { /* did get the lock */
ncfreelist = (struct nc *) 0;
- bzero ((char *)nameCache, sizeof(struct nc) * NCSIZE);
- bzero ((char *)nameHash, sizeof(struct nc *) * NHSIZE);
+ memset((char *)nameCache, 0, sizeof(struct nc) * NCSIZE);
+ memset((char *)nameHash, 0, sizeof(struct nc *) * NHSIZE);
for (i=0; i<NCSIZE; i++) {
nameCache[i].next = ncfreelist;
ncfreelist = &nameCache[i];
int i;
Lock_Init(&afs_xdnlc);
- bzero ((char *)&dnlcstats, sizeof(dnlcstats));
- bzero ((char *)dnlctracetable, sizeof(dnlctracetable));
+ memset((char *)&dnlcstats, 0, sizeof(dnlcstats));
+ memset((char *)dnlctracetable, 0, sizeof(dnlctracetable));
dnlct=0;
ObtainWriteLock(&afs_xdnlc,223);
ncfreelist = (struct nc *) 0;
- bzero ((char *)nameCache, sizeof(struct nc) * NCSIZE);
- bzero ((char *)nameHash, sizeof(struct nc *) * NHSIZE);
+ memset((char *)nameCache, 0, sizeof(struct nc) * NCSIZE);
+ memset((char *)nameHash, 0, sizeof(struct nc *) * NHSIZE);
for (i=0; i<NCSIZE; i++) {
nameCache[i].next = ncfreelist;
ncfreelist = &nameCache[i];
AFS_STATCNT(PGetFID);
if (!avc) return EINVAL;
- bcopy((char *)&avc->fid, aout, sizeof(struct VenusFid));
+ memcpy(aout, (char *)&avc->fid, sizeof(struct VenusFid));
*aoutSize = sizeof(struct VenusFid);
return 0;
}
if (!afs_resourceinit_flag) {
return EIO;
}
- bcopy(ain, (char *)&i, sizeof(afs_int32));
+ memcpy((char *)&i, ain, sizeof(afs_int32));
ain += sizeof(afs_int32);
stp = ain; /* remember where the ticket is */
if (i < 0 || i > 2000) return EINVAL; /* malloc may fail */
stLen = i;
ain += i; /* skip over ticket */
- bcopy(ain, (char *)&i, sizeof(afs_int32));
+ memcpy((char *)&i, ain, sizeof(afs_int32));
ain += sizeof(afs_int32);
if (i != sizeof(struct ClearToken)) {
return EINVAL;
}
- bcopy(ain, (char *)&clear, sizeof(struct ClearToken));
+ memcpy((char *)&clear, ain, sizeof(struct ClearToken));
if (clear.AuthHandle == -1) clear.AuthHandle = 999; /* more rxvab compat stuff */
ain += sizeof(struct ClearToken);
if (ainSize != 2*sizeof(afs_int32) + stLen + sizeof(struct ClearToken)) {
/* still stuff left? we've got primary flag and cell name. Set these */
- bcopy(ain, (char *)&flag, sizeof(afs_int32)); /* primary id flag */
+ memcpy((char *)&flag, ain, sizeof(afs_int32)); /* primary id flag */
ain += sizeof(afs_int32); /* skip id field */
/* rest is cell name, look it up */
if (flag & 0x8000) { /* XXX Use Constant XXX */
}
tu->stp = (char *) afs_osi_Alloc(stLen);
tu->stLen = stLen;
- bcopy(stp, tu->stp, stLen);
+ memcpy(tu->stp, stp, stLen);
tu->ct = clear;
#ifndef AFS_NOSTATS
afs_stats_cmfullperf.authent.TicketUpdates++;
if (code) return code;
/* Copy all this junk into msg->im_data, keeping track of the lengths. */
cp = aout;
- bcopy((char *)&volstat, cp, sizeof(VolumeStatus));
+ memcpy(cp, (char *)&volstat, sizeof(VolumeStatus));
cp += sizeof(VolumeStatus);
strcpy(cp, volName);
cp += strlen(volName)+1;
return ENODEV;
/* Copy the junk out, using cp as a roving pointer. */
cp = ain;
- bcopy(cp, (char *)&volstat, sizeof(AFSFetchVolumeStatus));
+ memcpy((char *)&volstat, cp, sizeof(AFSFetchVolumeStatus));
cp += sizeof(AFSFetchVolumeStatus);
if (strlen(cp) >= sizeof(volName))
return E2BIG;
/* we are sending parms back to make compat. with prev system. should
change interface later to not ask for current status, just set new status */
cp = aout;
- bcopy((char *)&volstat, cp, sizeof(VolumeStatus));
+ memcpy(cp, (char *)&volstat, sizeof(VolumeStatus));
cp += sizeof(VolumeStatus);
strcpy(cp, volName);
cp += strlen(volName)+1;
at the end, in that order.
*/
if (newStyle = (ainSize > 0)) {
- bcopy(ain, (char *)&iterator, sizeof(afs_int32));
+ memcpy((char *)&iterator, ain, sizeof(afs_int32));
}
i = UHash(areq->uid);
ObtainReadLock(&afs_xuser);
cp = aout;
iterator = tu->stLen; /* for compat, we try to return 56 byte tix if they fit */
if (iterator < 56) iterator = 56; /* # of bytes we're returning */
- bcopy((char *)&iterator, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&iterator, sizeof(afs_int32));
cp += sizeof(afs_int32);
- bcopy(tu->stp, cp, tu->stLen); /* copy out st */
+ memcpy(cp, tu->stp, tu->stLen); /* copy out st */
cp += iterator;
iterator = sizeof(struct ClearToken);
- bcopy((char *)&iterator, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&iterator, sizeof(afs_int32));
cp += sizeof(afs_int32);
- bcopy((char *)&tu->ct, cp, sizeof(struct ClearToken));
+ memcpy(cp, (char *)&tu->ct, sizeof(struct ClearToken));
cp += sizeof(struct ClearToken);
if (newStyle) {
/* put out primary id and cell name, too */
iterator = (tu->states & UPrimary ? 1 : 0);
- bcopy((char *)&iterator, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&iterator, sizeof(afs_int32));
cp += sizeof(afs_int32);
tcell = afs_GetCell(tu->cell, READ_LOCK);
if (tcell) {
tu->vid = UNDEFVID;
tu->states &= ~UHasTokens;
/* security is not having to say you're sorry */
- bzero((char *)&tu->ct, sizeof(struct ClearToken));
+ memset((char *)&tu->ct, 0, sizeof(struct ClearToken));
tu->refCount++;
ReleaseWriteLock(&afs_xuser);
/* We have to drop the lock over the call to afs_ResetUserConns, since
AFS_STATCNT(PMariner);
if (afs_mariner)
- bcopy((char *)&afs_marinerHost, (char *)&oldHostAddr, sizeof(afs_int32));
+ memcpy((char *)&oldHostAddr, (char *)&afs_marinerHost, sizeof(afs_int32));
else
oldHostAddr = 0xffffffff; /* disabled */
- bcopy(ain, (char *)&newHostAddr, sizeof(afs_int32));
+ memcpy((char *)&newHostAddr, ain, sizeof(afs_int32));
if (newHostAddr == 0xffffffff) {
/* disable mariner operations */
afs_mariner = 0;
afs_mariner = 1;
afs_marinerHost = newHostAddr;
}
- bcopy((char *)&oldHostAddr, aout, sizeof(afs_int32));
+ memcpy(aout, (char *)&oldHostAddr, sizeof(afs_int32));
*aoutSize = sizeof(afs_int32);
return 0;
}
pcheck=(struct chservinfo *)ain;
if (pcheck->tinterval >= 0) {
cp = aout;
- bcopy((char *)&PROBE_INTERVAL, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&PROBE_INTERVAL, sizeof(afs_int32));
*aoutSize = sizeof(afs_int32);
if (pcheck->tinterval > 0) {
if (!afs_osi_suser(acred))
temp=pcheck->tflags;
cp = pcheck->tbuffer;
} else { /* For pre afs3.3 versions */
- bcopy(ain, (char *)&temp, sizeof(afs_int32));
+ memcpy((char *)&temp, ain, sizeof(afs_int32));
cp = ain+sizeof(afs_int32);
if (ainSize > sizeof(afs_int32))
havecell = 1;
for(ts = afs_servers[i]; ts; ts=ts->next) {
if (cellp && ts->cell != cellp) continue; /* cell spec'd and wrong */
if ((ts->flags & SRVR_ISDOWN) && ts->addr->sa_portal != ts->cell->vlport) {
- bcopy((char *)&ts->addr->sa_ip, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&ts->addr->sa_ip, sizeof(afs_int32));
cp += sizeof(afs_int32);
}
}
ReleaseReadLock(&afs_xconn);
afs_PutUser(tu, READ_LOCK);
}
- bcopy((char *)&retValue, aout, sizeof(afs_int32));
+ memcpy(aout, (char *)&retValue, sizeof(afs_int32));
*aoutSize = sizeof(afs_int32);
return 0;
}
for(i=0;i<MAXHOSTS;i++) {
ts = tvp->serverHost[i];
if (!ts) break;
- bcopy((char *)&ts->addr->sa_ip, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&ts->addr->sa_ip, sizeof(afs_int32));
cp += sizeof(afs_int32);
}
if (i<MAXHOSTS) {
/* still room for terminating NULL, add it on */
ainSize = 0; /* reuse vbl */
- bcopy((char *)&ainSize, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&ainSize, sizeof(afs_int32));
cp += sizeof(afs_int32);
}
*aoutSize = cp - aout;
if (!avc) return EINVAL;
code = afs_VerifyVCache(avc, areq);
if (code) return code;
- bcopy(ain, (char *)&temp, sizeof(afs_int32));
+ memcpy((char *)&temp, ain, sizeof(afs_int32));
code = afs_AccessOK(avc,temp, areq, CHECK_MODE_BITS);
if (code) return 0;
else return EACCES;
return EACCES;
/* too many things are setup initially in mem cache version */
if (cacheDiskType == AFS_FCACHE_TYPE_MEM) return EROFS;
- bcopy(ain, (char *)&newValue, sizeof(afs_int32));
+ memcpy((char *)&newValue, ain, sizeof(afs_int32));
if (newValue == 0) afs_cacheBlocks = afs_stats_cmperf.cacheBlocksOrig;
else {
extern u_int afs_min_cache;
afs_int32 results[MAXGCSTATS];
AFS_STATCNT(PGetCacheSize);
- bzero((char *)results, sizeof(results));
+ memset((char *)results, 0, sizeof(results));
results[0] = afs_cacheBlocks;
results[1] = afs_blocksUsed;
- bcopy((char *)results, aout, sizeof(results));
+ memcpy(aout, (char *)results, sizeof(results));
*aoutSize = sizeof(results);
return 0;
}
if (!afs_osi_suser(acred))
return EACCES;
- bcopy(tp, (char *)&magic, sizeof(afs_int32));
+ memcpy((char *)&magic, tp, sizeof(afs_int32));
tp += sizeof(afs_int32);
if (magic != 0x12345678)
return EINVAL;
scount = ((newcell[0] != '\0') ? MAXCELLHOSTS : MAXHOSTS);
/* MAXCELLHOSTS (=8) is less than MAXHOSTS (=13) */
- bcopy(tp, (char *)cellHosts, MAXCELLHOSTS * sizeof(afs_int32));
+ memcpy((char *)cellHosts, tp, MAXCELLHOSTS * sizeof(afs_int32));
tp += (scount * sizeof(afs_int32));
lp = (afs_int32 *)tp;
if ( !afs_resourceinit_flag ) /* afs deamons havn't started yet */
return EIO; /* Inappropriate ioctl for device */
- bcopy(tp, (char *)&whichCell, sizeof(afs_int32));
+ memcpy((char *)&whichCell, tp, sizeof(afs_int32));
tp += sizeof(afs_int32);
ObtainReadLock(&afs_xcell);
for (cq = CellLRU.next; cq != &CellLRU; cq = tq) {
}
if (tcell) {
cp = aout;
- bzero(cp, MAXCELLHOSTS * sizeof(afs_int32));
+ memset(cp, 0, MAXCELLHOSTS * sizeof(afs_int32));
for(i=0;i<MAXCELLHOSTS;i++) {
if (tcell->cellHosts[i] == 0) break;
- bcopy((char *)&tcell->cellHosts[i]->addr->sa_ip, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&tcell->cellHosts[i]->addr->sa_ip, sizeof(afs_int32));
cp += sizeof(afs_int32);
}
cp = aout + MAXCELLHOSTS * sizeof(afs_int32);
if (!tcell) return ENOENT;
temp = tcell->states;
afs_PutCell(tcell, READ_LOCK);
- bcopy((char *)&temp, aout, sizeof(afs_int32));
+ memcpy(aout, (char *)&temp, sizeof(afs_int32));
*aoutSize = sizeof(afs_int32);
return 0;
}
tcell = afs_GetCellByName(ain+2*sizeof(afs_int32), WRITE_LOCK);
if (!tcell) return ENOENT;
- bcopy(ain, (char *)&temp, sizeof(afs_int32));
+ memcpy((char *)&temp, ain, sizeof(afs_int32));
if (temp & CNoSUID)
tcell->states |= CNoSUID;
else
stat.flockCount = avc->flockCount;
stat.mvstat = avc->mvstat;
stat.states = avc->states;
- bcopy((char *)&stat, aout, sizeof(struct vcxstat));
+ memcpy(aout, (char *)&stat, sizeof(struct vcxstat));
*aoutSize = sizeof(struct vcxstat);
return 0;
}
return (setuerror(EINVAL), EINVAL);
#endif
}
- bzero(inname, MAXSYSNAME);
- bcopy(ain, (char *)&setsysname, sizeof(afs_int32));
+ memset(inname, 0, MAXSYSNAME);
+ memcpy((char *)&setsysname, ain, sizeof(afs_int32));
ain += sizeof(afs_int32);
if (setsysname) {
/* inname gets first entry in case we're being a translater */
t = strlen(ain);
- bcopy(ain, inname, t+1); /* include terminating null */
+ memcpy(inname, ain, t+1); /* include terminating null */
ain += t + 1;
}
if (acred->cr_gid == RMTUSER_REQ) { /* Handles all exporters */
if (!afs_sysnamelist[count])
osi_Panic("PSetSysName: no afs_sysnamelist entry to write\n");
t = strlen(cp);
- bcopy(cp, afs_sysnamelist[count], t+1); /* include null */
+ memcpy(afs_sysnamelist[count], cp, t+1); /* include null */
cp += t+1;
}
}
}
if (!setsysname) {
cp = aout; /* not changing so report back the count and ... */
- bcopy((char *)&foundname, cp, sizeof(afs_int32));
+ memcpy(cp, (char *)&foundname, sizeof(afs_int32));
cp += sizeof(afs_int32);
if (foundname) {
strcpy(cp, outname); /* ... the entry, ... */
register struct afs_exporter *exporter;
AFS_STATCNT(PExportAfs);
- bcopy(ain, (char *)&handleValue, sizeof(afs_int32));
+ memcpy((char *)&handleValue, ain, sizeof(afs_int32));
type = handleValue >> 24;
if (type == 0x71) {
newint = 1;
}
if (!changestate) {
handleValue = exporter->exp_states;
- bcopy((char *)&handleValue, aout, sizeof(afs_int32));
+ memcpy(aout, (char *)&handleValue, sizeof(afs_int32));
*aoutSize = sizeof(afs_int32);
} else {
if (!afs_osi_suser(acred))
}
}
handleValue = exporter->exp_states;
- bcopy((char *)&handleValue, aout, sizeof(afs_int32));
+ memcpy(aout, (char *)&handleValue, sizeof(afs_int32));
*aoutSize = sizeof(afs_int32);
} else {
if (export)
if (sizeof(struct cm_initparams) > PIGGYSIZE)
return E2BIG;
- bcopy((char*)&cm_initParams, aout, sizeof(struct cm_initparams));
+ memcpy(aout, (char*)&cm_initParams, sizeof(struct cm_initparams));
*aoutSize = sizeof(struct cm_initparams);
return 0;
}
{
cred_t *cr;
cr = crdup(get_current_cred());
- bzero((char*)cr, sizeof(cred_t));
+ memset((char*)cr, 0, sizeof(cred_t));
#if CELL || CELL_PREPARE
cr->cr_id = -1;
#endif
afs_int32 *aoutSize;
struct AFS_UCRED *acred;
{
- bcopy((char *)&cryptall, aout, sizeof(afs_int32));
+ memcpy(aout, (char *)&cryptall, sizeof(afs_int32));
*aoutSize=sizeof(afs_int32);
return 0;
}
return EPERM;
if (ainSize != sizeof(afs_int32) || ain == NULL)
return EINVAL;
- bcopy(ain, (char *)&tmpval, sizeof(afs_int32));
+ memcpy((char *)&tmpval, ain, sizeof(afs_int32));
/* if new mappings added later this will need to be changed */
if (tmpval != 0 && tmpval != 1)
return EINVAL;
code = EINVAL;
goto out;
}
- bcopy(ain, (char *)&flags, sizeof(afs_int32));
+ memcpy((char *)&flags, ain, sizeof(afs_int32));
if (!(flags & AFSCALL_RXSTATS_MASK) || (flags & ~AFSCALL_RXSTATS_MASK)) {
code = EINVAL;
goto out;
code = EINVAL;
goto out;
}
- bcopy(ain, (char *)&flags, sizeof(afs_int32));
+ memcpy((char *)&flags, ain, sizeof(afs_int32));
if (!(flags & AFSCALL_RXSTATS_MASK) || (flags & ~AFSCALL_RXSTATS_MASK)) {
code = EINVAL;
goto out;
minj = 0 ;
do {
- bzero ((char *)dcList, NCHUNKSATONCE * sizeof(struct dcache *));
+ memset((char *)dcList, 0, NCHUNKSATONCE * sizeof(struct dcache *));
high = 0;
moredata = FALSE;
while (sbytes > 0) {
tlen = (sbytes > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : sbytes);
- bzero(tbuffer, tlen);
+ memset(tbuffer, 0, tlen);
#ifdef RX_ENABLE_LOCKS
AFS_GUNLOCK();
#endif /* RX_ENABLE_LOCKS */
afs_stats_cmperf.fs_UpDown[0].sumOfRecordAges = 0;
afs_stats_cmperf.fs_UpDown[0].ageOfYoungestRecord = 0;
afs_stats_cmperf.fs_UpDown[0].ageOfOldestRecord = 0;
- bzero((char *) afs_stats_cmperf.fs_UpDown[0].downIncidents,
- AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
+ memset((char *) afs_stats_cmperf.fs_UpDown[0].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
afs_stats_cmperf.fs_UpDown[1].sumOfRecordAges = 0;
afs_stats_cmperf.fs_UpDown[1].ageOfYoungestRecord = 0;
afs_stats_cmperf.fs_UpDown[1].ageOfOldestRecord = 0;
- bzero((char *) afs_stats_cmperf.fs_UpDown[1].downIncidents,
- AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
+ memset((char *) afs_stats_cmperf.fs_UpDown[1].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
afs_stats_cmperf.vl_UpDown[0].sumOfRecordAges = 0;
afs_stats_cmperf.vl_UpDown[0].ageOfYoungestRecord = 0;
afs_stats_cmperf.vl_UpDown[0].ageOfOldestRecord = 0;
- bzero((char *) afs_stats_cmperf.vl_UpDown[0].downIncidents,
- AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
+ memset((char *) afs_stats_cmperf.vl_UpDown[0].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
afs_stats_cmperf.vl_UpDown[1].sumOfRecordAges = 0;
afs_stats_cmperf.vl_UpDown[1].ageOfYoungestRecord = 0;
afs_stats_cmperf.vl_UpDown[1].ageOfOldestRecord = 0;
- bzero((char *) afs_stats_cmperf.vl_UpDown[1].downIncidents,
- AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
+ memset((char *) afs_stats_cmperf.vl_UpDown[1].downIncidents, 0, AFS_STATS_NUM_DOWNTIME_INCIDENTS_BUCKETS * sizeof(afs_int32));
/*
* Compute the current time, used to figure out server record ages.
i = afs_uuid_hash(uuidp) % NSERVERS;
for (ts = afs_servers[i]; ts; ts = ts->next) {
if ( (ts->flags & SRVR_MULTIHOMED) &&
- (bcmp((char *)uuidp, (char *)&ts->sr_uuid, sizeof(*uuidp)) == 0) &&
+ (memcmp((char *)uuidp, (char *)&ts->sr_uuid, sizeof(*uuidp)) == 0) &&
(!ts->addr || (ts->addr->sa_portal == aport)) )
return ts;
}
newts = (struct server *) afs_osi_Alloc(sizeof(struct server));
if (!newts) panic("malloc of server struct");
afs_totalServers++;
- bzero((char *)newts, sizeof(struct server));
+ memset((char *)newts, 0, sizeof(struct server));
/* Add the server struct to the afs_servers[] hash chain */
srvhash = (uuidp ? (afs_uuid_hash(uuidp)%NSERVERS) : SHash(aserverp[0]));
newsa = (struct srvAddr *) afs_osi_Alloc(sizeof(struct srvAddr));
if (!newsa) panic("malloc of srvAddr struct");
afs_totalSrvAddrs++;
- bzero((char *)newsa, sizeof(struct srvAddr));
+ memset((char *)newsa, 0, sizeof(struct srvAddr));
/* Add the new srvAddr to the afs_srvAddrs[] hash chain */
newsa->next_bkt = afs_srvAddrs[iphash];
if (!orphts) {
orphts = (struct server *) afs_osi_Alloc(sizeof(struct server));
if (!orphts) panic("malloc of lo server struct");
- bzero((char *)orphts, sizeof(struct server));
+ memset((char *)orphts, 0, sizeof(struct server));
afs_totalServers++;
/* Add the orphaned server to the afs_servers[] hash chain.
/*
* First step is to zero everything out.
*/
- bzero((char *)(&afs_cmstats), sizeof(struct afs_CMStats));
- bzero((char *)(&afs_stats_cmperf), sizeof(struct afs_stats_CMPerf));
- bzero((char *)(&afs_stats_cmfullperf),
- sizeof(struct afs_stats_CMFullPerf));
+ memset((char *)(&afs_cmstats), 0, sizeof(struct afs_CMStats));
+ memset((char *)(&afs_stats_cmperf), 0, sizeof(struct afs_stats_CMPerf));
+ memset((char *)(&afs_stats_cmfullperf), 0, sizeof(struct afs_stats_CMFullPerf));
/*
* Some fields really should be non-zero at the start, so set 'em up.
#ifndef AFS_NOSTATS
afs_stats_cmfullperf.authent.PAGCreations++;
#endif /* AFS_NOSTATS */
- bzero((char *)tu, sizeof(struct unixuser));
+ memset((char *)tu, 0, sizeof(struct unixuser));
tu->next = afs_users[i];
afs_users[i] = tu;
if (RmtUser) {
#endif /* AFS_MACH_ENV */
#if defined(AFS_SGI_ENV)
{ char name[METER_NAMSZ];
- bzero(tvc, sizeof(struct vcache));
+ memset(tvc, 0, sizeof(struct vcache));
tvc->v.v_number = ++afsvnumbers;
tvc->vc_rwlockid = OSI_NO_LOCKID;
initnsema(&tvc->vc_rwlock, 1, makesname(name, "vrw", tvc->v.v_number));
#endif /* AFS_MACH_ENV */
#if !defined(AFS_SGI_ENV) && !defined(AFS_OSF_ENV)
- bzero((char *)tvc, sizeof(struct vcache));
+ memset((char *)tvc, 0, sizeof(struct vcache));
#else
tvc->uncred = 0;
#endif
#ifdef AFS_AIX_ENV
/* Don't forget to free the gnode space */
tvc->v.v_gnode = gnodepnt = (struct gnode *) osi_AllocSmallSpace(sizeof(struct gnode));
- bzero((char *)gnodepnt, sizeof(struct gnode));
+ memset((char *)gnodepnt, 0, sizeof(struct gnode));
#endif
#ifdef AFS_SGI64_ENV
- bzero((void*)&(tvc->vc_bhv_desc), sizeof(tvc->vc_bhv_desc));
+ memset((void*)&(tvc->vc_bhv_desc), 0, sizeof(tvc->vc_bhv_desc));
bhv_desc_init(&(tvc->vc_bhv_desc), tvc, tvc, &Afs_vnodeops);
#ifdef AFS_SGI65_ENV
vn_bhv_head_init(&(tvc->v.v_bh), "afsvp");
#endif
tvc->h1.dchint = 0;
osi_dnlc_purgedp(tvc); /* this may be overkill */
- bzero((char *)&(tvc->quick),sizeof(struct vtodc));
- bzero((char *)&(tvc->callsort),sizeof(struct afs_q));
+ memset((char *)&(tvc->quick), 0, sizeof(struct vtodc));
+ memset((char *)&(tvc->callsort), 0, sizeof(struct afs_q));
tvc->slocks = (struct SimpleLocks *)0;
i = VCHash(afid);
#if !defined(AFS_OSF_ENV)
/* Allocate and thread the struct vcache entries */
tvp = (struct vcache *) afs_osi_Alloc(astatSize * sizeof(struct vcache));
- bzero((char *)tvp, sizeof(struct vcache)*astatSize);
+ memset((char *)tvp, 0, sizeof(struct vcache)*astatSize);
Initial_freeVCList = tvp;
freeVCList = &(tvp[0]);
struct fvolume *tf=0;
tv = afs_GetVolSlot();
- bzero((char *)tv, sizeof(struct volume));
+ memset((char *)tv, 0, sizeof(struct volume));
tv->cell = tcell->cell;
RWLOCK_INIT(&tv->lock, "volume lock");
tv->next = afs_volumes[i]; /* thread into list */
ListAddrByAttributes attrs;
afsUUID uuid;
- bzero((char *)&attrs, sizeof(attrs));
+ memset((char *)&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_UUID;
attrs.uuid = ve->serverNumber[i];
- bzero((char *)&uuid, sizeof(uuid));
- bzero((char *)&addrs, sizeof(addrs));
+ memset((char *)&uuid, 0, sizeof(uuid));
+ memset((char *)&addrs, 0, sizeof(addrs));
do {
tconn = afs_ConnByMHosts(tcell->cellHosts, tcell->vlport,
tcell->cell, areq, SHARED_LOCK);
#ifdef AFS_SUN5_ENV
/* On solaris the above does not resolve hostnames to full names */
if (he != (struct hostent *)0) {
- bcopy(he->h_addr, ip_addr, he->h_length);
+ memcpy(ip_addr, he->h_addr, he->h_length);
he = gethostbyaddr(ip_addr, he->h_length, he->h_addrtype);
}
#endif
fprintf(stderr,"[ %s ] Memory Allocation error 1",rn);
afsmon_Exit(25);
}
- bzero(curr_host->thresh,numBytes);
+ memset(curr_host->thresh, 0, numBytes);
}
curr_host = curr_host->next;;
}
fprintf(stderr,"[ %s ] Memory Allocation error 2",rn);
afsmon_Exit(35);
}
- bzero(curr_host->thresh,numBytes);
+ memset(curr_host->thresh, 0, numBytes);
}
curr_host = curr_host->next;;
}
/* copy hostname and probe number and probe time and probe status.
if the probe failed return now */
- bcopy(xstat_fs_Results.connP->hostName, tmp_fsPR->connP->hostName,
- sizeof(xstat_fs_Results.connP->hostName));
+ memcpy(tmp_fsPR->connP->hostName, xstat_fs_Results.connP->hostName, sizeof(xstat_fs_Results.connP->hostName));
tmp_fsPR->probeNum = xstat_fs_Results.probeNum;
tmp_fsPR->probeTime = xstat_fs_Results.probeTime;
tmp_fsPR->probeOK = xstat_fs_Results.probeOK;
}
/* copy connection information */
-#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- bcopy(&(xstat_fs_Results.connP->skt), &(tmp_fsPR->connP->skt),
- sizeof(struct sockaddr_in));
-#else
- bcopy(xstat_fs_Results.connP->skt, tmp_fsPR->connP->skt,
- sizeof(struct sockaddr_in));
-#endif
+ memcpy(&(tmp_fsPR->connP->skt), &(xstat_fs_Results.connP->skt), sizeof(struct sockaddr_in));
- bcopy(xstat_fs_Results.connP->hostName, tmp_fsPR->connP->hostName,
- sizeof(xstat_fs_Results.connP->hostName));
+ memcpy(tmp_fsPR->connP->hostName, xstat_fs_Results.connP->hostName, sizeof(xstat_fs_Results.connP->hostName));
tmp_fsPR->collectionNumber = xstat_fs_Results.collectionNumber;
/* copy the probe data information */
tmp_fsPR->data.AFS_CollData_len = xstat_fs_Results.data.AFS_CollData_len;
- bcopy(xstat_fs_Results.data.AFS_CollData_val,
- tmp_fsPR->data.AFS_CollData_val,
- xstat_fs_Results.data.AFS_CollData_len * sizeof(afs_int32));
+ memcpy(tmp_fsPR->data.AFS_CollData_val, xstat_fs_Results.data.AFS_CollData_val, xstat_fs_Results.data.AFS_CollData_len * sizeof(afs_int32));
/* we have a valid results structure so mark the list item used */
/* backup the display data of the probe cycle that just completed -
ie., store curr_fsData in prev_fsData */
- bcopy((char *)curr_fsData, (char *)prev_fsData,
- (numFS * sizeof(struct fs_Display_Data)) );
+ memcpy((char *)prev_fsData, (char *)curr_fsData, (numFS * sizeof(struct fs_Display_Data)) );
/* initialize curr_fsData but retain the threshold flag information.
for(i=0; i<numFS; i++) {
curr_fsDataP->probeOK = 0;
curr_fsDataP->ovfCount = 0;
- bzero((char *)curr_fsDataP->data, numBytes);
+ memset((char *)curr_fsDataP->data, 0, numBytes);
curr_fsDataP++;
}
/* copy hostname and probe number and probe time and probe status.
if the probe failed return now */
- bcopy(xstat_cm_Results.connP->hostName, tmp_cmPR->connP->hostName,
- sizeof(xstat_cm_Results.connP->hostName));
+ memcpy(tmp_cmPR->connP->hostName, xstat_cm_Results.connP->hostName, sizeof(xstat_cm_Results.connP->hostName));
tmp_cmPR->probeNum = xstat_cm_Results.probeNum;
tmp_cmPR->probeTime = xstat_cm_Results.probeTime;
tmp_cmPR->probeOK = xstat_cm_Results.probeOK;
/* copy connection information */
-#if defined(AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- bcopy(&(xstat_cm_Results.connP->skt), &(tmp_cmPR->connP->skt),
- sizeof(struct sockaddr_in));
-#else
- bcopy(xstat_cm_Results.connP->skt, tmp_cmPR->connP->skt,
- sizeof(struct sockaddr_in));
-#endif
+ memcpy(&(tmp_cmPR->connP->skt), &(xstat_cm_Results.connP->skt), sizeof(struct sockaddr_in));
/**** NEED TO COPY rx_connection INFORMATION HERE ******/
- bcopy(xstat_cm_Results.connP->hostName, tmp_cmPR->connP->hostName,
- sizeof(xstat_cm_Results.connP->hostName));
+ memcpy(tmp_cmPR->connP->hostName, xstat_cm_Results.connP->hostName, sizeof(xstat_cm_Results.connP->hostName));
tmp_cmPR->collectionNumber = xstat_cm_Results.collectionNumber;
/* copy the probe data information */
tmp_cmPR->data.AFSCB_CollData_len = xstat_cm_Results.data.AFSCB_CollData_len;
- bcopy(xstat_cm_Results.data.AFSCB_CollData_val,
- tmp_cmPR->data.AFSCB_CollData_val,
- xstat_cm_Results.data.AFSCB_CollData_len * sizeof(afs_int32));
+ memcpy(tmp_cmPR->data.AFSCB_CollData_val, xstat_cm_Results.data.AFSCB_CollData_val, xstat_cm_Results.data.AFSCB_CollData_len * sizeof(afs_int32));
/* we have a valid results structure so mark the list item used */
/* backup the display data of the probe cycle that just completed -
ie., store curr_cmData in prev_cmData */
- bcopy((char *)curr_cmData, (char *)prev_cmData,
- (numCM * sizeof(struct cm_Display_Data)) );
+ memcpy((char *)prev_cmData, (char *)curr_cmData, (numCM * sizeof(struct cm_Display_Data)) );
/* initialize curr_cmData but retain the threshold flag information.
for(i=0; i<numCM; i++) {
curr_cmDataP->probeOK = 0;
curr_cmDataP->ovfCount = 0;
- bzero((char *)curr_cmDataP->data, numBytes);
+ memset((char *)curr_cmDataP->data, 0, numBytes);
curr_cmDataP++;
}
fprintf(stderr,"[ %s ] Memory allocation failure\n",rn);
return(-1);
}
- bzero(curr_fsData,numBytes);
+ memset(curr_fsData, 0, numBytes);
numBytes = numFS * sizeof(struct fs_Display_Data);
prev_fsData = (struct fs_Display_Data *) malloc(numBytes);
fprintf(stderr,"[ %s ] Memory allocation failure\n",rn);
return(-5);
}
- bzero(prev_fsData,numBytes);
+ memset(prev_fsData, 0, numBytes);
/* fill in the host names */
tmp_fsData1 = curr_fsData;
fprintf(stderr,"[ %s ] Memory allocation failure\n",rn);
return(-10);
}
- bzero(curr_cmData,numBytes);
+ memset(curr_cmData, 0, numBytes);
numBytes = numCM * sizeof(struct cm_Display_Data);
prev_cmData = (struct cm_Display_Data *) malloc(numBytes);
fprintf(stderr,"[ %s ] Memory allocation failure\n",rn);
return(-15);
}
- bzero(prev_cmData,numBytes);
+ memset(prev_cmData, 0, numBytes);
/* fill in the host names */
tmp_cmData1 = curr_cmData;
return(-1);
}
- bzero(FSSktArray, FSsktbytes);
+ memset(FSSktArray, 0, FSsktbytes);
/* Fill in the socket information for each fileserve */
return(-1);
}
strncpy(curr_FS->hostName,he->h_name,HOST_NAME_LEN); /* complete name*/
- bcopy(he->h_addr, &(curr_skt->sin_addr.s_addr), 4);
+ memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
curr_skt->sin_family = htons(AF_INET); /*Internet family*/
curr_skt->sin_port = htons(7000); /*FileServer port*/
return(-1);
}
- bzero(CMSktArray, CMsktbytes);
+ memset(CMSktArray, 0, CMsktbytes);
/* Fill in the socket information for each CM */
return(-1);
}
strncpy(curr_CM->hostName,he->h_name,HOST_NAME_LEN); /* complete name*/
- bcopy(he->h_addr, &(curr_skt->sin_addr.s_addr), 4);
+ memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
curr_skt->sin_family = htons(AF_INET); /*Internet family*/
curr_skt->sin_port = htons(7001); /*Cache Manager port*/
afs_int32 EndTimestamp;
} token;
tp=buf;
- bcopy(tp, &len, sizeof(afs_int32)); /* get size of secret token */
+ memcpy(&len, tp, sizeof(afs_int32)); /* get size of secret token */
rc=(len+sizeof(afs_int32));
tp += (sizeof(afs_int32) + len); /* skip secret token and its length */
- bcopy(tp, &len, sizeof(afs_int32)); /* get size of clear token */
+ memcpy(&len, tp, sizeof(afs_int32)); /* get size of clear token */
if (len != sizeof(struct ClearToken)) {
#ifdef DEBUG
fprintf(stderr, "apache_afs_cache.c:getExpiration:"
} token;
tp = buf;
- bcopy(tp, &len, sizeof(afs_int32)); /* get size of secret token */
+ memcpy(&len, tp, sizeof(afs_int32)); /* get size of secret token */
tp += (sizeof(afs_int32) + len); /* skip secret token and its length */
- bcopy(tp, &len, sizeof(afs_int32)); /* get size of clear token */
+ memcpy(&len, tp, sizeof(afs_int32)); /* get size of clear token */
if (len != sizeof(struct ClearToken)) {
#ifdef DEBUG
fprintf(stderr, "apache_afs_cache.c:getExpiration:"
}
tp += sizeof(afs_int32); /* skip length of clear token */
- bcopy(tp, &token, sizeof(struct ClearToken)); /* copy the token */
+ memcpy(&token, tp, sizeof(struct ClearToken)); /* copy the token */
return token.EndTimestamp;
}
#ifdef OLDSETPAG
/* skip over the secret token */
temp = tokenBuf;
- bcopy(temp, &i, sizeof(afs_int32));
+ memcpy(&i, temp, sizeof(afs_int32));
temp += (i + sizeof(afs_int32));
/* skip over the clear token */
- bcopy(temp, &i, sizeof(afs_int32));
+ memcpy(&i, temp, sizeof(afs_int32));
temp += (i + sizeof(afs_int32));
doneSETPAG = 1;
- bcopy(temp, &i, sizeof(afs_int32));
+ memcpy(&i, temp, sizeof(afs_int32));
i |= 0x8000;
- bcopy(&i, temp, sizeof(afs_int32));
+ memcpy(temp, &i, sizeof(afs_int32));
temp += sizeof(afs_int32);
#endif
strcpy(global_default_cell, defaultCell);
}
- bzero(user,APACHEAFS_USERNAME_MAX);
- bzero(passwd,APACHEAFS_PASSWORD_MAX);
- bzero(cell,APACHEAFS_CELLNAME_MAX);
+ memset(user, 0, APACHEAFS_USERNAME_MAX);
+ memset(passwd, 0, APACHEAFS_PASSWORD_MAX);
+ memset(cell, 0, APACHEAFS_CELLNAME_MAX);
if (auth_line == NULL) { /* No Authorization field - we don't do anything */
/*
afslog(15, ("%s: No authline recieved", module_name));
haveAuth = 0;
userChanged=1;
- bzero(lastUser, APACHEAFS_USERNAME_MAX);
- bzero(lastCell, APACHEAFS_CELLNAME_MAX);
- bzero(lastCksum, SHA_HASH_BYTES);
+ memset(lastUser, 0, APACHEAFS_USERNAME_MAX);
+ memset(lastCell, 0, APACHEAFS_CELLNAME_MAX);
+ memset(lastCksum, 0, SHA_HASH_BYTES);
rc = unlog();
afslog(25, ("%s: pid:%d No Authorization field. Unlogging ...",
module_name, getpid()));
module_name, getpid()));
haveAuth = 0;
userChanged = 1;
- bzero(lastUser, APACHEAFS_USERNAME_MAX);
- bzero(lastCell, APACHEAFS_CELLNAME_MAX);
- bzero(lastCksum, SHA_HASH_BYTES);
+ memset(lastUser, 0, APACHEAFS_USERNAME_MAX);
+ memset(lastCell, 0, APACHEAFS_CELLNAME_MAX);
+ memset(lastCksum, 0, SHA_HASH_BYTES);
rc = unlog();
if (rc) {
sprintf(err_msg, "%s: Error unlogging from AFS cell - rc: %d, errno:%d",
afsassert(r);
afsassert(buf);
- bzero(buf, APACHEAFS_CELLNAME_MAX);
+ memset(buf, 0, APACHEAFS_CELLNAME_MAX);
pos = strchr(r->uri,'/');
if (pos != NULL) {
pos++;
afsassert(buf);
afsassert(msg);
- bzero(blank, sizeof(blank));
+ memset(blank, 0, sizeof(blank));
afslog(50, ("%s: Parsing Authorization Required reply. buf:%s", module_name, buf));
pos = strchr(buf, '<');
pos++;
strcat(msg, pos);
strcpy(buf, msg);
- bzero(msg, 1024);
+ memset(msg, 0, 1024);
parseAuthName_int(r, buf, msg);
return 0;
}
afsassert(r);
afsassert(buf);
- bzero(msg, sizeof(msg));
+ memset(msg, 0, sizeof(msg));
pos=strchr(buf,'<');
while (pos != NULL) {
return -1;
}
strcpy(buf, msg);
- bzero(msg, sizeof(msg));
+ memset(msg, 0, sizeof(msg));
pos = strchr(buf, '<');
}
afslog(50, ("%s: Parsing WWW Auth required reply. final message:%s",
char * temp = tokenBuf;
/* skip over the secret token */
- bcopy(temp, &i, sizeof(afs_int32));
+ memcpy(&i, temp, sizeof(afs_int32));
temp += (i + sizeof(afs_int32));
/* skip over the clear token */
- bcopy(temp, &i, sizeof(afs_int32));
+ memcpy(&i, temp, sizeof(afs_int32));
temp += (i + sizeof(afs_int32));
/* set the primary flag */
- bcopy(temp, &i, sizeof(afs_int32));
+ memcpy(&i, temp, sizeof(afs_int32));
i |= 0x8000;
- bcopy(&i, temp, sizeof(afs_int32));
+ memcpy(temp, &i, sizeof(afs_int32));
temp += sizeof(afs_int32);
return 0;
}
assert ( buf != NULL );
tp = buf;
- bcopy(tp, &len, sizeof(afs_int32)); /* get size of secret token */
+ memcpy(&len, tp, sizeof(afs_int32)); /* get size of secret token */
tp += (sizeof(afs_int32)+ len); /* skip secret token */
- bcopy(tp, &len, sizeof(afs_int32)); /* get size of clear token */
+ memcpy(&len, tp, sizeof(afs_int32)); /* get size of clear token */
if (len != sizeof(struct ClearToken)) {
fprintf(stderr, "weblog:parseToken: error getting length of ClearToken\n");
return;
}
tp += sizeof(afs_int32); /* skip length of cleartoken */
- bcopy(tp, &clearToken, sizeof(struct ClearToken)); /* copy cleartoken */
+ memcpy(&clearToken, tp, sizeof(struct ClearToken)); /* copy cleartoken */
tp += len; /* skip clear token itself */
- bcopy(tp, &len, sizeof(afs_int32)); /* copy the primary flag */
+ memcpy(&len, tp, sizeof(afs_int32)); /* copy the primary flag */
tp += sizeof(afs_int32); /* skip primary flag */
/* tp now points to the cell name */
#include <sys/time.h>
#define NEED_STRERROR
typedef int rlim_t;
-#define memmove(a,b,c) bcopy(b,a,c)
+#ifndef HAVE_MEMMOVE
+#define memmove(a,b,c) memcpy(a, b, c)
+#endif
#define NO_LINGCLOSE
#define USE_FLOCK_SERIALIZED_ACCEPT
#define NO_KILLPG
#undef NO_SETSID
#define HAVE_SYS_RESOURCE_H
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
#define USE_FCNTL_SERIALIZED_ACCEPT
#define HAVE_MMAP
/* These are to let -Wall compile more cleanly */
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *,const char *,unsigned);
-extern int set42sig(), getopt(), getpeername(), bzero();
+extern int set42sig(), getopt(), getpeername();
extern int listen(), bind(), socket(), getsockname();
extern int accept(), gethostname(), connect(), lstat();
extern int select(), killpg(), shutdown();
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
/* A lot of SVR4 systems need this */
#define USE_FCNTL_SERIALIZED_ACCEPT
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
#define HAVE_RESOURCE
#define HAVE_MMAP
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
/* A lot of SVR4 systems need this */
#define USE_FCNTL_SERIALIZED_ACCEPT
#define NO_KILLPG
#undef NO_SETSID
#define HAVE_RESOURCE 1
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
#define USE_FCNTL_SERIALIZED_ACCEPT
#define HAVE_MMAP
#include <sys/time.h>
#define NEED_STRERROR
typedef int rlim_t;
-#define memmove(a,b,c) bcopy(b,a,c)
+#ifndef HAVE_MEMMOVE
+#define memmove(a,b,c) memcpy(a, b, c)
+#endif
#define NO_LINGCLOSE
#define USE_FLOCK_SERIALIZED_ACCEPT
#define NEED_DIFFTIME
#undef HAVE_GMTOFF
#define NO_KILLPG
#undef NO_SETSID
-#define bzero(a,b) memset(a,0,b)
#if !defined(USE_SYSVSEM_SERIALIZED_ACCEPT) && \
!defined(USE_PTHREAD_SERIALIZED_ACCEPT)
#define USE_FCNTL_SERIALIZED_ACCEPT
#endif
#define USE_FCNTL_SERIALIZED_ACCEPT
#ifdef USEBCOPY
-#define memmove(a,b,c) bcopy(b,a,c)
+#define memmove(a,b,c) memcpy(a, b, c)
#endif
#if AIX >= 42
#define NET_SIZE_T size_t
/* These are to let -Wall compile more cleanly */
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *, const char *, unsigned);
-extern int set42sig(), getopt(), getpeername(), bzero();
+extern int set42sig(), getopt(), getpeername();
extern int listen(), bind(), socket(), getsockname();
extern int accept(), gethostname(), connect(), lstat();
extern int select(), killpg(), shutdown();
#define NEED_STRNCASECMP
#endif /* ENCORE */
#endif /* MPRAS */
-#define bzero(a,b) memset(a,0,b)
/* A lot of SVR4 systems need this */
#ifndef USE_SYSVSEM_SERIALIZED_ACCEPT
#define USE_FCNTL_SERIALIZED_ACCEPT
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define HAVE_MMAP 1
#define USE_MMAP_SCOREBOARD
#define USE_MMAP_FILES
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
/* A lot of SVR4 systems need this */
#define USE_FCNTL_SERIALIZED_ACCEPT
#define ap_inet_addr inet_network
#undef HAVE_GMTOFF
#define NO_KILLPG
#undef NO_SETSID
-#define bzero(a,b) memset(a,0,b)
#define USE_FCNTL_SERIALIZED_ACCEPT
#define HAVE_MMAP 1
#define USE_MMAP_SCOREBOARD
#include <sys/time.h>
#define NEED_STRERROR
typedef int rlim_t;
-#define memmove(a,b,c) bcopy(b,a,c)
+#ifndef HAVE_MEMMOVE
+#define memmove(a,b,c) memcpy(a, b, c)
+#endif
#define NO_LINGCLOSE
#define USE_FLOCK_SERIALIZED_ACCEPT
#define NEED_DIFFTIME
#undef HAVE_GMTOFF
#define NO_KILLPG
#undef NO_SETSID
-#define bzero(a,b) memset(a,0,b)
#if !defined(USE_SYSVSEM_SERIALIZED_ACCEPT) && \
!defined(USE_PTHREAD_SERIALIZED_ACCEPT)
#define USE_FCNTL_SERIALIZED_ACCEPT
#endif
#define USE_FCNTL_SERIALIZED_ACCEPT
#ifdef USEBCOPY
-#define memmove(a,b,c) bcopy(b,a,c)
+#define memmove(a,b,c) memcpy(a, b, c)
#endif
#if AIX >= 42
#define NET_SIZE_T size_t
/* These are to let -Wall compile more cleanly */
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *, const char *, unsigned);
-extern int set42sig(), getopt(), getpeername(), bzero();
+extern int set42sig(), getopt(), getpeername();
extern int listen(), bind(), socket(), getsockname();
extern int accept(), gethostname(), connect(), lstat();
extern int select(), killpg(), shutdown();
#define NEED_STRNCASECMP
#endif /* ENCORE */
#endif /* MPRAS */
-#define bzero(a,b) memset(a,0,b)
/* A lot of SVR4 systems need this */
#ifndef USE_SYSVSEM_SERIALIZED_ACCEPT
#define USE_FCNTL_SERIALIZED_ACCEPT
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define HAVE_MMAP 1
#define USE_MMAP_SCOREBOARD
#define USE_MMAP_FILES
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
#endif
-#define bzero(a,b) memset(a,0,b)
/* A lot of SVR4 systems need this */
#define USE_FCNTL_SERIALIZED_ACCEPT
#define ap_inet_addr inet_network
#undef HAVE_GMTOFF
#define NO_KILLPG
#undef NO_SETSID
-#define bzero(a,b) memset(a,0,b)
#define USE_FCNTL_SERIALIZED_ACCEPT
#define HAVE_MMAP 1
#define USE_MMAP_SCOREBOARD
#include <sys/time.h>
#define NEED_STRERROR
typedef int rlim_t;
-#define memmove(a,b,c) bcopy(b,a,c)
+#ifndef HAVE_MEMMOVE
+#define memmove(a,b,c) memcpy(a, b, c)
+#endif
#define NO_LINGCLOSE
#define USE_FLOCK_SERIALIZED_ACCEPT
#define NO_KILLPG
#undef NO_SETSID
#define HAVE_SYS_RESOURCE_H
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
#define USE_FCNTL_SERIALIZED_ACCEPT
#define HAVE_MMAP
/* These are to let -Wall compile more cleanly */
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *,const char *,unsigned);
-extern int set42sig(), getopt(), getpeername(), bzero();
+extern int set42sig(), getopt(), getpeername();
extern int listen(), bind(), socket(), getsockname();
extern int accept(), gethostname(), connect(), lstat();
extern int select(), killpg(), shutdown();
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
/* A lot of SVR4 systems need this */
#define USE_FCNTL_SERIALIZED_ACCEPT
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
#define HAVE_RESOURCE
#define HAVE_MMAP
#undef NEED_STRDUP
#define NEED_STRCASECMP
#define NEED_STRNCASECMP
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
/* A lot of SVR4 systems need this */
#define USE_FCNTL_SERIALIZED_ACCEPT
#define NO_KILLPG
#undef NO_SETSID
#define HAVE_RESOURCE 1
-#define bzero(a,b) memset(a,0,b)
#define JMP_BUF sigjmp_buf
#define USE_FCNTL_SERIALIZED_ACCEPT
#define HAVE_MMAP
token.startTime = starttime;
token.endTime = endtime;
- bcopy(session_key, (char *) &token.sessionKey, sizeof(token.sessionKey));
+ memcpy((char *) &token.sessionKey, session_key, sizeof(token.sessionKey));
token.kvno = tkt_type;
token.ticketLen = ticket_len;
if (ticket_len > MAXKTCTICKETLEN) {
"Maximum length accepted by AFS cache manager is %d\n", MAXKTCTICKETLEN);
return -1;
}
- bcopy((char *) ticket_p, (char *) token.ticket, ticket_len);
+ memcpy((char *) token.ticket, (char *) ticket_p, ticket_len);
sprintf(client.name, "AFS ID %d", unix_id);
strcpy(client.instance, "");
fprintf(stderr, "dlog: out of memory\n");
exit(1);
}
- bcopy(s_p, new_p, length);
+ memcpy(new_p, s_p, length);
new_p[length] = '\0';
return new_p;
}
case ASN_OCTET_STRING:
if (context == 1 && len == sizeof(reply_p->session_key)) {
saw_session_key++;
- bcopy(buf, reply_p->session_key, len);
+ memcpy(reply_p->session_key, buf, len);
}
buf += len;
break;
des_string_to_key(passwd, passwd_key);
/* Destroy the password. */
- bzero(passwd, strlen(passwd));
+ memset(passwd, 0, strlen(passwd));
/*
/*
* Destroy the key block: it's no longer needed.
*/
- bzero(schedule, sizeof(schedule));
- bzero(passwd_key, sizeof(passwd_key));
+ memset(schedule, 0, sizeof(schedule));
+ memset(passwd_key, 0, sizeof(passwd_key));
/*
char type[10]; /* authentication type AFS or DFS */
/* blow away command line arguments */
- for (i=1; i<zero_argc; i++) bzero (zero_argv[i], strlen(zero_argv[i]));
+ for (i=1; i<zero_argc; i++) memset(zero_argv[i], 0, strlen(zero_argv[i]));
zero_argc = 0;
/* first determine quiet flag based on -silent switch */
case AUD_FID : /* AFSFid - contains 3 entries */
vaFid = (struct AFSFid *) va_arg(vaList, int);
if (vaFid) {
- bcopy(vaFid, bufferPtr, sizeof(struct AFSFid));
+ memcpy(bufferPtr, vaFid, sizeof(struct AFSFid));
}
else {
- bzero (bufferPtr, sizeof(struct AFSFid));
+ memset(bufferPtr, 0, sizeof(struct AFSFid));
}
bufferPtr += sizeof(struct AFSFid);
break;
if (Fids && Fids->AFSCBFids_len) {
*((u_int *)bufferPtr) = Fids->AFSCBFids_len;
bufferPtr += sizeof(u_int);
- bcopy(Fids->AFSCBFids_val, bufferPtr, sizeof(struct AFSFid));
+ memcpy(bufferPtr, Fids->AFSCBFids_val, sizeof(struct AFSFid));
}
else {
struct AFSFid dummy;
*((u_int *)bufferPtr) = 0;
bufferPtr += sizeof(u_int);
- bzero (bufferPtr, sizeof(struct AFSFid));
+ memset(bufferPtr, 0, sizeof(struct AFSFid));
}
bufferPtr += sizeof(struct AFSFid);
break;
LOCK_GLOBAL_MUTEX
/* zero structure and fill in name; rest is done by internal routine */
tdir = (struct afsconf_dir *) malloc(sizeof(struct afsconf_dir));
- bzero(tdir, sizeof(struct afsconf_dir));
+ memset(tdir, 0, sizeof(struct afsconf_dir));
tdir->name = (char *) malloc(strlen(adir)+1);
strcpy(tdir->name, adir);
curEntry = 0;
}
curEntry = (struct afsconf_entry *) malloc(sizeof(struct afsconf_entry));
- bzero(curEntry, sizeof(struct afsconf_entry));
+ memset(curEntry, 0, sizeof(struct afsconf_entry));
code = ParseCellLine(tbuffer, curEntry->cellInfo.name, linkedcell);
if (code) {
afsconf_CloseInternal(adir);
if (adir->keystr) free(adir->keystr);
/* reinit */
- bzero(adir, sizeof(struct afsconf_dir));
+ memset(adir, 0, sizeof(struct afsconf_dir));
adir->name = tname; /* restore it */
return 0;
}
code = afsconf_Check(adir);
if (code)
return AFSCONF_FAILURE;
- bcopy(adir->keystr, astr, sizeof(struct afsconf_keys));
+ memcpy(astr, adir->keystr, sizeof(struct afsconf_keys));
UNLOCK_GLOBAL_MUTEX
return 0;
}
}
}
if (bestk) { /* found any */
- if (akey) bcopy(bestk->key, akey, 8); /* copy out latest key */
+ if (akey) memcpy(akey, bestk->key, 8); /* copy out latest key */
if (avno) *avno = bestk->kvno; /* and kvno to caller */
UNLOCK_GLOBAL_MUTEX
return 0;
for(tk = adir->keystr->key,i=0;i<maxa;i++,tk++) {
if (tk->kvno == avno) {
- bcopy(tk->key, akey, 8);
+ memcpy(akey, tk->key, 8);
UNLOCK_GLOBAL_MUTEX
return 0;
}
register afs_int32 i;
char tbuffer[256];
- bcopy(adir->keystr, &tkeys, sizeof(struct afsconf_keys));
+ memcpy(&tkeys, adir->keystr, sizeof(struct afsconf_keys));
/* convert it to net byte order */
for(i = 0; i<tkeys.nkeys; i++ )
tkey = &tk->key[tk->nkeys++];
}
tkey->kvno = akvno;
- bcopy(akey, tkey->key, 8);
+ memcpy(tkey->key, akey, 8);
i = SaveKeys(adir);
afsconf_Touch(adir);
UNLOCK_GLOBAL_MUTEX
/* otherwise slide the others down. i and tkey point at the guy to delete */
for(;i<tk->nkeys-1; i++,tkey++) {
tkey->kvno = (tkey+1)->kvno;
- bcopy((tkey+1)->key, tkey->key, 8);
+ memcpy(tkey->key, (tkey+1)->key, 8);
}
tk->nkeys--;
i = SaveKeys(adir);
else /* valid, but no match */ ;
} else found = i; /* remember this empty slot */
if (found == -1) return KTC_NOENT;
- bcopy (atoken, &local_tokens[found].token, sizeof(struct ktc_token));
+ memcpy(&local_tokens[found].token, atoken, sizeof(struct ktc_token));
local_tokens[found].server = *aserver;
local_tokens[found].client = *aclient;
local_tokens[found].valid = 1;
tp = tbuffer; /* start copying here */
if ((atoken->ticketLen < MINKTCTICKETLEN) ||
(atoken->ticketLen > MAXKTCTICKETLEN)) return KTC_TOOBIG;
- bcopy(&atoken->ticketLen, tp, sizeof(afs_int32)); /* copy in ticket length */
+ memcpy(tp, &atoken->ticketLen, sizeof(afs_int32)); /* copy in ticket length */
tp += sizeof(afs_int32);
- bcopy(atoken->ticket, tp, atoken->ticketLen); /* copy in ticket */
+ memcpy(tp, atoken->ticket, atoken->ticketLen); /* copy in ticket */
tp += atoken->ticketLen;
/* next, copy in the "clear token", describing who we are */
ct.AuthHandle = atoken->kvno; /* hide auth handle here */
- bcopy(&atoken->sessionKey, ct.HandShakeKey, 8);
+ memcpy(ct.HandShakeKey, &atoken->sessionKey, 8);
ct.BeginTimestamp = atoken->startTime;
ct.EndTimestamp = atoken->endTime;
#endif
temp = sizeof(struct ClearToken);
- bcopy(&temp, tp, sizeof(afs_int32));
+ memcpy(tp, &temp, sizeof(afs_int32));
tp += sizeof(afs_int32);
- bcopy(&ct, tp, sizeof(struct ClearToken));
+ memcpy(tp, &ct, sizeof(struct ClearToken));
tp += sizeof(struct ClearToken);
/* next copy in primary flag */
if (flags & AFS_SETTOK_SETPAG)
temp |= 0x8000;
- bcopy(&temp, tp, sizeof(afs_int32));
+ memcpy(tp, &temp, sizeof(afs_int32));
tp += sizeof(afs_int32);
/* finally copy in the cell name */
(strcmp (local_tokens[i].server.name, aserver->name) == 0) &&
(strcmp (local_tokens[i].server.instance, aserver->instance) == 0) &&
(strcmp (local_tokens[i].server.cell, aserver->cell) == 0)) {
- bcopy (&local_tokens[i].token, atoken, min (atokenLen, sizeof(struct ktc_token)));
+ memcpy (atoken, &local_tokens[i].token, min (atokenLen, sizeof(struct ktc_token)));
if (aclient)
*aclient = local_tokens[i].client;
UNLOCK_GLOBAL_MUTEX
if (aclient)
strcpy(aclient->cell, lcell);
- bcopy(&ctoken, atoken,
+ memcpy(atoken, &ctoken,
min (atokenLen, sizeof(struct ktc_token)));
afs_tf_close();
/* next iterator determined by earlier loop */
*aindex = index+1;
- bcopy(tp, &temp, sizeof(afs_int32)); /* get size of secret token */
+ memcpy(&temp, tp, sizeof(afs_int32)); /* get size of secret token */
tp += sizeof(afs_int32);
tp += temp; /* skip ticket for now */
- bcopy(tp, &temp, sizeof(afs_int32)); /* get size of clear token */
+ memcpy(&temp, tp, sizeof(afs_int32)); /* get size of clear token */
if (temp != sizeof(struct ClearToken)) {
UNLOCK_GLOBAL_MUTEX
return KTC_ERROR;
(void) close(fd);
fd = -1; /* see declaration of fd above */
}
- bzero(tfbfr, sizeof(tfbfr));
+ memset(tfbfr, 0, sizeof(tfbfr));
}
/*
if ((fd = open(file, O_RDWR, 0)) < 0)
goto out; /* can't zero it, but we can still try truncating it */
- bzero(zerobuf, sizeof(zerobuf));
+ memset(zerobuf, 0, sizeof(zerobuf));
for (i = 0; i < sbuf.st_size; i += sizeof(zerobuf))
if (write(fd, zerobuf, sizeof(zerobuf)) != sizeof(zerobuf)) {
if ((fd = open(file, O_RDWR, 0)) < 0)
goto out;
- bzero(buf, BUFSIZ);
+ memset(buf, 0, BUFSIZ);
for (i = 0; i < statb.st_size; i += BUFSIZ)
if (write(fd, buf, BUFSIZ) != BUFSIZ) {
printf(" Ex: setkey add 0 \"80b6a7cd7a9dadb6\"\n");
exit(1);
}
- bzero(tkey, sizeof(tkey));
+ memset(tkey, 0, sizeof(tkey));
for(i=7, cp = argv[3] + 15;i>=0; i--,cp-=2)
tkey[i] = char2hex(*cp) + char2hex(*(cp-1))*16;
char hexbuf[17];
unsigned char c;
int j;
- bcopy(tkeys.key[i].key, tbuffer, 8);
+ memcpy(tbuffer, tkeys.key[i].key, 8);
tbuffer[8] = 0;
for(j=0;j<8;j++) {
c = tbuffer[j];
printf("Cell %s:\n", ainfo->name);
for(i=0;i<ainfo->numServers;i++) {
- bcopy(&ainfo->hostAddr[i].sin_addr, &temp, sizeof(long));
+ memcpy(&temp, &ainfo->hostAddr[i].sin_addr, sizeof(long));
printf(" host %s at %x.%x\n", ainfo->hostName[i], temp, ainfo->hostAddr[i].sin_port);
}
return 0;
printf("Host %s not found in host database...\n", aci->hostName[i]);
return AFSCONF_FAILURE;
}
- bcopy(th->h_addr, &aci->hostAddr[i].sin_addr, sizeof(afs_int32));
+ memcpy(&aci->hostAddr[i].sin_addr, th->h_addr, sizeof(afs_int32));
}
/* otherwise we're deleting this entry */
}
}
if (!tt) {
tt = (struct bnode_type *) malloc(sizeof(struct bnode_type));
- bzero(tt, sizeof(struct bnode_type));
+ memset(tt, 0, sizeof(struct bnode_type));
tt->next = allTypes;
allTypes = tt;
tt->name = atype;
struct bnode **lb, *nb;
/* format the bnode properly */
- bzero(abnode, sizeof(struct bnode));
+ memset(abnode, 0, sizeof(struct bnode));
abnode->ops = abnodeops;
abnode->name = (char *) malloc(strlen(aname)+1);
strcpy(abnode->name, aname);
if (initDone) return 0;
initDone = 1;
- bzero(&bnode_stats, sizeof(bnode_stats));
+ memset(&bnode_stats, 0, sizeof(bnode_stats));
LWP_InitializeProcessSupport(1, &junk); /* just in case */
IOMGR_Initialize();
code = LWP_CreateProcess(bproc, BNODE_LWP_STACKSIZE,
/* priority */ 1, /* parm */0, "bnode-manager", &bproc_pid);
if (code) return code;
- bzero((char *)&newaction, sizeof(newaction));
+ memset((char *)&newaction, 0, sizeof(newaction));
newaction.sa_handler = bnode_Int;
code = sigaction(SIGCHLD, &newaction, NULL);
if (code) return errno;
code = bnode_ParseLine(aexecString, &tlist); /* try parsing first */
if (code) return code;
tp = (struct bnode_proc *) malloc(sizeof(struct bnode_proc));
- bzero(tp, sizeof(struct bnode_proc));
+ memset(tp, 0, sizeof(struct bnode_proc));
tp->next = allProcs;
allProcs = tp;
*aproc = tp;
printf("bos: can't find address for host '%s'\n", hostname);
exit(1);
}
- bcopy(th->h_addr, &addr, sizeof(afs_int32));
+ memcpy(&addr, th->h_addr, sizeof(afs_int32));
/* get tokens for making authenticated connections */
localauth = (as->parms[ADDPARMOFFSET + 2].items != 0);
register char *tp;
strcpy(aresult, adir);
- tp = rindex(aname, '/');
+ tp = strrchr(aname, '/');
if (!tp) {
/* no '/' in name */
strcat(aresult, "/");
char buf[BUFSIZ], ver[BUFSIZ];
tconn = GetConn(as, 1);
- bzero(&tkey, sizeof(struct ktc_encryptionKey));
+ memset(&tkey, 0, sizeof(struct ktc_encryptionKey));
if(as->parms[1].items)
strcpy(buf,as->parms[1].items->data);
char *orphans;
char *tp;
- bzero(&mrafsParm, sizeof(mrafsParm));
+ memset(&mrafsParm, 0, sizeof(mrafsParm));
/* parm 0 is machine name, 1 is partition, 2 is volume, 3 is -all flag */
tconn = GetConn(as, 0);
code = 0; /* assume success */
switch (atype) {
case 1:
- bcopy(&bozo_nextRestartKT, aktime, sizeof(struct ktime));
+ memcpy(aktime, &bozo_nextRestartKT, sizeof(struct ktime));
break;
case 2:
- bcopy(&bozo_nextDayKT, aktime, sizeof(struct ktime));
+ memcpy(aktime, &bozo_nextDayKT, sizeof(struct ktime));
break;
default:
code = 0; /* assume success */
switch (atype) {
case 1:
- bcopy(aktime, &bozo_nextRestartKT, sizeof(struct ktime));
+ memcpy(&bozo_nextRestartKT, aktime, sizeof(struct ktime));
break;
case 2:
- bcopy(aktime, &bozo_nextDayKT, sizeof(struct ktime));
+ memcpy(&bozo_nextDayKT, aktime, sizeof(struct ktime));
break;
default:
goto fail;
}
- bzero(&tcell.hostAddr[which], sizeof(struct sockaddr_in));
- bzero(tcell.hostName[which], MAXHOSTCHARS);
+ memset(&tcell.hostAddr[which], 0, sizeof(struct sockaddr_in));
+ memset(tcell.hostName[which], 0, MAXHOSTCHARS);
code = afsconf_SetCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATH, &tcell);
fail:
}
}
- bzero(&tcell.hostAddr[which], sizeof(struct sockaddr_in));
+ memset(&tcell.hostAddr[which], 0, sizeof(struct sockaddr_in));
strcpy(tcell.hostName[which], aname);
code = afsconf_SetCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATH, &tcell);
goto fail;
}
*akvno = tkeys.key[an].kvno;
- bzero(akeyinfo, sizeof(struct bozo_keyInfo));
+ memset(akeyinfo, 0, sizeof(struct bozo_keyInfo));
noauth = afsconf_GetNoAuthFlag(bozo_confdir);
rxkad_GetServerInfo(acall->conn, &enc_level, 0, 0, 0, 0, 0);
*/
if ((noauth) || (enc_level == rxkad_crypt)) {
- bcopy(tkeys.key[an].key, akey, 8);
+ memcpy(akey, tkeys.key[an].key, 8);
}
- else bzero (akey, 8);
+ else memset(akey, 0, 8);
code = stat(AFSDIR_SERVER_KEY_FILEPATH, &tstat);
if (code == 0) {
strcpy(*atype, tb->type->name);
else
(*atype)[0] = 0; /* null string */
- bzero(astatus, sizeof(struct bozo_status)); /* good defaults */
+ memset(astatus, 0, sizeof(struct bozo_status)); /* good defaults */
astatus->goal = tb->goal;
astatus->fileGoal = tb->fileGoal;
astatus->procStartTime = tb->procStartTime;
bnode_Hold(tb);
if (anum == 999) {
if (tb->notifier) {
- bcopy(tb->notifier, tp, strlen(tb->notifier)+1);
+ memcpy(tp, tb->notifier, strlen(tb->notifier)+1);
code = 0;
} else
code = BZNOENT; /* XXXXX */
bozo_Log("try the 'hostname' command\n");
exit(1);
}
- bzero(tcell.hostAddr, sizeof(tcell.hostAddr)); /* not computed */
+ memset(tcell.hostAddr, 0, sizeof(tcell.hostAddr)); /* not computed */
code = afsconf_SetCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATH, &tcell);
if (code) {
bozo_Log("could not create cell database in '%s' (code %d), quitting\n", AFSDIR_SERVER_ETC_DIRPATH, code);
}
te = (struct cronbnode *) malloc(sizeof(struct cronbnode));
- bzero(te, sizeof(struct cronbnode));
+ memset(te, 0, sizeof(struct cronbnode));
code = ktime_ParsePeriodic(awhen, &te->whenToRun);
if (code < 0) {
free(te);
}
te = (struct ezbnode *) malloc(sizeof(struct ezbnode));
- bzero(te, sizeof(struct ezbnode));
+ memset(te, 0, sizeof(struct ezbnode));
bnode_InitBnode(te, &ezbnode_ops, ainstance);
te->command = cmdpath;
return (struct bnode *) te;
}
te = (struct fsbnode *) malloc(sizeof(struct fsbnode));
- bzero(te, sizeof(struct fsbnode));
+ memset(te, 0, sizeof(struct fsbnode));
te->filecmd = fileCmdpath;
te->volcmd = volCmdpath;
te->salcmd = salCmdpath;
struct sigaction intaction, oldaction;
struct cmd_syndesc *cptr;
- bzero((char *)&intaction, sizeof(intaction));
+ memset((char *)&intaction, 0, sizeof(intaction));
intaction.sa_handler = (int (*)())quitFms;
sigaction(SIGINT, &intaction, &oldaction);
if ( dB_buffer == 0 )
ERROR(-1);
dB_buffersize = reqSize;
- bzero(dB_buffer, dB_buffersize);
+ memset(dB_buffer, 0, dB_buffersize);
}
ptr = (int *) dB_buffer;
*ss = 0;
return(BC_NOMEM);
}
- bzero(*ss, sizeof(struct serversort));
+ memset(*ss, 0, sizeof(struct serversort));
(*ss)->ipaddr = server;
(*ss)->next = *serverlist;
*serverlist = *ss;
*ss = 0;
return(BC_NOMEM);
}
- bzero(*ps, sizeof(struct partitionsort));
+ memset(*ps, 0, sizeof(struct partitionsort));
(*ps)->part = partition;
(*ps)->next = (*ss)->partitions;
(*ss)->partitions = *ps;
com_err(whoami, BC_NOMEM, "");
ERROR(BC_NOMEM);
}
- bzero(tvd, sizeof(*tvd));
+ memset(tvd, 0, sizeof(*tvd));
tvd->name = (char *) malloc(strlen(entries[e].name)+10);
if (!(tvd->name)) {
*/
for (index=0; 1; index=next_index)
{ /*w*/
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
code = ubik_Call(VL_ListEntry, /*Routine to invoke*/
uclient, /*Ubik client structure*/
0, /*Ubik flags*/
com_err(whoami, BC_NOMEM,"");
return(BC_NOMEM);
}
- bzero(tvd, sizeof(*tvd));
+ memset(tvd, 0, sizeof(*tvd));
tvd->name = (char *) malloc(strlen(entry.name)+10);
if (!(tvd->name))
tp = as->parms[0].items->data;
- if (index(tp, '.') == 0)
+ if (strchr(tp, '.') == 0)
{
slot = bc_SafeATOI(tp);
if (slot == -1)
com_err(whoami,BC_NOMEM,"");
return BC_NOMEM;
}
- bzero(tvol, sizeof(struct bc_volumeDump));
+ memset(tvol, 0, sizeof(struct bc_volumeDump));
tvol->name = (char *) malloc(VOLSER_MAXVOLNAME +1);
if (!tvol->name)
}
/* create a volume set corresponding to the volume pattern we've been given */
- bzero(&tvolumeSet, sizeof(tvolumeSet));
- bzero(&tvolumeEntry, sizeof(tvolumeEntry));
+ memset(&tvolumeSet, 0, sizeof(tvolumeSet));
+ memset(&tvolumeEntry, 0, sizeof(tvolumeEntry));
tvolumeSet.name = "TempVolumeSet";
tvolumeSet.ventries = &tvolumeEntry;
tvolumeEntry.serverName = as->parms[0].items->data;
}
}
else /* use destination host == original host */
- bcopy(&tvolumeEntry.server, &destServ, sizeof(destServ));
+ memcpy(&destServ, &tvolumeEntry.server, sizeof(destServ));
/* specified other destination partition */
if (as->parms[9].items)
/* Allocate a volumeDump structure and link it in */
tvol = (struct bc_volumeDump *) malloc(sizeof(struct bc_volumeDump));
- bzero(tvol, sizeof(struct bc_volumeDump));
+ memset(tvol, 0, sizeof(struct bc_volumeDump));
tvol->name = (char *) malloc(VOLSER_MAXVOLNAME+1);
if (!tvol->name)
return BC_NOMEM;
}
strncpy(tvol->name, volume, VOLSER_OLDMAXVOLNAME);
- bcopy(&destServer, &tvol->server, sizeof(destServer));
+ memcpy(&tvol->server, &destServer, sizeof(destServer));
tvol->partition = destPartition;
if (lastVol) lastVol->next = tvol; /* thread onto end of list */
if (parent) problemFindingDump = 1;
parent = dumpEntry.id;
level = dumpEntry.level+1;
- bcopy(&dumpEntry, &fde, sizeof(dumpEntry));
+ memcpy(&fde, &dumpEntry, sizeof(dumpEntry));
}
else {
/* Dump hierarchy not complete so can't base off the latest */
tempPtr = (struct dumpedVol *) malloc(sizeof(struct dumpedVol));
if (!tempPtr) ERROR(BC_NOMEM);
- bzero(tempPtr, sizeof(*tempPtr));
+ memset(tempPtr, 0, sizeof(*tempPtr));
tempPtr->incTime = volumeEntry[i].clone;
tempPtr->dumpID = volumeEntry[i].dump;
strncpy(tempPtr->tapeName, volumeEntry[i].tape, BU_MAXTAPELEN);
ERROR(BC_NOMEM);
}
- bzero(tapeLinkPtr, sizeof(*tapeLinkPtr));
+ memset(tapeLinkPtr, 0, sizeof(*tapeLinkPtr));
code = bcdb_FindTapeSeq(dumpid, tapeNumber, &tapeLinkPtr->tapeEntry);
if (code)
{
com_err(whoami,BC_NOMEM,"");
ERROR(BC_NOMEM);
}
- bzero(volumeLinkPtr, sizeof(*volumeLinkPtr));
+ memset(volumeLinkPtr, 0, sizeof(*volumeLinkPtr));
- bcopy(&vl.budb_volumeList_val[i], &volumeLinkPtr->volumeEntry,
- sizeof(struct budb_volumeEntry));
+ memcpy(&volumeLinkPtr->volumeEntry, &vl.budb_volumeList_val[i], sizeof(struct budb_volumeEntry));
/* now insert it onto the right place */
while ( (*link != 0) &&
if (!tb) return(BC_NOMEM);
bc_globalConfig = tb;
- bzero(tb, sizeof(struct bc_config));
+ memset(tb, 0, sizeof(struct bc_config));
tb->path = (char *) malloc(strlen(apath)+1);
if (!tb->path)
{
/* tlast now points to the next pointer (or head pointer) we should overwrite */
tentry = (struct bc_hostEntry *) malloc(sizeof(struct bc_hostEntry));
- bzero(tentry, sizeof(*tentry));
+ memset(tentry, 0, sizeof(*tentry));
tentry->name = (char *) malloc(strlen(aname)+1);
strcpy(tentry->name, aname);
*tlast = tentry;
tentry->next = (struct bc_hostEntry *) 0;
tentry->addr.sin_family = AF_INET;
- bcopy(th->h_addr, &tentry->addr.sin_addr.s_addr, sizeof(afs_int32));
+ memcpy(&tentry->addr.sin_addr.s_addr, th->h_addr, sizeof(afs_int32));
tentry->addr.sin_port = 0;
tentry->portOffset = aport;
return 0;
char *pathNamePtr;
{
char *ptr;
- ptr = rindex(pathNamePtr, '/');
+ ptr = strrchr(pathNamePtr, '/');
if ( ptr == 0 )
{
/* this should never happen */
asockaddr->sin_family = AF_INET;
asockaddr->sin_port = 0;
addr = (b1<<24) | (b2<<16) | (b3<<8) | b4;
- bcopy(&addr,&tmp1,sizeof(afs_int32));
+ memcpy(&tmp1, &addr, sizeof(afs_int32));
tmp2 = htonl(tmp1);
- bcopy(&tmp2, &asockaddr->sin_addr.s_addr, sizeof(afs_int32));
+ memcpy(&asockaddr->sin_addr.s_addr, &tmp2, sizeof(afs_int32));
return(0);
}
*/
if (strcmp(aname, ".*") == 0) {
- bzero(asockaddr, sizeof(struct sockaddr_in));
+ memset(asockaddr, 0, sizeof(struct sockaddr_in));
return 0;
}
*/
asockaddr->sin_family = AF_INET;
asockaddr->sin_port = 0;
- bcopy(th->h_addr,&tmp1,sizeof(afs_int32));
+ memcpy(&tmp1, th->h_addr, sizeof(afs_int32));
tmp2 = htonl(tmp1);
- bcopy(&tmp2,&(asockaddr->sin_addr.s_addr),
- sizeof(asockaddr->sin_addr.s_addr));
+ memcpy(&(asockaddr->sin_addr.s_addr), &tmp2, sizeof(asockaddr->sin_addr.s_addr));
return(0);
} /*bc_ParseHost*/
/* move to end of the list */
nset = (struct bc_volumeSet *) malloc(sizeof(struct bc_volumeSet));
- bzero(nset, sizeof(*nset));
+ memset(nset, 0, sizeof(*nset));
nset->flags = aflags;
nset->name = (char *) malloc(strlen(avolName)+1);
strcpy(nset->name, avolName);
/* move to end of the list */
for(tentry = *tlast; tentry; tlast = &tentry->next, tentry = *tlast);
tentry = (struct bc_volumeEntry *) malloc(sizeof(struct bc_volumeEntry));
- bzero(tentry, sizeof(*tentry));
+ memset(tentry, 0, sizeof(*tentry));
tentry->serverName = (char *) malloc(strlen(ahost)+1);
strcpy(tentry->serverName, ahost);
tentry->partname = (char *) malloc(strlen(apart)+1);
return -2; /* name specification error */
tdump = (struct bc_dumpSchedule *) malloc(sizeof(struct bc_dumpSchedule));
- bzero(tdump, sizeof(*tdump));
+ memset(tdump, 0, sizeof(*tdump));
/* prepend this node to the dump schedule list */
tdump->next = aconfig->dsched;
matchLength = 0;
curptr = &nodeString[1]; /* past first / */
- separator = index(curptr, '/');
+ separator = strchr(curptr, '/');
if ( separator == 0 )
matchLength = strlen(curptr) + 1; /* +1 for leading / */
else
return(-3);
}
- separator = index(curptr, '/');
+ separator = strchr(curptr, '/');
if ( separator == 0 )
matchLength = strlen(&nodeString[0]);
else
baseNamePtr = tailCompPtr(dumpTaskPtr->dumpName);
/* setup the interface structure */
- bzero(tcdiPtr, sizeof(*tcdiPtr));
+ memset(tcdiPtr, 0, sizeof(*tcdiPtr));
/* general */
strcpy(tcdiPtr->dumpPath, dumpTaskPtr->dumpName);
return(BC_NOTLOCKED);
}
- bzero(&bc_dumpTasks[i], sizeof(struct bc_dumpTask));
+ memset(&bc_dumpTasks[i], 0, sizeof(struct bc_dumpTask));
bc_dumpTasks[i].callProc = aproc;
bc_dumpTasks[i].config = aconfig;
bc_dumpTasks[i].volumes = avolsToDump;
bc_dumpTasks[i].expType = dsptr->expType;
}
if (adestServer)
- bcopy(adestServer, &bc_dumpTasks[i].destServer, sizeof(struct sockaddr_in));
+ memcpy(&bc_dumpTasks[i].destServer, adestServer, sizeof(struct sockaddr_in));
else
- bzero(&bc_dumpTasks[i].destServer, sizeof(struct sockaddr_in));
+ memset(&bc_dumpTasks[i].destServer, 0, sizeof(struct sockaddr_in));
code = LWP_CreateProcess(bc_DmpRstStart, 20480, LWP_NORMAL_PRIORITY, i, "helper", &junk);
if (code)
code = ConnectButc(config, port, &tconn);
if (code) return(code);
- bzero(&label,sizeof(label));
+ memset(&label, 0, sizeof(label));
if (afsname)
strcpy(label.afsname, afsname);
if (pname)
code = ConnectButc(config, port, &tconn);
if (code) return(code);
- bzero(&label,sizeof(label));
+ memset(&label, 0, sizeof(label));
code = TC_ReadLabel(tconn, &label, &taskId);
if (code) {
if (code == BUTM_NOLABEL) {
return (BC_INTERNALERROR);
}
tds = (struct bc_dumpSchedule *)malloc(sizeof(struct bc_dumpSchedule));
- bzero(tds, sizeof(*tds));
+ memset(tds, 0, sizeof(*tds));
tds->next = (struct bc_dumpSchedule *) 0;
tds->name = (char *) malloc(strlen(dsname)+1);
afs_int32 longDate;
struct ktime_date *kdptr;
{
- bzero(kdptr, sizeof(*kdptr));
+ memset(kdptr, 0, sizeof(*kdptr));
kdptr->day = longDate % (MAX_DAY_VALUE + 1);
if ( kdptr->day != 0 )
afs_int32 value, digit_limit;
afs_int32 type_index;
- bzero(relDatePtr, sizeof(*relDatePtr));
+ memset(relDatePtr, 0, sizeof(*relDatePtr));
type_index = 0;
while ( 1 )
for ( i = 0; i < TB_NUM; i++ )
{
- bzero(ctPtr, sizeof(*ctPtr));
+ memset(ctPtr, 0, sizeof(*ctPtr));
ctPtr->textType = i;
ctPtr->textVersion = -1;
ctPtr++;
extern char *whoami;
extern struct rx_connection *bc_GetConn();
-#ifdef AFS_SGI64_ENV
-extern char *rindex();
-#endif
-
#define BC_MAXLEVELS 20
#define MAXTAPESATONCE 10
{
char *sptr;
- sptr = rindex(tapename, '.');
+ sptr = strrchr(tapename, '.');
if ( !sptr ) return(-1);
sptr++;
return(atol(sptr));
com_err(whoami,BC_NOMEM,"");
ERROR(BC_NOMEM);
}
- bzero (di, sizeof(struct dumpinfo));
+ memset(di, 0, sizeof(struct dumpinfo));
di->DumpId = dumpDescr->id;
di->initialDumpId = dumpDescr->initialDumpID;
com_err(whoami,BC_NOMEM,"");
ERROR(BC_NOMEM);
}
- bzero (vi, sizeof(struct volinfo));
+ memset(vi, 0, sizeof(struct volinfo));
vi->volname = (char*)malloc(strlen(vname)+1);
if (!vi->volname)
for (di=dumpinfolist; di; di=di->next)
{
/* Find each of the parent dumps */
- bcopy(di, &dlevels[0], sizeof(struct dumpinfo));
+ memcpy(&dlevels[0], di, sizeof(struct dumpinfo));
for (lvl=1, parent=dlevels[0].parentDumpId; parent;
parent=dlevels[lvl].parentDumpId, lvl++)
{
com_err(whoami,BC_NOMEM,"");
return(BC_NOMEM);
}
- bzero(tle, sizeof(struct bc_tapeList));
+ memset(tle, 0, sizeof(struct bc_tapeList));
tle->tapeName = (char*)malloc(strlen(volumeEntries[ve].tape)+1);
if (!tle->tapeName)
com_err(whoami,BC_NOMEM,"");
return(BC_NOMEM);
}
- bzero(ti, sizeof(struct bc_tapeItem));
+ memset(ti, 0, sizeof(struct bc_tapeItem));
ti->volumeName = (char*)malloc(strlen(volumeEntries[ve].name)+1);
if (!ti->volumeName)
com_err(whoami,BC_NOMEM,"");
ERROR(BC_NOMEM);
}
- bzero(tcarray, nentries*sizeof(struct tc_restoreDesc));
+ memset(tcarray, 0, nentries*sizeof(struct tc_restoreDesc));
/* Fill in the array with the list above */
i = 0;
{
return(0);
}
- bzero(ptr, sizeof(*ptr));
+ memset(ptr, 0, sizeof(*ptr));
/* link it onto the chain of status entries */
ObtainWriteLock(&statusQueueLock);
the = (struct bc_hostEntry *) malloc(sizeof(struct bc_hostEntry));
if (the == (struct bc_hostEntry *)0)
return (BC_NOMEM);
- bzero(the, sizeof(struct bc_hostEntry));
+ memset(the, 0, sizeof(struct bc_hostEntry));
if (tlast)
{
tlast->next = the;
strcpy(the->name, hostName);
the->portOffset = port;
if (th) {
- bcopy(th->h_addr, &the->addr.sin_addr.s_addr, 4);
+ memcpy(&the->addr.sin_addr.s_addr, th->h_addr, 4);
the->addr.sin_family = AF_INET;
the->addr.sin_port = 0;
}
printf("tape controller received request to start dump %s.\n", adumpName);
*adumpID = ++transID; /* send result back to caller */
- bzero(&tdentry, sizeof(tdentry));
+ memset(&tdentry, 0, sizeof(tdentry));
tdentry.created = time(0);
strcpy(tdentry.name, atapeSet->format);
strcat(tdentry.name, ".");
printf("created dump %d\n", tdentry.id);
/* start tape (preent all fits on one tape at first */
- bzero(&ttentry, sizeof(ttentry));
+ memset(&ttentry, 0, sizeof(ttentry));
sprintf(ttentry.name, tdentry.tapes.format, 1);
ttentry.written = time(0);
ttentry.dump = tdentry.id; /* dump we're in */
tdescr = adumpArray->tc_dumpArray_val;
for(i=0;i<adumpArray->tc_dumpArray_len;i++, tdescr++) {
- bcopy(tdescr->hostID, &taddr, sizeof(taddr));
+ memcpy(&taddr, tdescr->hostID, sizeof(taddr));
printf("dumping volid %s(%d) from host %08x since date %d\n", tdescr->name,
tdescr->vid, taddr.sin_addr.s_addr, tdescr->date);
- bzero(&tventry, sizeof(tventry));
+ memset(&tventry, 0, sizeof(tventry));
strcpy(tventry.name, tdescr->name);
tventry.clone = tdescr->date;
tventry.seq = 0; /* frag in volume */
printf("tape controller received request to start restore %s.\n", aname);
tdescr = arestore->tc_restoreArray_val;
for(i=0;i<arestore->tc_restoreArray_len; i++, tdescr++) {
- bcopy(tdescr->hostID, &taddr, sizeof(taddr));
+ memcpy(&taddr, tdescr->hostID, sizeof(taddr));
printf("restoring frag %d of volume %s from tape %s at position %d.\n New name is '%s', new vid is %d, new host is %08x, new partition is %d\n",
tdescr->frag, tdescr->oldName, tdescr->tapeName, tdescr->position, tdescr->newName,
tdescr->vid, taddr.sin_addr.s_addr, tdescr->partition);
goto error;
}
- bcopy(dl.budb_dumpList_val, deptr, sizeof(*deptr));
+ memcpy(deptr, dl.budb_dumpList_val, sizeof(*deptr));
exit:
if ( dl.budb_dumpList_val )
return(code);
error:
- bzero(deptr, sizeof(*deptr));
+ memset(deptr, 0, sizeof(*deptr));
goto exit;
}
afs_int32 dbTime;
afs_int32 code = 0;
- bzero(teptr, sizeof(*teptr));
+ memset(teptr, 0, sizeof(*teptr));
tl.budb_tapeList_len = 0;
tl.budb_tapeList_val = 0;
if (tl.budb_tapeList_len != 1)
ERROR(BC_NOTUNIQUE); /* expecting a single descriptor */
- bcopy(tl.budb_tapeList_val, teptr, sizeof(*teptr));
+ memcpy(teptr, tl.budb_tapeList_val, sizeof(*teptr));
error_exit:
if ( tl.budb_tapeList_val )
afs_int32 dbTime;
afs_int32 code = 0;
- bzero(teptr, sizeof(*teptr));
+ memset(teptr, 0, sizeof(*teptr));
tl.budb_tapeList_len = 0;
tl.budb_tapeList_val = 0;
if (tl.budb_tapeList_len != 1)
ERROR(BC_NOTUNIQUE); /* expecting a single descriptor */
- bcopy(tl.budb_tapeList_val, teptr, sizeof(*teptr));
+ memcpy(teptr, tl.budb_tapeList_val, sizeof(*teptr));
error_exit:
if ( tl.budb_tapeList_val )
if ( code )
{
/* error. Clean up single server state */
- bzero(&uServer, sizeof(uServer));
+ memset(&uServer, 0, sizeof(uServer));
}
return(code);
}
else
if ( (aflags & UF_END_SINGLESERVER) != 0 )
{
- bzero(&uServer, sizeof(uServer));
+ memset(&uServer, 0, sizeof(uServer));
return(0);
}
}
* global configuration structure.
*/
tvs = (struct bc_volumeSet *) malloc(sizeof(struct bc_volumeSet));
- bzero(tvs, sizeof(*tvs));
+ memset(tvs, 0, sizeof(*tvs));
tvs->name = (char *) malloc(strlen(vsname)+1);
strcpy(tvs->name, vsname);
com_err(whoami,0, "Can't malloc() a new volume spec record!");
return(-1);
}
- bzero(tve, sizeof(*tve));
+ memset(tve, 0, sizeof(*tve));
if (bc_ParseHost(serverName, &(tve->server)))
com_err(whoami,0, "Can't get required info on host '%s'", serverName);
pollCount = 0;
- bzero (&db, sizeof(db));
+ memset(&db, 0, sizeof(db));
Lock_Init (&db.lock);
if ((code = InitDBalloc ()) || (code = InitDBhash ()))
return code;
LogDebug(0, "No data base - Building new one\n");
/* try to write a good header */
- bzero(&db.h,sizeof(db.h));
+ memset(&db.h, 0, sizeof(db.h));
db.h.version = htonl(BUDB_VERSION);
db.h.checkVersion = htonl(BUDB_VERSION);
db.h.lastUpdate = db.h.lastDumpId = htonl(time(0));
}
/* clear and return the block */
- bzero (block, sizeof(*block));
+ memset(block, 0, sizeof(*block));
*aP = a;
return 0;
}
dbadr a; /* db address of block */
{
if (a != BlockBase(a)) db_panic ("Block addr no good");
- bzero (bh, sizeof(*bh));
+ memset(bh, 0, sizeof(*bh));
bh->next = db.h.freePtrs[0];
if (set_header_word (ut, freePtrs[0], htonl(a)) ||
dbwrite (ut, a, (char *)bh, sizeof(*bh))) return BUDB_IO;
/* Read the dump entry */
if (dbAddr == dbAppAddr) {
/* First time through, don't need to read the dump entry again */
- bcopy(&diskDump, &apDiskDump, sizeof(diskDump));
+ memcpy(&apDiskDump, &diskDump, sizeof(diskDump));
}
else {
if (badEntry(dbAppAddr)) {
mht->size = nb*sizeof(struct memoryHTBlock *);
b = mht->blocks = (struct memoryHTBlock **)malloc (mht->size);
- bzero (b, mht->size);
+ memset(b, 0, mht->size);
for (i=0; i<nb; i++) {
b[i] = (struct memoryHTBlock *)malloc (sizeof (struct memoryHTBlock));
if (*blocksP == 0) {
*sizeP = ht_TableSize (length);
*blocksP = (struct memoryHTBlock **)malloc (*sizeP);
- bzero (*blocksP, *sizeP);
+ memset(*blocksP, 0, *sizeP);
}
n = *sizeP / sizeof (struct memoryHTBlock *);
if (bi >= n) db_panic ("table size inconsistent");
textRemaining = BLOCK_DATA_SIZE - blockOffset;
chunkSize = min(textRemaining, transferSize);
- bcopy(&block.a[blockOffset], textPtr, chunkSize);
+ memcpy(textPtr, &block.a[blockOffset], chunkSize);
/* LogDebug(5, "transfering %d bytes: %s\n", chunkSize, textPtr); */
chunkSize = MIN(remainingInBlock, textLength);
/* copy in the data */
- bcopy(textptr, &diskBlock.a[offset % BLOCK_DATA_SIZE], chunkSize);
+ memcpy(&diskBlock.a[offset % BLOCK_DATA_SIZE], textptr, chunkSize);
/* LogDebug(5, "text is %s\n", textptr); */
LogDebug(5, "Setup dump\n");
/* no dump in progress - setup and retake lock */
- bzero(dumpSyncPtr, sizeof(*dumpSyncPtr));
+ memset(dumpSyncPtr, 0, sizeof(*dumpSyncPtr));
/* ObtainWriteLock(&dumpSyncPtr->ds_lock); */
/* mark dump in progress */
if (code) LogError(code, "Aborting dump transaction\n");
}
- bzero(dumpSyncPtr, sizeof(*dumpSyncPtr));
+ memset(dumpSyncPtr, 0, sizeof(*dumpSyncPtr));
goto exit;
} /*i*/
bmsize = sizeof(*ablockMap) + (blockEntries[blocktype]-1) * sizeof(ablockMap->entries[0]);
ablockMap = (struct blockMap *) malloc(bmsize);
if (!ablockMap) ERROR(BUDB_NOMEM);
- bzero(ablockMap, bmsize);
+ memset(ablockMap, 0, bmsize);
ablockMap->nEntries = blockEntries[blocktype];
/* save the block header in the block map */
- bcopy(&block.h, &ablockMap->header, sizeof(ablockMap->header));
+ memcpy(&ablockMap->header, &block.h, sizeof(ablockMap->header));
blockMap[i] = ablockMap;
}
/* clear verification statistics */
misc = &miscData;
- bzero (&miscData, sizeof(miscData));
+ memset(&miscData, 0, sizeof(miscData));
#ifdef PDEBUG
miscData.maxErrors = 1000000;
bmsize = nBlocks*sizeof(struct blockMap *);
blockMap = (struct blockMap **) malloc(bmsize);
if (!blockMap) ERROR(BUDB_NOMEM);
- bzero(blockMap, bmsize);
+ memset(blockMap, 0, bmsize);
/* verify blocks and construct the block map */
Log("Read header of every block\n");
if (!th) *host = 0;
else
{
- bcopy(th->h_addr, host, sizeof(afs_int32));
+ memcpy(host, th->h_addr, sizeof(afs_int32));
*host = ntohl(*host);
}
char *pathNamePtr;
{
char *ptr;
- ptr = rindex(pathNamePtr, '/');
+ ptr = strrchr(pathNamePtr, '/');
if ( ptr == 0 )
{
/* this should never happen */
eList->budb_dumpList_val = (struct budb_dumpEntry *)malloc (e_size * to_return);
if (!eList->budb_dumpList_val) return(BUDB_NOMEM);
}
- bzero(eList->budb_dumpList_val, e_size * to_return);
+ memset(eList->budb_dumpList_val, 0, e_size * to_return);
eList->budb_dumpList_len = to_return;
e = (char *)(eList->budb_dumpList_val);
else if ( !VolInfoMatch(volP,viP) ) /* Not the head volinfo struct */
{
hvia = via; /* remember the head volinfo struct */
- bcopy(viP, &hvi, sizeof(hvi));
+ memcpy(&hvi, viP, sizeof(hvi));
/* Search the same name chain for the correct volinfo structure */
for (via=ntohl(viP->sameNameChain); via; via=ntohl(viP->sameNameChain))
ptr = (struct chosenDump *) malloc(sizeof(*ptr));
if (!ptr)
return(0);
- bzero(ptr, sizeof(*ptr));
+ memset(ptr, 0, sizeof(*ptr));
ptr->addr = dumpAddr;
ptr->date = (afs_uint32) ntohl(dumpPtr->created);
}
/* Allocate a dump structure */
- bzero (&d, sizeof(d));
+ memset(&d, 0, sizeof(d));
eval = AllocStructure (ut, dump_BLOCK, 0, &da, &d);
if (eval) ABORT(eval);
/* Construct a database dump name */
strcpy(dumpName, DUMP_TAPE_NAME);
}
- else if (index(dumpPath,'/') == 0) {
+ else if (strchr(dumpPath,'/') == 0) {
int level, old, length, hash;
struct dump hostDump, diskDump;
struct memoryHashTable *mht;
/* end specifies how many dumps */
if (!end) ABORT(BUDB_BADFLAGS);
- bzero(&rock, sizeof(rock));
+ memset(&rock, 0, sizeof(rock));
rock.maxDumps = end;
scanHashTable(ut, &db.dumpName, wantDump, rememberDump, (char *) &rock);
/* Zero volume entry if the last tape has no volumes */
if (!lastVol) {
- bzero(volEntry, sizeof(*volEntry));
+ memset(volEntry, 0, sizeof(*volEntry));
} else {
/* Follow the volumes until we reach the last volume */
eval = dbread (ut,lastVol,&vf,sizeof(vf));
*new = 0;
- bzero (&t, sizeof(t));
+ memset(&t, 0, sizeof(t));
eval = AllocStructure (ut, tape_BLOCK, 0, &a, &t);
if (eval) ABORT(eval);
printf("prserver: couldn't get address of this host.\n");
BUDB_EXIT(1);
}
- bcopy(th->h_addr,myHost,sizeof(afs_int32));
+ memcpy(myHost, th->h_addr, sizeof(afs_int32));
for (i=0; i<cellinfo->numServers; i++)
/* omit my host from serverList */
exit(2);
}
- bzero(globalConfPtr, sizeof(*globalConfPtr));
+ memset(globalConfPtr, 0, sizeof(*globalConfPtr));
/* set default configuration values */
strcpy(dbDir, AFSDIR_SERVER_DB_DIRPATH);
/* misc. initialization */
/* database dump synchronization */
- bzero(dumpSyncPtr, sizeof(*dumpSyncPtr));
+ memset(dumpSyncPtr, 0, sizeof(*dumpSyncPtr));
Lock_Init(&dumpSyncPtr->ds_lock);
rx_StartServer(0); /* start handling requests */
budbDumpPtr->created = dumpPtr->created;
budbDumpPtr->nVolumes = dumpPtr->nVolumes;
- bcopy(&dumpPtr->tapes, &budbDumpPtr->tapes, sizeof(struct budb_tapeSet));
+ memcpy(&budbDumpPtr->tapes, &dumpPtr->tapes, sizeof(struct budb_tapeSet));
copy_ktcPrincipal_to_budbPrincipal(&dumpPtr->dumper, &budbDumpPtr->dumper);
return(0);
}
struct budb_tapeSet *tapesetPtr;
char *dumpname;
{
- bzero(tapesetPtr, sizeof(*tapesetPtr));
+ memset(tapesetPtr, 0, sizeof(*tapesetPtr));
strcpy(tapesetPtr->format, dumpname);
strcat(tapesetPtr->format, ".%d");
entryPtr->dlq_type = type;
entryPtr->dlq_structPtr = entry;
- bcopy (anEntry, entry, size);
+ memcpy(entry, anEntry, size);
dlqLinkb (&entries_to_flush, entryPtr);
return(0);
}
entryPtr->dlq_type = type;
entryPtr->dlq_structPtr = entry;
- bcopy (anEntry, entry, size);
+ memcpy(entry, anEntry, size);
dlqLinkb (&savedEntries, (dlqlinkP)entryPtr);
return(0);
}
{
afs_int32 code = 0;
- bzero(aTapeEntryPtr, sizeof(struct budb_tapeEntry));
+ memset(aTapeEntryPtr, 0, sizeof(struct budb_tapeEntry));
strcpy(aTapeEntryPtr->name, tapename);
aTapeEntryPtr->flags = BUDB_TAPE_BEINGWRITTEN;
aTapeEntryPtr->written = written; /* When label was written */
allo = 1;
}
- bzero(aVolEntryPtr, sizeof(struct budb_volumeEntry));
+ memset(aVolEntryPtr, 0, sizeof(struct budb_volumeEntry));
strcpy(aVolEntryPtr->name, volname);
aVolEntryPtr->flags = flags;
aVolEntryPtr->id = volid;
break;
}
- bcopy(volPtr, &volumes[c], sizeof(struct budb_volumeEntry));
+ memcpy(&volumes[c], volPtr, sizeof(struct budb_volumeEntry));
free(volPtr);
free(entryPtr);
entryPtr = (dlqlinkP)0;
time_t *t;
struct tm *tm;
{
- bcopy(localtime(t), tm, sizeof(struct tm));
+ memcpy(tm, localtime(t), sizeof(struct tm));
}
#endif
}
/* Remember the server and partition the volume exists on */
- bzero (&server, sizeof(server));
+ memset(&server, 0, sizeof(server));
server.sin_addr.s_addr = vldbEntry.serverNumber[e];
server.sin_port = 0;
server.sin_family = AF_INET;
TapeLog(2, taskId, 0, 0, "Dump %s\n", nodePtr->dumpSetName);
/* setup the dump parameters */
- bzero(&dparams, sizeof(dparams));
+ memset(&dparams, 0, sizeof(dparams));
dparams.node = nodePtr;
dparams.tapeInfoPtr = &tapeInfo;
dlqInit(&savedEntries);
ErrorLog(0, taskId, code, 0, "Can't read backup database\n");
ERROR_EXIT(code);
}
- bzero(&dparams.lastDump, sizeof(dparams.lastDump));
+ memset(&dparams.lastDump, 0, sizeof(dparams.lastDump));
}
code = createDump(&dparams); /* enter dump into database */
ErrorLog(0, taskId, code, tapeInfoPtr->error,
"Warning: Tape error while reading label (will proceed with dump)\n");
}
- bzero(&oldTapeLabel, sizeof(oldTapeLabel));
+ memset(&oldTapeLabel, 0, sizeof(oldTapeLabel));
}
/* Check if null tape. Prior 3.3, backup tapes have no dump id */
*/
for (dmp=oldTapeLabel.dumpid; dmp; dmp=de.appendedDumpID) {
if (dmp == dparamsPtr->lastDump.id) {
- bcopy(&dparamsPtr->lastDump, &de, sizeof(de));
- bcopy(&dparamsPtr->lastDump, &de2, sizeof(de2));
+ memcpy(&de, &dparamsPtr->lastDump, sizeof(de));
+ memcpy(&de2, &dparamsPtr->lastDump, sizeof(de2));
}
else {
code = bcdb_FindDumpByID(dmp, &de);
curDump = &nodePtr->dumps[dparamsPtr->curVolume];
- bzero(vhptr, sizeof(*vhptr));
+ memset(vhptr, 0, sizeof(*vhptr));
strcpy(vhptr->volumeName, curDump->name);
vhptr->volumeID = curDump->vid;
vhptr->cloneDate = curDump->cloneDate;
volHdr.versionflags = htonl(hostPtr->versionflags);
volHdr.cloneDate = htonl(hostPtr->cloneDate);
- bcopy(&volHdr, netPtr, sizeof(struct volumeHeader));
+ memcpy(netPtr, &volHdr, sizeof(struct volumeHeader));
}
/* database related routines */
afs_int32 code = 0;
dumpPtr = &dparamsPtr->dump;
- bzero(dumpPtr, sizeof(*dumpPtr));
+ memset(dumpPtr, 0, sizeof(*dumpPtr));
/* id filled in by database */
dumpPtr->parent = nodePtr->parent;
/* get space */
*newNode = (struct dumpNode *) (malloc (sizeof (struct dumpNode)));
- bzero(*newNode, sizeof(struct dumpNode));
+ memset(*newNode, 0, sizeof(struct dumpNode));
(*newNode)->next = dumpQHeader->next;
dumpQHeader->next = *newNode;
magic == TC_VOLENDMAGIC || \
magic == TC_VOLCONTD ) { \
\
- bcopy (&vhptr, header, sizeof(struct volumeHeader)); \
+ memcpy(header, &vhptr, sizeof(struct volumeHeader)); \
return (0); \
} /* magic */ \
} /* versionflags */ \
{
case TAPE_VERSION_0:
/* sizes in bytes and fields in host order */
- bcopy(hostVolHeader, tapeVolHeader, sizeof(struct volumeHeader));
+ memcpy(tapeVolHeader, hostVolHeader, sizeof(struct volumeHeader));
break;
case TAPE_VERSION_1:
}
/* fill tbuffer with end of buffer */
bytesRead -= sizeof(tbuffer);
- bcopy(buffer+bytesRead, tbuffer, sizeof(tbuffer));
+ memcpy(tbuffer, buffer+bytesRead, sizeof(tbuffer));
tbuffersize = sizeof(tbuffer);
/* Write out whatever is left over in buffer */
if (bytesRead) {
}
else if ((tbuffersize + bytesRead) <= sizeof(tbuffer)) {
/* Copy all of buffer into tbuffer (it will fit) */
- bcopy(buffer, tbuffer+tbuffersize, bytesRead);
+ memcpy(tbuffer+tbuffersize, buffer, bytesRead);
tbuffersize += bytesRead;
bytesRead = 0;
}
tbuffersize -= w;
/* Move the data in tbuffer up */
- bcopy(tbuffer+towrite, tbuffer, tbuffersize);
+ memcpy(tbuffer, tbuffer+towrite, tbuffersize);
/* Now copy buffer in */
- bcopy(buffer, tbuffer+tbuffersize, bytesRead);
+ memcpy(tbuffer+tbuffersize, buffer, bytesRead);
tbuffersize += bytesRead;
bytesRead = 0;
}
printf("\n\n");
TLog (taskId, "Restore\n");
- bzero(&tapeInfo, sizeof(tapeInfo));
+ memset(&tapeInfo, 0, sizeof(tapeInfo));
if (!CONF_XBSA) {
tapeInfo.structVersion = BUTM_MAJORVERSION;
tcode = butm_file_Instantiate (&tapeInfo, &globalTapeConfig);
if ( checkAbortByTaskId(taskId) ) ERROR_EXIT(TC_ABORTEDBYREQUEST);
- bzero(&rparams, sizeof(rparams));
+ memset(&rparams, 0, sizeof(rparams));
rparams.nodePtr = newNode;
rparams.tapeInfoPtr = &tapeInfo;
Restore = newNode->restores; /* Array of vol fragments to restore */
bufferBlock = (struct TapeBlock *)0;
bufferBlock = (struct TapeBlock *) malloc(allocbufferSize);
if (!bufferBlock) ERROR_EXIT(TC_NOMEMORY);
- bzero(bufferBlock, allocbufferSize);
+ memset(bufferBlock, 0, allocbufferSize);
startTime = time(0);
for (rparams.frag=0; (rparams.frag < newNode->arraySize); rparams.frag++) {
struct timezone tzp;
afs_uint32 size;
- bzero(tapeLabel,sizeof(struct butm_tapeLabel));
+ memset(tapeLabel, 0, sizeof(struct butm_tapeLabel));
if (!CONF_XBSA) {
butm_GetSize(tapeInfoPtr, &size);
if (!s) return 0;
}
- bzero(tapeVolumeHT, sizeof(tapeVolumeHT));
- if (headB) bcopy (buffera + sizea - headB, tapeVolumeHT , headB);
- if (tailB) bcopy (bufferb , tapeVolumeHT + headB, tailB);
+ memset(tapeVolumeHT, 0, sizeof(tapeVolumeHT));
+ if (headB) memcpy(tapeVolumeHT , buffera + sizea - headB, headB);
+ if (tailB) memcpy(tapeVolumeHT + headB, bufferb , tailB);
if (ExtractTrailer (tapeVolumeHT, s, &offset, volTrailerPtr)) {
found = 1;
if (offset > headB) {
printf("\n\n");
TLog (taskId, "Labeltape\n");
- bzero(&tapeInfo, sizeof(tapeInfo));
+ memset(&tapeInfo, 0, sizeof(tapeInfo));
tapeInfo.structVersion = BUTM_MAJORVERSION;
code = butm_file_Instantiate (&tapeInfo, &globalTapeConfig);
if (code)
printf("\n\n");
TLog (taskId, "Readlabel\n");
- bzero(&tapeInfo,sizeof(tapeInfo));
+ memset(&tapeInfo, 0, sizeof(tapeInfo));
tapeInfo.structVersion = BUTM_MAJORVERSION;
code = butm_file_Instantiate (&tapeInfo, &globalTapeConfig);
if (code)
ErrorLog(0, taskId, code, tapeInfo.error, "Can't initialize the tape module\n");
ERROR_EXIT(code);
}
- bzero(&newTapeLabel,sizeof(newTapeLabel));
+ memset(&newTapeLabel, 0, sizeof(newTapeLabel));
interactiveFlag = autoQuery;
(strncmp(tempvhptr->postamble, "T--NAME#",8) == 0) )
{
/* Handle Cases 2 & 3 */
- bcopy (buffer+bufloc, &vhptr, sizeof(struct volumeHeader));
+ memcpy(&vhptr, buffer+bufloc, sizeof(struct volumeHeader));
HEADER_CHECKS(vhptr, header);
/* Handle Case 4 */
- bzero (&vhptr, sizeof(struct volumeHeader));
- bcopy (buffer+bufloc, &vhptr, firstSplice);
- bzero (&vhptr.pad, padLen);
- bcopy (buffer+bufloc+firstSplice, &vhptr.volumeID, nextSplice);
+ memset(&vhptr, 0, sizeof(struct volumeHeader));
+ memcpy(&vhptr, buffer+bufloc, firstSplice);
+ memset(&vhptr.pad, 0, padLen);
+ memcpy(&vhptr.volumeID, buffer+bufloc+firstSplice, nextSplice);
HEADER_CHECKS(vhptr, header);
/* Handle Case 1 */
- bzero (&vhptr, sizeof(struct volumeHeader));
- bcopy (buffer+bufloc, &vhptr, firstSplice);
- bcopy (buffer+bufloc+firstSplice+padLen, &vhptr+firstSplice, nextSplice);
+ memset(&vhptr, 0, sizeof(struct volumeHeader));
+ memcpy(&vhptr, buffer+bufloc, firstSplice);
+ memcpy(&vhptr+firstSplice, buffer+bufloc+firstSplice+padLen, nextSplice);
HEADER_CHECKS(vhptr, header);
}
{
afs_int32 code, c;
- bcopy(&scanInfoPtr->tapeLabel, &scanInfoPtr->dumpLabel, sizeof(struct butm_tapeLabel));
+ memcpy(&scanInfoPtr->dumpLabel, &scanInfoPtr->tapeLabel, sizeof(struct butm_tapeLabel));
while(1)
{
if (ptr->addDbFlag) TLog(taskId, "ScanTape and add to the database\n");
else TLog(taskId, "Scantape\n");
- bzero(&tapeScanInfo, sizeof(tapeScanInfo));
+ memset(&tapeScanInfo, 0, sizeof(tapeScanInfo));
tapeScanInfo.addDbFlag = ptr->addDbFlag;
- bzero(&curTapeInfo, sizeof(curTapeInfo));
+ memset(&curTapeInfo, 0, sizeof(curTapeInfo));
curTapeInfo.structVersion = BUTM_MAJORVERSION;
code = butm_file_Instantiate (&curTapeInfo, &globalTapeConfig);
if (code)
afs_int32 code = 0;
afs_int32 rcode, tcode;
- bzero(volumeHeader, sizeof(struct volumeHeader));
+ memset(volumeHeader, 0, sizeof(struct volumeHeader));
block = (char *) malloc(2*BUTM_BLOCKSIZE);
if (!block) return(TC_NOMEMORY);
/* extract information from previous tape label */
strcpy(buffer, prevTapeName);
- prevdot = rindex(buffer, '.');
+ prevdot = strrchr(buffer, '.');
if (!prevdot) return(retval);
prevdot++;
strcpy(tapeName, labelptr->AFSName);
- tp = rindex(tapeName, '.');
+ tp = strrchr(tapeName, '.');
if ( !tp ) return(1);
tp++;
- up = rindex(pathptr, '/');
+ up = strrchr(pathptr, '/');
if ( !up )
{
fprintf(stderr, "Invalid path name, missing /\n");
char *dotPtr;
int dotIndex;
- dotPtr = index(ptr, '.');
+ dotPtr = strchr(ptr, '.');
if ( !dotPtr ) return(0);
dotIndex = dotPtr - ptr;
char *dotPtr;
int dotIndex;
- dotPtr = rindex(ptr, '.');
+ dotPtr = strrchr(ptr, '.');
if (!dotPtr) return(0);
dotIndex = dotPtr - ptr;
{
char *sptr;
- sptr = rindex(tapename, '.');
+ sptr = strrchr(tapename, '.');
if ( !sptr ) return(-1);
sptr++;
return(atol(sptr));
char *sptr;
int c;
- sptr = rindex(tapeName, '.');
+ sptr = strrchr(tapeName, '.');
if ( !sptr ) return(0);
c = (int)( (afs_int32)sptr - (afs_int32)tapeName );
struct budb_dumpEntry *dumpEntryPtr = &tapeScanInfoPtr->dumpEntry;
/* construct dump entry */
- bzero(dumpEntryPtr, sizeof(struct budb_dumpEntry));
+ memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
dumpEntryPtr->id = volHeaderPtr->dumpID;
dumpEntryPtr->initialDumpID = tapeScanInfoPtr->initialDumpId;
dumpEntryPtr->parent = volHeaderPtr->parentID;
*/
if (argc == 1) {
ts = (struct cmd_syndesc *) malloc(sizeof(struct cmd_syndesc));
- bzero(ts, sizeof(*ts));
+ memset(ts, 0, sizeof(*ts));
ti = (struct cmd_item *) malloc(sizeof(struct cmd_item));
ti->next = 0;
ptr = (struct labelTapeIf *) malloc(sizeof(*ptr));
if (!ptr) ERROR_EXIT(TC_NOMEMORY);
- bcopy(label, &ptr->label, sizeof(ptr->label));
+ memcpy(&ptr->label, label, sizeof(ptr->label));
/* set up the status node */
*taskId = allocTaskId(); /* for bucoord */
{
afs_int32 code = 0;
- bzero(dumpEntryPtr, sizeof(struct budb_dumpEntry));
+ memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
strcpy(dumpEntryPtr->name, DUMP_TAPE_NAME);
strcpy(dumpEntryPtr->tapes.format, DUMP_TAPE_NAME);
goto getNewTape;
}
- bzero(&oldTapeLabel, sizeof(oldTapeLabel));
+ memset(&oldTapeLabel, 0, sizeof(oldTapeLabel));
code = butm_ReadLabel(tapeInfoPtr, &oldTapeLabel, 1); /* rewind tape */
if (code)
{
*/
for (dmp=oldTapeLabel.dumpid; dmp; dmp=de.appendedDumpID) {
if (dmp == lastDump.id) {
- bcopy(&lastDump, &de, sizeof(de));
- bcopy(&lastDump, &de2, sizeof(de2));
+ memcpy(&de, &lastDump, sizeof(de));
+ memcpy(&de2, &lastDump, sizeof(de2));
}
else {
code = bcdb_FindDumpByID(dmp, &de);
/* Initialize a tapeEntry for later inclusion into the database*/
listEntryPtr = (struct tapeEntryList *)malloc(sizeof(struct tapeEntryList));
if (!listEntryPtr) ERROR_EXIT(TC_NOMEMORY);
- bzero(listEntryPtr, sizeof(struct tapeEntryList));
+ memset(listEntryPtr, 0, sizeof(struct tapeEntryList));
/* Remember dumpid so we can delete it later */
if ( (oldTapeLabel.structVersion >= TAPE_VERSION_3) && oldTapeLabel.dumpid )
}
/* Determine what the last database dump was */
- bzero(&lastDump, sizeof(lastDump));
+ memset(&lastDump, 0, sizeof(lastDump));
code = bcdb_FindLatestDump("", "", &lastDump);
if (code) {
if (code != BUDB_NODUMPNAME) {
ErrorLog(0, taskId, code, 0, "Can't read backup database\n");
ERROR_EXIT(code);
}
- bzero(&lastDump, sizeof(lastDump));
+ memset(&lastDump, 0, sizeof(lastDump));
}
code = CreateDBDump(&dumpEntry); /* Create a dump for this tape */
{
afs_int32 code;
- bzero(dumpEntryPtr, sizeof(struct budb_dumpEntry));
+ memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
dumpEntryPtr->id = tapeEntPtr->dump;
dumpEntryPtr->initialDumpID = 0;
/* Initialize a tapeEntry for later inclusion into the database*/
listEntryPtr = (struct tapeEntryList *) malloc(sizeof(struct tapeEntryList));
if (!listEntryPtr) ERROR_EXIT(TC_NOMEMORY);
- bzero(listEntryPtr, sizeof(struct tapeEntryList));
+ memset(listEntryPtr, 0, sizeof(struct tapeEntryList));
/* Fill in tape entry so we can save it later */
strcpy(tapeEntryPtr->name, TNAME(&oldTapeLabel));
if (!writeBlock) ERROR_EXIT(TC_NOMEMORY);
writeBuffer = writeBlock + sizeof(struct blockMark);
- bzero(writeBuffer, BUTM_BLKSIZE);
+ memset(writeBuffer, 0, BUTM_BLKSIZE);
maxReadSize = 1024;
/*
transferSize = (charList.charListT_len < (blockSize - writeBufNbytes)) ?
charList.charListT_len : (blockSize - writeBufNbytes);
- bcopy(readBufPtr, writeBufPtr, transferSize);
+ memcpy(writeBufPtr, readBufPtr, transferSize);
charList.charListT_len -= transferSize;
writeBufPtr += transferSize;
readBufPtr += transferSize;
ERROR_EXIT(code);
}
- bzero(writeBuffer, blockSize);
+ memset(writeBuffer, 0, blockSize);
writeBufPtr = &writeBuffer[0];
writeBufNbytes = 0;
}
/* get the first item-header */
- bzero(&netItemHeader, sizeof(netItemHeader));
+ memset(&netItemHeader, 0, sizeof(netItemHeader));
code = getTapeData(tapeInfoPtr, rstTapeInfoPtr, &netItemHeader, sizeof(netItemHeader));
if (code) ERROR_EXIT(code);
structDumpHeader_ntoh(&netItemHeader, &hostItemHeader);
extern struct udbHandleS udbHandle;
/* Read the database header */
- bzero(&netDbHeader, sizeof(netDbHeader));
+ memset(&netDbHeader, 0, sizeof(netDbHeader));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netDbHeader, sizeof(netDbHeader));
if (code) ERROR_EXIT(code);
DbHeader_ntoh(&netDbHeader, &hostDbHeader);
}
/* get the next item-header */
- bzero(nextHeader, sizeof(*nextHeader));
+ memset(nextHeader, 0, sizeof(*nextHeader));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader, sizeof(netItemHeader));
if (code) ERROR_EXIT(code);
structDumpHeader_ntoh(&netItemHeader, nextHeader);
taskId = rstTapeInfoPtr->taskId;
/* read dump entry */
- bzero(&netDumpEntry, sizeof(netDumpEntry));
+ memset(&netDumpEntry, 0, sizeof(netDumpEntry));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netDumpEntry, sizeof(netDumpEntry));
if (code) ERROR_EXIT(code);
}
/* get the next item-header */
- bzero(nextHeader, sizeof(*nextHeader));
+ memset(nextHeader, 0, sizeof(*nextHeader));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader, sizeof(netItemHeader));
if (code) ERROR_EXIT(code);
structDumpHeader_ntoh(&netItemHeader, nextHeader);
{ /*t*/
/* read the tape entry */
- bzero(&netTapeEntry, sizeof(netTapeEntry));
+ memset(&netTapeEntry, 0, sizeof(netTapeEntry));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netTapeEntry, sizeof(netTapeEntry));
if (code) ERROR_EXIT(code);
tapeEntry_ntoh(&netTapeEntry, &hostTapeEntry);
}
/* get the next item-header */
- bzero(nextHeader, sizeof(*nextHeader));
+ memset(nextHeader, 0, sizeof(*nextHeader));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader, sizeof(netItemHeader));
if (code) ERROR_EXIT(code);
structDumpHeader_ntoh(&netItemHeader, nextHeader);
{ /*v*/
/* read the volume entry */
- bzero(&netVolumeEntry, sizeof(netVolumeEntry));
+ memset(&netVolumeEntry, 0, sizeof(netVolumeEntry));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netVolumeEntry, sizeof(netVolumeEntry));
if (code) ERROR_EXIT(code);
volumeEntry_ntoh(&netVolumeEntry, &hostVolumeEntry);
}
/* get the next item-header */
- bzero(nextHeader, sizeof(*nextHeader));
+ memset(nextHeader, 0, sizeof(*nextHeader));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader, sizeof(netItemHeader));
if (code) ERROR_EXIT(code);
structDumpHeader_ntoh(&netItemHeader, nextHeader);
ctPtr = (udbClientTextP) malloc(sizeof(*ctPtr));
if (!ctPtr) ERROR_EXIT(TC_NOMEMORY);
- bzero(ctPtr, sizeof(*ctPtr));
+ memset(ctPtr, 0, sizeof(*ctPtr));
ctPtr->textType = textType;
/* lock the text in the database */
unlink(filename);
/* get the next item-header */
- bzero(nextHeader, sizeof(*nextHeader));
+ memset(nextHeader, 0, sizeof(*nextHeader));
code = getTapeData(tapeInfo, rstTapeInfoPtr, &netItemHeader, sizeof(netItemHeader));
if (code) ERROR_EXIT(code);
structDumpHeader_ntoh(&netItemHeader, nextHeader);
/* copy out data */
transferBytes = (nbytes < requestedBytes ) ? nbytes : requestedBytes;
- bcopy(tapeReadBufferPtr, buffer, transferBytes);
+ memcpy(buffer, tapeReadBufferPtr, transferBytes);
tapeReadBufferPtr += transferBytes;
buffer += transferBytes;
nbytes -= transferBytes;
int index;
char *cp; {
afs_int32 temp;
- bcopy(cp+index*4, &temp, sizeof(afs_int32));
+ memcpy(&temp, cp+index*4, sizeof(afs_int32));
return temp;
}
}
th = gethostbyname(aname);
if (!th) return 0;
- bcopy(th->h_addr, &addr, sizeof(addr));
+ memcpy(&addr, th->h_addr, sizeof(addr));
return addr;
}
code = tapeInfo.ops.mount(&tapeInfo, "TAPE_NAME");
PASSq ("Mount tape", 0);
- bzero(tapeLabelWrite, sizeof(tapeLabelWrite));
+ memset(tapeLabelWrite, 0, sizeof(tapeLabelWrite));
tapeLabelWrite.structVersion = CUR_TAPE_VERSION;
tapeLabelWrite.creationTime = time(0);
tapeLabelWrite.expirationDate = time(0);
code = tapeInfo.ops.readLabel(&tapeInfo, &tapeLabelRead, REWIND);
PASS ("Read a label", 0);
- if ( bcmp(&tapeLabelWrite, &tapeLabelRead, sizeof(tapeLabelWrite)) )
+ if ( memcmp(&tapeLabelWrite, &tapeLabelRead, sizeof(tapeLabelWrite)) )
printf("FAILURE: Label Read is not same as label Written\n");
else
printf("PASSED: Label Read is same as label Written\n");
{
if (length == 0) ERROR_EXIT(0);
bmark = (struct blockMark *)buffer;
- bzero(bmark, sizeof(struct blockMark));
+ memset(bmark, 0, sizeof(struct blockMark));
bmark->magic = htonl(BLOCK_MAGIC);
bmark->count = htonl(length);
}
p = (struct progress *)info->tmRock;
- bzero(buffer, BUTM_BLOCKSIZE);
+ memset(buffer, 0, BUTM_BLOCKSIZE);
label = (struct tapeLabel *)buffer;
fmark = (struct fileMark *)buffer;
bmark = (struct blockMark *)buffer;
/* Copy the label into the tape block
* ---------------------------------- */
- bzero(tapeBlock, BUTM_BLOCKSIZE);
+ memset(tapeBlock, 0, BUTM_BLOCKSIZE);
if (!label->creationTime) label->creationTime = time(0);
tlabel = (struct tapeLabel *)tapeBlock;
- bcopy(label, &tlabel->label, sizeof(struct butm_tapeLabel));
+ memcpy(&tlabel->label, label, sizeof(struct butm_tapeLabel));
tlabel->label.structVersion = htonl(CUR_TAPE_VERSION);
tlabel->label.creationTime = htonl(tlabel->label.creationTime);
tlabel->label.expirationDate = htonl(tlabel->label.expirationDate);
if (label)
{
tlabel = (struct tapeLabel *) tapeBlock;
- bcopy(&tlabel->label, label, sizeof(struct butm_tapeLabel));
+ memcpy(label, &tlabel->label, sizeof(struct butm_tapeLabel));
label->structVersion = ntohl(label->structVersion);
label->creationTime = ntohl(label->creationTime);
label->expirationDate = ntohl(label->expirationDate);
if (len < BUTM_BLKSIZE)
{
- bzero(&dstart[len], BUTM_BLKSIZE - len);
+ memset(&dstart[len], 0, BUTM_BLKSIZE - len);
length = len;
}
else
if (b < (blocks-1)) b++;
else if (len)
- bcopy(&dstart[BUTM_BLKSIZE], &dstart[0], len);
+ memcpy(&dstart[0], &dstart[BUTM_BLKSIZE], len);
}
error_exit:
if (!info) ERROR_EXIT(BUTM_BADARGUMENT);
if (info->structVersion != BUTM_MAJORVERSION) ERROR_EXIT(BUTM_OLDINTERFACE);
- bzero (info, sizeof(struct butm_tapeInfo));
+ memset(info, 0, sizeof(struct butm_tapeInfo));
info->structVersion = BUTM_MAJORVERSION;
info->ops.mount = file_Mount;
info->ops.dismount = file_Dismount;
ERROR_EXIT (2);
}
- bzero(&label, sizeof(label));
+ memset(&label, 0, sizeof(label));
gettimeofday(&tp, 0);
label.structVersion = CUR_TAPE_VERSION;
label.creationTime = tp.tv_sec;
tprogress = tlen = fprogress = flen = 0;
while (1) {
- bzero(tbuffer,BUTM_BLKSIZE);
+ memset(tbuffer, 0, BUTM_BLKSIZE);
code = butm_ReadFileData (&info, tbuffer, BUTM_BLKSIZE, &tlen);
if (code && code != BUTM_STATUS_EOF) {
com_err (whoami, code, "Reading %dth tape data", i+1);
ERROR_EXIT(6);
}
- bzero(fbuffer,BUTM_BLKSIZE);
+ memset(fbuffer, 0, BUTM_BLKSIZE);
flen = read (fid, fbuffer, sizeof(fbuffer));
if (flen < 0) {
com_err (whoami, errno, "Reading %dth file data", i+1);
/* these macros define Unix-style functions missing in VC++5.0/NT4.0 */
#define MAXPATHLEN _MAX_PATH
-#define bzero(A, S) memset((void*)(A), 0, (size_t)(S))
-#define bcopy(A, B, S) memcpy((void*)(B), (void*)(A), (size_t)(S))
+#if 0
+#define memset(A, 0, S) memset((void*)(A), 0, (size_t)(S))
+#define memcpy(B, A, S) memcpy((void*)(B), (void*)(A), (size_t)(S))
/* There is a minor syntactic difference between memcmp and bcmp... */
-#define bcmp(A,B,S) (memcmp((void*)(A), (void*)(B), (size_t)(S)) ? 1 : 0)
+#define memcmp(A, B, S) (memcmp((void*)(A), (void*)(B), (size_t)(S)) ? 1 : 0)
+#define strchr(s, c) strchr(s, c)
+#define strrchr(s, c) strrchr(s, c)
+#endif
#define strcasecmp(s1,s2) _stricmp(s1,s2)
#define strncasecmp(s1,s2,n) _strnicmp(s1,s2,n)
-#define index(s, c) strchr(s, c)
-#define rindex(s, c) strrchr(s, c)
#define sleep(seconds) Sleep((seconds) * 1000)
#define fsync(fileno) _commit(fileno)
#define ftruncate(fd, size) _chsize((fd), (long)(size))
/* these macros define Unix-style functions missing in VC++5.0/NT4.0 */
#define MAXPATHLEN _MAX_PATH
-#define bzero(A, S) memset((void*)(A), 0, (size_t)(S))
-#define bcopy(A, B, S) memcpy((void*)(B), (void*)(A), (size_t)(S))
+#if 0
+#define memset(A, 0, S) memset((void*)(A), 0, (size_t)(S))
+#define memcpy(B, A, S) memcpy((void*)(B), (void*)(A), (size_t)(S))
/* There is a minor syntactic difference between memcmp and bcmp... */
-#define bcmp(A,B,S) (memcmp((void*)(A), (void*)(B), (size_t)(S)) ? 1 : 0)
+#define memcmp(A, B, S) (memcmp((void*)(A), (void*)(B), (size_t)(S)) ? 1 : 0)
+#define strchr(s, c) strchr(s, c)
+#define strrchr(s, c) strrchr(s, c)
+#endif
#define strcasecmp(s1,s2) _stricmp(s1,s2)
#define strncasecmp(s1,s2,n) _strnicmp(s1,s2,n)
-#define index(s, c) strchr(s, c)
-#define rindex(s, c) strrchr(s, c)
#define sleep(seconds) Sleep((seconds) * 1000)
#define fsync(fileno) _commit(fileno)
#define ftruncate(fd, size) _chsize((fd), (long)(size))
#if defined(AFS_LINUX20_ENV) && defined(KERNEL)
/* This is here instead of osi_machdep.h so fcrypt.c can pick it up. */
#include "../h/string.h"
-#define bcopy(F,T,C) memcpy((T), (F), (C))
+#if 0
+#define bcopy(F, T, C) memcpy((T), (F), (C))
+#endif
#endif
static char gpbuf[MAX_PASSWD_LEN];
register int i, tc;
- bzero(gpbuf, sizeof(gpbuf));
+ memset(gpbuf, 0, sizeof(gpbuf));
for(i=0; i<(sizeof(gpbuf)-1); i++) {
tc = fgetc(stdin);
if (tc == '\n' || tc == EOF) break;
token.startTime = starttime;
token.endTime = endtime;
- bcopy(session_key, (char *) &token.sessionKey, sizeof(token.sessionKey));
+ memcpy((char *) &token.sessionKey, session_key, sizeof(token.sessionKey));
token.kvno = tkt_type;
token.ticketLen = ticket_len;
if (ticket_len > MAXKTCTICKETLEN) {
fprintf(stderr, "dlog: DCE ticket is too long (length %d). Maximum length accepted by AFS cache manager is %d\n", MAXKTCTICKETLEN);
exit(1);
}
- bcopy((char *) ticket_p, (char *) token.ticket, ticket_len);
+ memcpy((char *) token.ticket, (char *) ticket_p, ticket_len);
sprintf(client.name, "AFS ID %d", unix_id);
strcpy(client.instance, "");
fprintf(stderr, "dlog: out of memory\n");
exit(1);
}
- bcopy(s_p, new_p, length);
+ memcpy(new_p, s_p, length);
new_p[length] = '\0';
return new_p;
}
case ASN_OCTET_STRING:
if (context == 1 && len == sizeof(reply_p->session_key)) {
saw_session_key++;
- bcopy(buf, reply_p->session_key, len);
+ memcpy(reply_p->session_key, buf, len);
}
buf += len;
break;
* Discard command line arguments, in case the password is on the
* command line (to avoid it showing up from a ps command).
*/
- for (i=1; i<zero_argc; i++) bzero (zero_argv[i], strlen(zero_argv[i]));
+ for (i=1; i<zero_argc; i++) memset(zero_argv[i], 0, strlen(zero_argv[i]));
zero_argc = 0;
#ifdef DLOG_TEST
foundPassword = 1;
strncpy (passwd, as->parms[aPASSWORD].items->data, sizeof(passwd) - 1);
passwd[sizeof(passwd) - 1] = '\0';
- bzero (as->parms[aPASSWORD].items->data,
- strlen(as->parms[aPASSWORD].items->data));
+ memset(as->parms[aPASSWORD].items->data, 0, strlen(as->parms[aPASSWORD].items->data));
}
if (as->parms[aLIFETIME].items) {
}
strcat(passwd, reply_p->salt);
des_string_to_key(passwd, passwd_key);
- bzero(passwd, strlen(passwd));
+ memset(passwd, 0, strlen(passwd));
/*
* Decrypt the private data returned by the DCE KDC, and forwarded
/*
* Destroy the key block: it's no longer needed.
*/
- bzero(schedule, sizeof(schedule));
- bzero(passwd_key, sizeof(passwd_key));
+ memset(schedule, 0, sizeof(schedule));
+ memset(passwd_key, 0, sizeof(passwd_key));
/*
* Do a very quick and dirty ASN.1 decode of the relevant parts
if (encrypt) {
#ifdef MUSTALIGN
if ((afs_int32) ivec & 3) {
- bcopy((char *)ivec++, (char *)&t_output[0], sizeof(t_output[0]));
- bcopy((char *)ivec, (char *)&t_output[1], sizeof(t_output[1]));
+ memcpy((char *)&t_output[0], (char *)ivec++, sizeof(t_output[0]));
+ memcpy((char *)&t_output[1], (char *)ivec, sizeof(t_output[1]));
}
else
#endif
/* get input */
#ifdef MUSTALIGN
if ((afs_int32) input & 3) {
- bcopy((char *)input++,(char *)&t_input[0],sizeof(t_input[0]));
- bcopy((char *)input++,(char *)&t_input[1],sizeof(t_input[1]));
+ memcpy((char *)&t_input[0], (char *)input++, sizeof(t_input[0]));
+ memcpy((char *)&t_input[1], (char *)input++, sizeof(t_input[1]));
}
else
#endif
/* copy temp output and save it for cbc */
#ifdef MUSTALIGN
if ((afs_int32) output & 3) {
- bcopy((char *)&t_output[0],(char *)output++,
- sizeof(t_output[0]));
- bcopy((char *)&t_output[1],(char *)output++,
- sizeof(t_output[1]));
+ memcpy((char *)output++, (char *)&t_output[0], sizeof(t_output[0]));
+ memcpy((char *)output++, (char *)&t_output[1], sizeof(t_output[1]));
}
else
#endif
/* decrypt */
#ifdef MUSTALIGN
if ((afs_int32) ivec & 3) {
- bcopy((char *)ivec++,(char *)&xor_0,sizeof(xor_0));
- bcopy((char *)ivec,(char *)&xor_1,sizeof(xor_1));
+ memcpy((char *)&xor_0, (char *)ivec++, sizeof(xor_0));
+ memcpy((char *)&xor_1, (char *)ivec, sizeof(xor_1));
}
else
#endif
/* get input */
#ifdef MUSTALIGN
if ((afs_int32) input & 3) {
- bcopy((char *)input++,(char *)&t_input[0],sizeof(t_input[0]));
- bcopy((char *)input++,(char *)&t_input[1],sizeof(t_input[0]));
+ memcpy((char *)&t_input[0], (char *)input++, sizeof(t_input[0]));
+ memcpy((char *)&t_input[1], (char *)input++, sizeof(t_input[0]));
}
else
#endif
/* copy temp output */
#ifdef MUSTALIGN
if ((afs_int32) output & 3) {
- bcopy((char *)&t_output[0],(char *)output++,
- sizeof(t_output[0]));
- bcopy((char *)&t_output[1],(char *)output++,
- sizeof(t_output[1]));
+ memcpy((char *)output++, (char *)&t_output[0], sizeof(t_output[0]));
+ memcpy((char *)output++, (char *)&t_output[1], sizeof(t_output[1]));
}
else
#endif
#ifdef MUSTALIGN
if ((afs_int32) ivec & 3) {
- bcopy((char *)ivec++,(char *)&t_output[0],sizeof(t_output[0]));
- bcopy((char *)ivec,(char *)&t_output[1],sizeof(t_output[1]));
+ memcpy((char *)&t_output[0], (char *)ivec++, sizeof(t_output[0]));
+ memcpy((char *)&t_output[1], (char *)ivec, sizeof(t_output[1]));
}
else
#endif
/* get input */
#ifdef MUSTALIGN
if ((afs_int32) input & 3) {
- bcopy((char *)input++,(char *)&t_input[0],sizeof(t_input[0]));
- bcopy((char *)input++,(char *)&t_input[1],sizeof(t_input[1]));
+ memcpy((char *)&t_input[0], (char *)input++, sizeof(t_input[0]));
+ memcpy((char *)&t_input[1], (char *)input++, sizeof(t_input[1]));
}
else
#endif
/* copy temp output and save it for checksum */
#ifdef MUSTALIGN
if ((afs_int32) output & 3) {
- bcopy((char *)&t_output[0],(char *)output++,sizeof(t_output[0]));
- bcopy((char *)&t_output[1],(char *)output,sizeof(t_output[1]));
+ memcpy((char *)output++, (char *)&t_output[0], sizeof(t_output[0]));
+ memcpy((char *)output, (char *)&t_output[1], sizeof(t_output[1]));
}
else
#endif
}
#endif
if ((afs_int32) clear & 3) {
- bcopy((char *)clear++,(char *)&L_save,sizeof(L_save));
- bcopy((char *)clear,(char *)&R_save,sizeof(R_save));
+ memcpy((char *)&L_save, (char *)clear++, sizeof(L_save));
+ memcpy((char *)&R_save, (char *)clear, sizeof(R_save));
L1 = L_save;
R1 = R_save;
}
if ((afs_int32) cipher & 3) {
L_save = L2; /* cant bcopy a reg */
R_save = R2;
- bcopy((char *)&L_save,(char *)cipher++,sizeof(L_save));
- bcopy((char *)&R_save,(char *)cipher,sizeof(R_save));
+ memcpy((char *)cipher++, (char *)&L_save, sizeof(L_save));
+ memcpy((char *)cipher, (char *)&R_save, sizeof(R_save));
}
else
#endif
}
ivec[0] = 0;
ivec[1] = 0;
- bcopy(key,sum,sizeof(C_Block));
+ memcpy(sum, key, sizeof(C_Block));
for (;;) {
if ((length = read (ind, inbuf, 512)) < 0) {
fprintf (stderr, "%s: Error reading from input.\n",
des_set_sequence_number(des_cblock new_sequence_number)
{
LOCK_RANDOM
- bcopy((char *)new_sequence_number, (char *)sequence_number,
- sizeof(sequence_number));
+ memcpy((char *)sequence_number, (char *)new_sequence_number, sizeof(sequence_number));
UNLOCK_RANDOM
return 0;
}
if (encrypt) {
#ifdef MUSTALIGN
if ((afs_int32) ivec & 3) {
- bcopy((char *)ivec++,(char *)&xor_0,sizeof(xor_0));
- bcopy((char *)ivec,(char *)&xor_1,sizeof(xor_1));
+ memcpy((char *)&xor_0, (char *)ivec++, sizeof(xor_0));
+ memcpy((char *)&xor_1, (char *)ivec, sizeof(xor_1));
}
else
#endif
/* get input */
#ifdef MUSTALIGN
if ((afs_int32) input & 3) {
- bcopy((char *)input,(char *)&t_input[0],sizeof(t_input[0]));
- bcopy((char *)(input+1),(char *)&t_input[1],sizeof(t_input[1]));
+ memcpy((char *)&t_input[0], (char *)input, sizeof(t_input[0]));
+ memcpy((char *)&t_input[1], (char *)(input+1), sizeof(t_input[1]));
}
else
#endif
*/
#ifdef MUSTALIGN
if ((afs_int32) input & 3) {
- bcopy((char *)input++,(char *)&xor_0,sizeof(xor_0));
+ memcpy((char *)&xor_0, (char *)input++, sizeof(xor_0));
xor_0 ^= t_output[0];
- bcopy((char *)input++,(char *)&xor_1,sizeof(xor_1));
+ memcpy((char *)&xor_1, (char *)input++, sizeof(xor_1));
xor_1 ^= t_output[1];
}
else
/* copy temp output and save it for cbc */
#ifdef MUSTALIGN
if ((afs_int32) output & 3) {
- bcopy((char *)&t_output[0],(char *)output++,
- sizeof(t_output[0]));
- bcopy((char *)&t_output[1],(char *)output++,
- sizeof(t_output[1]));
+ memcpy((char *)output++, (char *)&t_output[0], sizeof(t_output[0]));
+ memcpy((char *)output++, (char *)&t_output[1], sizeof(t_output[1]));
}
else
#endif
/* decrypt */
#ifdef MUSTALIGN
if ((afs_int32) ivec & 3) {
- bcopy((char *)ivec++,(char *)&xor_0,sizeof(xor_0));
- bcopy((char *)ivec,(char *)&xor_1,sizeof(xor_1));
+ memcpy((char *)&xor_0, (char *)ivec++, sizeof(xor_0));
+ memcpy((char *)&xor_1, (char *)ivec, sizeof(xor_1));
}
else
#endif
/* get input */
#ifdef MUSTALIGN
if ((afs_int32) input & 3) {
- bcopy((char *)input++,(char *)&t_input[0],sizeof(t_input[0]));
- bcopy((char *)input++,(char *)&t_input[1],sizeof(t_input[1]));
+ memcpy((char *)&t_input[0], (char *)input++, sizeof(t_input[0]));
+ memcpy((char *)&t_input[1], (char *)input++, sizeof(t_input[1]));
}
else
#endif
/* copy temp output */
#ifdef MUSTALIGN
if ((afs_int32) output & 3) {
- bcopy((char *)&t_output[0],(char *)output++,
- sizeof(t_output[0]));
- bcopy((char *)&t_output[1],(char *)output++,
- sizeof(t_output[1]));
+ memcpy((char *)output++, (char *)&t_output[0], sizeof(t_output[0]));
+ memcpy((char *)output++, (char *)&t_output[1], sizeof(t_output[1]));
}
else
#endif
#ifdef BSDUNIX
lose:
#endif
- bzero(key_string, sizeof (key_string));
+ memset(key_string, 0, sizeof (key_string));
return ok;
}
#else
#ifdef BSDUNIX
/* XXX assume jmp_buf is typedef'ed to an array */
- bcopy((char *)old_env, (char *)env, sizeof(env));
+ memcpy((char *)env, (char *)old_env, sizeof(env));
if (setjmp(env))
goto lose;
/* save terminal state*/
return -1;
push_signals();
/* Turn off echo */
- bcopy (&tty_state, &echo_off_tty_state, sizeof (tty_state));
+ memcpy(&echo_off_tty_state, &tty_state, sizeof (tty_state));
echo_off_tty_state.sg_flags &= ~ECHO;
if (ioctl(0,TIOCSETP,(char *)&echo_off_tty_state) == -1)
return -1;
}
continue;
}
- if ((ptr = index(s, '\n')))
+ if ((ptr = strchr(s, '\n')))
*ptr = '\0';
#endif
if (verify) {
clearerr(stdin);
continue;
}
- if ((ptr = index(key_string, '\n')))
+ if ((ptr = strchr(key_string, '\n')))
*ptr = '\0';
#endif
if (strcmp(s,key_string)) {
lose:
#endif
if (!ok)
- bzero(s, maxa);
+ memset(s, 0, maxa);
printf("\n");
#if defined(AFS_HPUX_ENV) || defined(AFS_FBSD_ENV)
/*
if (ioctl(0,TIOCSETP,(char *)&tty_state))
ok = 0;
pop_signals();
- bcopy((char *)env, (char *)old_env, sizeof(env));
+ memcpy((char *)old_env, (char *)env, sizeof(env));
#else
#if defined (AFS_AIX_ENV) /*|| defined (AFS_HPUX_ENV)*/ || defined(AFS_SGI_ENV) || defined(AFS_LINUX20_ENV)
ttyb.c_lflag = flags;
#endif
#endif
if (verify)
- bzero(key_string, sizeof (key_string));
+ memset(key_string, 0, sizeof (key_string));
s[maxa-1] = 0; /* force termination */
return !ok; /* return nonzero if not okay */
}
length = strlen(str);
/* init key array for bits */
- bzero(k_char,sizeof(k_char));
+ memset(k_char, 0, sizeof(k_char));
#ifdef DEBUG
if (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);
const des_cblock *weak_p = weak;
for (i = 0; i < (sizeof(weak)/sizeof(des_cblock)); i++) {
- if (!bcmp((char *)weak_p++,(char *)key,sizeof(des_cblock)))
+ if (!memcmp((char *)weak_p++,(char *)key,sizeof(des_cblock)))
return 1;
}
struct DirEntry *ep;
int entry;
- bzero(dot, sizeof(dot));
- bzero(dotdot, sizeof(dotdot));
+ memset(dot, 0, sizeof(dot));
+ memset(dotdot, 0, sizeof(dotdot));
dot[1] = vn;
dot[2] = vu;
dotdot[1] = pvn;
dirhandle dir;
CreateDir(dname, &dir);
- bzero(fid, sizeof(fid));
+ memset(fid, 0, sizeof(fid));
MakeDir(&dir, fid, fid);
for(i=0;i<count;i++) {
sprintf(tbuffer, "%s%d", ename, i);
kstr_size = 0;
nksyms = 0;
- bzero(xsq = &xcoff_sym, sizeof (*xsq));
+ memset(xsq = &xcoff_sym, 0, sizeof (*xsq));
for (i = 1; i < nxsyms; ++i, xsq = xsp++) {
if (xsp->n_zeroes != xsq->n_zeroes
*/
if (sym = symsrch(name))
return sym;
- bcopy(name, buf+1, sizeof (buf) - 2);
+ memcpy(buf+1, name, sizeof (buf) - 2);
buf[0] = '.';
if (sym = symsrch(buf))
struct interfaceAddr *interfaceAddr; /*Bogus param*/
fsprobe_ConnInfo = (struct fsprobe_ConnectionInfo *)0;
- bzero(fsprobe_Results, sizeof(struct fsprobe_ProbeResults));
+ memset(&fsprobe_Results, 0, sizeof(struct fsprobe_ProbeResults));
rxcall = (struct rx_call *)0;
Fids_Array = (AFSCBFids *)0;
curr_stats = fsprobe_Results.stats;
curr_probeOK = fsprobe_Results.probeOK;
fsprobe_Results.probeNum++;
- bzero(fsprobe_Results.stats, fsprobe_statsBytes);
- bzero(fsprobe_Results.probeOK, fsprobe_probeOKBytes);
+ memset(fsprobe_Results.stats, 0, fsprobe_statsBytes);
+ memset(fsprobe_Results.probeOK, 0, fsprobe_probeOKBytes);
for (conn_idx = 0; conn_idx < fsprobe_numServers; conn_idx++) {
/*
fsprobe_Results.probeNum = 0;
fsprobe_Results.probeTime = 0;
- bzero(fsprobe_Results.stats,
- (a_numServers * sizeof(struct ProbeViceStatistics)));
+ memset(fsprobe_Results.stats, 0, (a_numServers * sizeof(struct ProbeViceStatistics)));
/*
* Initialize the Rx subsystem, just in case nobody's done it.
(a_socketArray + curr_srv)->sin_addr.s_addr,
(a_socketArray + curr_srv)->sin_port);
}
- bcopy(a_socketArray + curr_srv,
- &(curr_conn->skt),
- sizeof(struct sockaddr_in));
+ memcpy(&(curr_conn->skt), a_socketArray + curr_srv, sizeof(struct sockaddr_in));
hostNameFound = hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
if (hostNameFound == (char *)0) {
} else {
int i, cnt;
- bzero(&curr_conn->partList, sizeof(struct partList));
+ memset(&curr_conn->partList, 0, sizeof(struct partList));
curr_conn->partCnt = 0;
i = XListPartitions(curr_conn->rxVolconn, &curr_conn->partList, &cnt);
if (!i) {
fprintf(stderr, "[%s] Can't get host info for servername1\n", rn);
exit(-1);
}
- bcopy(he->h_addr, &(FSSktArray[0].sin_addr.s_addr), 4);
+ memcpy(&(FSSktArray[0].sin_addr.s_addr), he->h_addr, 4);
FSSktArray[1].sin_family = htons(AF_INET); /*Internet address family*/
FSSktArray[1].sin_port = htons(7000); /*FileServer port*/
fprintf(stderr, "[%s] Can't get host info for servername2\n", rn);
exit(-1);
}
- bcopy(he->h_addr, &(FSSktArray[1].sin_addr.s_addr), 4);
+ memcpy(&(FSSktArray[1].sin_addr.s_addr), he->h_addr, 4);
FSSktArray[2].sin_family = htons(AF_INET); /*Internet address family*/
FSSktArray[2].sin_port = htons(7000); /*FileServer port*/
fprintf(stderr, "[%s] Can't get host info for servername3\n", rn);
exit(-1);
}
- bcopy(he->h_addr, &(FSSktArray[2].sin_addr.s_addr), 4);
+ memcpy(&(FSSktArray[2].sin_addr.s_addr), he->h_addr, 4);
printf("Sockets for the 3 AFS FileServers to be probed:\n");
printf("\t Host servername1: IP addr 0x%lx, port %d\n",
if (strncasecmp(cbuf, "PASS", 4) != NULL)
setproctitle("%s: %s", proctitle, cbuf);
#endif /* SETPROCTITLE */
- if ((cp = index(cbuf, '\r'))) {
+ if ((cp = strchr(cbuf, '\r'))) {
*cp++ = '\n';
*cp = '\0';
}
syslog(LOG_ERR, MSGSTR(SOCKOPT, "setsockopt: %m"));
/* set-up signal handler routines for SRC TRACE ON/OFF support */
- bzero((char *)&sa, sizeof(sa));
+ memset((char *)&sa, 0, sizeof(sa));
sa.sa_mask.losigs = sigmask(SIGUSR2);
sa.sa_handler = trace_handler;
sigaction(SIGUSR1, &sa, (struct sigaction *)0);
return;
}
- bzero((char *)&ut, sizeof(ut));
+ memset((char *)&ut, 0, sizeof(ut));
if (!fstat(fd, &buf)) {
(void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
(void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
if (!(pids =
(uid_t *)malloc((u_int)(fds * sizeof(uid_t)))))
return(NULL);
- bzero(pids, fds * sizeof(uid_t));
+ memset(pids, 0, fds * sizeof(uid_t));
}
if (pipe(pdes) < 0)
return(NULL);
if (pids[fdes = fileno(iop)] == 0)
return(-1);
(void)fclose(iop);
- bzero((char *)someSignals, sizeof(someSignals));
+ memset((char *)someSignals, 0, sizeof(someSignals));
someSignals[0] = (1<<(SIGINT-1)) + (1<<(SIGQUIT-1)) + (1<<(SIGHUP-1));
sigBlock = *((sigset_t *) someSignals);
sigprocmask(SIG_BLOCK, &sigBlock, &oset);
tmenu = (struct gtxframe_menu *) malloc(sizeof(*tmenu));
if (tmenu == (struct gtxframe_menu *)0)
return(-1);
- bzero(tmenu, sizeof(*tmenu));
+ memset(tmenu, 0, sizeof(*tmenu));
tmenu->next = aframe->menus;
aframe->menus = tmenu;
tmenu->name = gtx_CopyString(alabel);
WOP_GETDIMENSIONS(aframe->window, &sizeparms);
if (aframe->promptLine) {
- bzero(&strparms, sizeof(strparms));
+ memset(&strparms, 0, sizeof(strparms));
strparms.x = 0;
strparms.y = sizeparms.maxy-1;
strparms.highlight = 1;
}
else if (aframe->messageLine) {
/* Otherwise we're visible, print the message at the bottom */
- bzero(&strparms, sizeof(strparms));
+ memset(&strparms, 0, sizeof(strparms));
strparms.highlight = 1;
strparms.x = 0;
strparms.y = sizeparms.maxy-1;
* Now that all the pieces exist, fill them in and stick them in
* the right places.
*/
- bzero(tframe, sizeof(struct gtx_frame));
+ memset(tframe, 0, sizeof(struct gtx_frame));
tframe->keymap = newkeymap;
tframe->keystate = newkeystate;
keymap_InitState(tframe->keystate, tframe->keymap);
strcat(menubuffer, " ");
}
if (menubuffer[0] != 0) {
- bzero(&strparms, sizeof(strparms));
+ memset(&strparms, 0, sizeof(strparms));
strparms.x = 0;
strparms.y = 0;
strparms.s = menubuffer;
tmap = (struct keymap_map *) malloc(sizeof(struct keymap_map));
if (tmap != (struct keymap_map *)0)
- bzero(tmap, sizeof(*tmap));
+ memset(tmap, 0, sizeof(*tmap));
return(tmap);
}
keymap_InitState(astate, amap)
register struct keymap_state *astate;
struct keymap_map *amap; {
- bzero(astate, sizeof(*astate));
+ memset(astate, 0, sizeof(*astate));
astate->initMap = amap;
astate->currentMap = amap;
return 0;
*/
if (gator_textcb_debug)
fprintf(stderr, "[%s] Zeroing %d bytes in text buffer at 0x%x\n", rn, numBuffBytes, newBuff);
- bzero(newBuff, numBuffBytes);
+ memset(newBuff, 0, numBuffBytes);
if (gator_textcb_debug)
fprintf(stderr, "[%s] Initializing blank line buffer at 0x%x\n", rn, blankLine);
curr_ent->numInversions = 0;
curr_ent->charsUsed = 0;
curr_ent->textp = curr_buff;
- bcopy(blankLine, curr_ent->textp, a_maxCharsPerEntry+1);
+ memcpy(curr_ent->textp, blankLine, a_maxCharsPerEntry+1);
for (curr_inv = 0; curr_inv < GATOR_TEXTCB_MAXINVERSIONS; curr_inv++)
curr_ent->inversion[curr_inv] = 0;
* Copy over a blank line into the one we're initializing. We
* copy over the trailing null, too.
*/
- bcopy(a_cbhdr->blankLine, curr_ent->textp, a_cbhdr->maxCharsPerEntry+1);
+ memcpy(curr_ent->textp, a_cbhdr->blankLine, a_cbhdr->maxCharsPerEntry+1);
for (inv=0; inv < GATOR_TEXTCB_MAXINVERSIONS; inv++)
curr_ent->inversion[inv] = 0;
#endif /* defined(AFS_HPUX_ENV) */
memset((char *)allZeroes, '\0', sizeof(allZeroes));
- bzero((char *)allZeroes, sizeof(allZeroes));
+ memset((char *)allZeroes, 0, sizeof(allZeroes));
sigNone = *((sigset_t *) allZeroes);
allZeroes[0] = (1<<(SIGCHLD-1)) + (1<<(SIGHUP-1)) + (1<<(SIGALRM-1));
inet_ntoa(his_addr.sin_addr.s_addr),
ntohs(his_addr.sin_port));
execl(sep->se_server,
- rindex(sep->se_server, '/')+1,
+ strrchr(sep->se_server, '/')+1,
sep->se_socktype == SOCK_DGRAM
? (char *)0 : addrbuf, (char *)0);
} else
(cnt + 2)));
if (!P)
return(-1);
- bcopy(environ, P, cnt * sizeof(char *));
+ memcpy(P, environ, cnt * sizeof(char *));
environ = P;
}
environ[cnt + 1] = NULL;
/* (4) sessionKey */
bp = buf + strlen(buf);
- bcopy(&token->sessionKey,bp,8);
+ memcpy(bp, &token->sessionKey, 8);
bp += 8;
/* (5) - (6) */
/* (7) ticket */
bp += strlen(bp);
- bcopy(token->ticket, bp, token->ticketLen);
+ memcpy(bp, token->ticket, token->ticketLen);
bp += token->ticketLen;
if((count = write(s, buf, (int)(bp - buf))) == -1) {
hrs = 0;
s = as->parms[7].items->data;
- if (index(s, ':'))
+ if (strchr(s, ':'))
sscanf(s, "%d:%d", &hrs, &mins);
else
sscanf(s, "%d", &mins);
if (code) { /* if not then get key and try again */
if (as->parms[13].items) { /* if password specified */
strncpy (passwd, as->parms[13].items->data, sizeof(passwd));
- bzero (as->parms[13].items->data, strlen (as->parms[13].items->data));
+ memset(as->parms[13].items->data, 0, strlen (as->parms[13].items->data));
} else {
char msg[MAXKTCNAMELEN+50];
if (as->parms[12].items) sprintf (msg, "Administrator's (%s) Password: ", name);
"getting Authentication token for %s",
PrintedName (name, instance, cell));
}
- bzero (&key, sizeof(key));
+ memset(&key, 0, sizeof(key));
}
}
cksum = ntohl(answer->cksum);
if (challenge != ntohl(answer->challenge)) return KABADPROTOCOL;
- bcopy (&answer->sessionKey, &token->sessionKey, sizeof(token->sessionKey));
+ memcpy(&token->sessionKey, &answer->sessionKey, sizeof(token->sessionKey));
token->startTime = ntohl(answer->startTime);
token->endTime = ntohl(answer->endTime);
token->kvno = (short) ntohl(answer->kvno);
)
return KABADPROTOCOL;
- bcopy (strings, token->ticket, token->ticketLen);
+ memcpy(token->ticket, strings, token->ticketLen);
strings += token->ticketLen;
- if (bcmp (strings, label, KA_LABELSIZE) != 0) return KABADPROTOCOL;
+ if (memcmp (strings, label, KA_LABELSIZE) != 0) return KABADPROTOCOL;
if (pwexpires) {
afs_int32 temp;
if (oanswer->SeqLen > temp) {
strings = oanswer->SeqBody + temp;
- bcopy (strings, &temp, sizeof(afs_int32));
+ memcpy(&temp, strings, sizeof(afs_int32));
tempc = ntohl(temp) >> 24;
/* don't forget this if you add any more fields!
strings += sizeof(afs_int32);
request_time = time(0);
request.time = htonl(request_time);
- bcopy (req_label, request.label, sizeof(request.label));
+ memcpy(request.label, req_label, sizeof(request.label));
arequest.SeqLen = sizeof(request);
arequest.SeqBody = (char *)&request;
des_pcbc_encrypt (arequest.SeqBody, arequest.SeqBody, arequest.SeqLen,
token->endTime = end;
token->kvno = ntohl(answer_old.kvno);
token->ticketLen = answer_old.ticket_len;
- bcopy (answer_old.ticket, token->ticket, sizeof(token->ticket));
- bcopy (&answer_old.sessionkey, &token->sessionKey,
- sizeof(struct ktc_encryptionKey));
+ memcpy(token->ticket, answer_old.ticket, sizeof(token->ticket));
+ memcpy(&token->sessionKey, &answer_old.sessionkey, sizeof(struct ktc_encryptionKey));
}
break;
default:
token->endTime = ntohl(answer_old.endTime);
token->ticketLen = ntohl(answer_old.ticketLen);
token->kvno = ntohl(answer_old.kvno);
- bcopy (&answer_old.sessionKey, &token->sessionKey,
- sizeof(token->sessionKey));
+ memcpy(&token->sessionKey, &answer_old.sessionKey, sizeof(token->sessionKey));
if (tkt_CheckTimes (token->startTime, token->endTime, time(0)) < 0) {
UNLOCK_GLOBAL_MUTEX
UNLOCK_GLOBAL_MUTEX
return KABADPROTOCOL;
}
- bcopy (strings, token->ticket, token->ticketLen);
+ memcpy(token->ticket, strings, token->ticketLen);
break;
default:
int i;
int passlen;
- bzero (key, sizeof(struct ktc_encryptionKey));
+ memset(key, 0, sizeof(struct ktc_encryptionKey));
strncpy (password, cell, 8);
passlen = strlen (str);
if ((passlen = strlen(password)) > sizeof(password))
passlen = sizeof(password);
- bcopy ("kerberos", ivec, 8);
- bcopy ("kerberos", temp_key, 8);
+ memcpy(ivec, "kerberos", 8);
+ memcpy(temp_key, "kerberos", 8);
des_fixup_key_parity (temp_key);
des_key_sched (temp_key, schedule);
des_cbc_cksum (password, ivec, passlen, schedule, ivec);
- bcopy (ivec, temp_key, 8);
+ memcpy(temp_key, ivec, 8);
des_fixup_key_parity (temp_key);
des_key_sched (temp_key, schedule);
des_cbc_cksum (password, key, passlen, schedule, ivec);
afs_int32 code;
LOCK_GLOBAL_MUTEX
- bzero (key, sizeof(struct ktc_encryptionKey));
+ memset(key, 0, sizeof(struct ktc_encryptionKey));
code = read_pw_string (password, sizeof(password), prompt, verify);
if (code) {
UNLOCK_GLOBAL_MUTEX
printf ("Error discovered in header, rebuilding.\n");
/* try to write a good header */
- bzero(&cheader,sizeof(cheader));
+ memset(&cheader, 0, sizeof(cheader));
cheader.version = htonl(KADBVERSION);
cheader.checkVersion = htonl(KADBVERSION);
cheader.headerSize = htonl(sizeof(cheader));
code = inc_header_word (at, stats.allocs);
if (code) return 0;
- bzero (tentry, sizeof(kaentry)); /* zero new entry */
+ memset(tentry, 0, sizeof(kaentry)); /* zero new entry */
return temp;
}
/* check index just to be on the safe side */
if (!index_OK (index)) return KABADINDEX;
- bzero (&tentry, sizeof(kaentry));
+ memset(&tentry, 0, sizeof(kaentry));
tentry.next = cheader.freePtr;
tentry.flags = htonl(KAFFREE);
code = set_header_word (at, freePtr, htonl(index));
((now - ntohl(okeys.keys[i].superseded) > maxKeyLifetime)) ) {
okeys.keys[i].superseded = 0;
okeys.keys[i].version = htonl(-1);
- bzero(&okeys.keys[i].key, sizeof(struct ktc_encryptionKey));
+ memset(&okeys.keys[i].key, 0, sizeof(struct ktc_encryptionKey));
modified = 1;
es_Report ("Dropped oldkey %d seconds old with kvno %d\n",
if (!addednewkey && (okeys.keys[i].superseded == 0)) {
okeys.keys[i].version = htonl(newkeyver);
okeys.keys[i].superseded = htonl(NEVERDATE);
- bcopy (key, &okeys.keys[i].key, sizeof(struct ktc_encryptionKey));
+ memcpy(&okeys.keys[i].key, key, sizeof(struct ktc_encryptionKey));
modified = 1;
addednewkey = okeysaddr;
}
okeys.entry = htonl(tentryaddr);
okeys.keys[0].version = htonl(newkeyver);
okeys.keys[0].superseded = htonl(NEVERDATE);
- bcopy (key, &okeys.keys[0].key, sizeof(struct ktc_encryptionKey));
+ memcpy(&okeys.keys[0].key, key, sizeof(struct ktc_encryptionKey));
newtotalkeyentries++;
/* Thread onto the header's chain of oldkeys */
tentry->misc.asServer.oldKeys = htonl(addednewkey);
tentry->misc.asServer.nOldKeys = htonl(newtotalkeyentries);
tentry->key_version = htonl(newkeyver);
- bcopy (key, &tentry->key, sizeof (tentry->key));
+ memcpy(&tentry->key, key, sizeof (tentry->key));
/* invalidate key caches everywhere */
code = inc_header_word (tt, specialKeysVersion);
struct ka_debugInfo *info;
{ int i;
- bcopy (&cheader_lock, &info->cheader_lock, sizeof (info->cheader_lock));
- bcopy (&keycache_lock, &info->keycache_lock, sizeof (info->keycache_lock));
+ memcpy(&info->cheader_lock, &cheader_lock, sizeof (info->cheader_lock));
+ memcpy(&info->keycache_lock, &keycache_lock, sizeof (info->keycache_lock));
info->kcVersion = keyCacheVersion;
info->kcSize = maxCachedKeys;
strncpy (keyCache[i].name, name, sizeof (keyCache[i].name));
strncpy (keyCache[i].inst, inst, sizeof (keyCache[i].inst));
keyCacheVersion = ntohl(cheader.specialKeysVersion);
- bcopy (key, &keyCache[i].key, sizeof(*key));
+ memcpy(&keyCache[i].key, key, sizeof(*key));
keyCache[i].superseded = superseded;
keyCache[i].used = time(0);
if ((keyCache[i].kvno == kvno) &&
(strcmp(keyCache[i].name, name) == 0) &&
(strcmp(keyCache[i].inst, inst) == 0)) {
- bcopy (&keyCache[i].key, key, sizeof(*key));
+ memcpy(key, &keyCache[i].key, sizeof(*key));
keyCache[i].used = time(0);
ReleaseReadLock (&keycache_lock);
return 0;
/* first check the current key */
if (tentry.key_version == htonl(kvno)) {
- bcopy (&tentry.key, key, sizeof(*key));
+ memcpy(key, &tentry.key, sizeof(*key));
ka_Encache (name, inst, kvno, key, NEVERDATE);
return 0;
}
for (i=0; i<NOLDKEYS; i++)
if (okeys.keys[i].superseded &&
(ntohl(okeys.keys[i].version) == kvno)) {
- bcopy (&okeys.keys[i].key, key, sizeof(*key));
+ memcpy(key, &okeys.keys[i].key, sizeof(*key));
ka_Encache (name, inst, kvno, key,
ntohl(okeys.keys[i].superseded));
return 0;
if ((keyCache[i].superseded == NEVERDATE) &&
(strcmp(keyCache[i].name, name) == 0) &&
(strcmp(keyCache[i].inst, inst) == 0)){
- bcopy (&keyCache[i].key, key, sizeof(*key));
+ memcpy(key, &keyCache[i].key, sizeof(*key));
*kvno = keyCache[i].kvno;
keyCache[i].used = time(0);
ReleaseReadLock (&keycache_lock);
code = FindBlock (tt, name, inst, &to, &tentry);
if (code) return code;
if (to == 0) return KANOENT;
- bcopy (&tentry.key, key, sizeof(*key));
+ memcpy(key, &tentry.key, sizeof(*key));
*kvno = ntohl(tentry.key_version);
ka_Encache (name, inst, *kvno, key, NEVERDATE);
return 0;
if (nextAutoCPWTime == 0) { /* initialize things */
nextAutoCPWTime = time.tv_sec + autoCPWInterval;
- bcopy (&time, &random_value[0], 8);
- bcopy (&time, &random_value[2], 8);
+ memcpy(&random_value[0], &time, 8);
+ memcpy(&random_value[2], &time, 8);
}
if ((++totalUpdates >= autoCPWUpdates) &&
if (code) return code;
if (to) { /* check if auto cpw is disabled */
if (!(ntohl(tentry.flags) & KAFNOCPW)) {
- bcopy (&random_value[0], &key, sizeof(key));
+ memcpy(&key, &random_value[0], sizeof(key));
des_fixup_key_parity (&key);
code = set_password (tt, KA_ADMIN_NAME, KA_ADMIN_INST,
&key, 0, 0);
if (code) return code;
if (to) { /* check if auto cpw is disabled */
if (!(ntohl(tentry.flags) & KAFNOCPW)) {
- bcopy (&random_value[2], &key, sizeof(key));
+ memcpy(&key, &random_value[2], sizeof(key));
des_fixup_key_parity (&key);
code = set_password (tt, KA_TGS_NAME, lrealm, &key, 0, 0);
if (code == 0) {
if (code = ka_NewKey (tt, to, &tentry, key)) return code;
}
else {
- bcopy(key, &tentry.key, sizeof(tentry.key));
+ memcpy(&tentry.key, key, sizeof(tentry.key));
tentry.key_version = htonl(0);
}
tentry.user_expiration = htonl(NEVERDATE);
oanswer->SeqLen = answer_len;
answer = oanswer->SeqBody;
request.time = htonl (request_time+1);
- bcopy ((char *)&request.time, answer, sizeof(Date));
+ memcpy(answer, (char *)&request.time, sizeof(Date));
answer += sizeof(Date);
- bcopy (KA_CPW_ANS_LABEL, answer, KA_LABELSIZE);
+ memcpy(answer, KA_CPW_ANS_LABEL, KA_LABELSIZE);
des_pcbc_encrypt (oanswer->SeqBody, oanswer->SeqBody, answer_len,
user_schedule, &tentry.key, ENCRYPT);
if ((now - ntohl(tentry->change_password_time)) < MinHours*60*60)
return KATOOSOON;
- if (!bcmp(password, &(tentry->key), sizeof(EncryptionKey)))
+ if (!memcmp(password, &(tentry->key), sizeof(EncryptionKey)))
return KAREUSED;
code = ka_KeyCheckSum ((char *)password, &newsum);
if (code = ka_NewKey (tt, to, &tentry, password)) return(code);
}
else {
- bcopy (password, &tentry.key, sizeof(tentry.key));
+ memcpy(&tentry.key, password, sizeof(tentry.key));
if (!kvno) {
kvno = ntohl(tentry.key_version);
if ((kvno < 1) || (kvno >= MAXKAKVNO))
answer = (struct ka_ticketAnswer *)oanswer->SeqBody;
answer->challenge = htonl(challenge);
- bcopy (sessionKey, &answer->sessionKey, sizeof(struct ktc_encryptionKey));
+ memcpy(&answer->sessionKey, sessionKey, sizeof(struct ktc_encryptionKey));
answer->startTime = htonl(start);
answer->endTime = htonl(end);
answer->kvno = server->key_version;
putstr (server->userID.name);
putstr (server->userID.instance);
if (rem < ticketLen+KA_LABELSIZE) return code;
- bcopy (ticket, ans, ticketLen);
+ memcpy(ans, ticket, ticketLen);
ans += ticketLen;
- if (label) bcopy (label, ans, KA_LABELSIZE);
- else bzero (ans, KA_LABELSIZE);
+ if (label) memcpy(ans, label, KA_LABELSIZE);
+ else memset(ans, 0, KA_LABELSIZE);
ans += KA_LABELSIZE;
oanswer->SeqLen = (ans - oanswer->SeqBody);
}
else { /* return our time if possible */
oanswer->SeqLen = sizeof(afs_int32);
request.time = htonl(now);
- bcopy (&request.time, oanswer->SeqBody, sizeof(afs_int32));
+ memcpy(oanswer->SeqBody, &request.time, sizeof(afs_int32));
}
#endif
code = KACLOCKSKEW;
if (to == 0) {code = KANOENT; goto abort; }
tgskvno = ntohl(server.key_version);
- bcopy (&server.key, &tgskey, sizeof(tgskey));
+ memcpy(&tgskey, &server.key, sizeof(tgskey));
code = des_random_key (&sessionKey);
if (code) {
oanswer->SeqLen = answer_len;
answer = oanswer->SeqBody;
answer_time = htonl(request.time+1);
- bcopy ((char *)&answer_time, answer, sizeof(Date));
+ memcpy(answer, (char *)&answer_time, sizeof(Date));
answer += sizeof(Date);
- bcopy ((char *)&sessionKey, answer, sizeof(struct ktc_encryptionKey));
+ memcpy(answer, (char *)&sessionKey, sizeof(struct ktc_encryptionKey));
answer += sizeof(struct ktc_encryptionKey);
temp = htonl(tgskvno);
- bcopy ((char *)&temp, answer, sizeof(afs_int32));
+ memcpy(answer, (char *)&temp, sizeof(afs_int32));
answer += sizeof(afs_int32);
temp = htonl(ticketLen);
- bcopy ((char *)&temp, answer, sizeof(afs_int32));
+ memcpy(answer, (char *)&temp, sizeof(afs_int32));
answer += sizeof(afs_int32);
- bcopy (ticket, answer, ticketLen);
+ memcpy(answer, ticket, ticketLen);
answer += ticketLen;
- bcopy ((tgt ? KA_GETTGT_ANS_LABEL : KA_GETADM_ANS_LABEL), answer,
- KA_LABELSIZE);
+ memcpy(answer, (tgt ? KA_GETTGT_ANS_LABEL : KA_GETADM_ANS_LABEL), KA_LABELSIZE);
break;
case 1:
case 2:
temp = pwexpires << 24; /* move it into the high byte */
pwexpires = htonl(temp);
- bcopy (&pwexpires, (char * )oanswer->SeqBody + oanswer->SeqLen, sizeof(afs_int32));
+ memcpy((char * )oanswer->SeqBody + oanswer->SeqLen, &pwexpires, sizeof(afs_int32));
oanswer->SeqLen += sizeof(afs_int32);
oanswer->SeqLen = round_up_to_ebs(oanswer->SeqLen);
if (oanswer->SeqLen > oanswer->MaxSeqLen) {
if (newvals[REUSEFLAGS]) {
if (newvals[REUSEFLAGS] & KA_REUSEPW)
- bzero(tentry.pwsums, KA_NPWSUMS);
+ memset(tentry.pwsums, 0, KA_NPWSUMS);
else if ((newvals[REUSEFLAGS] & KA_NOREUSEPW) && !tentry.pwsums[0])
tentry.pwsums[0] = 0xff;
}
get_time (0,0,0); /* generate random update */
- bzero (aentry, sizeof(*aentry));
+ memset(aentry, 0, sizeof(*aentry));
aentry->minor_version = KAMINORVERSION;
aentry->flags = ntohl(tentry.flags);
aentry->user_expiration = ntohl(tentry.user_expiration);
rxkad_GetServerInfo(call->conn, &enc_level, 0, 0, 0, 0, 0);
if ((noAuthenticationRequired) ||
(callerIsAdmin && enc_level == rxkad_crypt))
- bcopy (&tentry.key, &aentry->key, sizeof(struct ktc_encryptionKey));
- else bzero (&aentry->key, sizeof(aentry->key));
+ memcpy(&aentry->key, &tentry.key, sizeof(struct ktc_encryptionKey));
+ else memset(&aentry->key, 0, sizeof(aentry->key));
code = ka_KeyCheckSum ((char *)&tentry.key, &aentry->keyCheckSum);
if (!tentry.pwsums[0] && npwSums > 1 && !tentry.pwsums[1]) {
aentry->reserved3 = 0x12340000;
sizeof(struct ka_getTicketAnswer) - 5*MAXKTCNAMELEN) goto abort;
answer = (struct ka_getTicketAnswer *)oanswer->SeqBody;
- bcopy (&sessionKey, &answer->sessionKey,
- sizeof(struct ktc_encryptionKey));
+ memcpy(&answer->sessionKey, &sessionKey, sizeof(struct ktc_encryptionKey));
answer->startTime = htonl(times.start);
answer->endTime = htonl(end);
answer->kvno = server.key_version;
putstr (sname);
putstr (sinstance);
if (rem < ticketLen) goto abort;
- bcopy (ticket, ans, ticketLen);
+ memcpy(ans, ticket, ticketLen);
oanswer->SeqLen = (ans - oanswer->SeqBody) + ticketLen;
}
oanswer->SeqLen = round_up_to_ebs(oanswer->SeqLen);
}
*admin_accounts = ntohl(cheader.admin_accounts);
- /* bcopy ((char *)&cheader.stats, (char *)statics, sizeof(kasstats)); */
+ /* memcpy((char *)statics, (char *)&cheader.stats, sizeof(kasstats)); */
/* these are stored in network byte order and must be copied */
statics->allocs = ntohl(cheader.stats.allocs);
statics->frees = ntohl(cheader.stats.frees);
check that the statistics command copies all the fields
#endif
- bcopy ((char *)&dynamic_statistics, (char *)dynamics, sizeof(kadstats));
+ memcpy((char *)dynamics, (char *)&dynamic_statistics, sizeof(kadstats));
statics->minor_version = KAMINORVERSION;
dynamics->minor_version = KAMINORVERSION;
* ignore this for aix till v3.1... */
getrusage(RUSAGE_SELF, &ru);
#if (KAMAJORVERSION>5)
- bcopy (&ru.ru_utime, &dynamics->utime, sizeof(struct katimeval));
- bcopy (&ru.ru_stime, &dynamics->stime, sizeof(struct katimeval));
+ memcpy(&dynamics->utime, &ru.ru_utime, sizeof(struct katimeval));
+ memcpy(&dynamics->stime, &ru.ru_stime, sizeof(struct katimeval));
dynamics->dataSize = ru.ru_idrss;
dynamics->stackSize = ru.ru_isrss;
dynamics->pageFailts = ru.ru_majflt;
return code;
}
- bcopy (&tentry.key, password, sizeof (*password));
+ memcpy(password, &tentry.key, sizeof (*password));
code = ubik_EndTrans (tt);
#endif
return code;
if (sizeof(struct ka_cpwRequest) % 8) return KAINTERNALERROR;
if (version != KAMAJORVERSION) return KAOLDINTERFACE;
- bzero (info, sizeof(*info));
+ memset(info, 0, sizeof(*info));
info->minorVersion = KAMINORVERSION;
info->host = dynamic_statistics.host;
static void initialize_dstats ()
{
- bzero (&dynamic_statistics, sizeof(dynamic_statistics));
+ memset(&dynamic_statistics, 0, sizeof(dynamic_statistics));
dynamic_statistics.start_time = time(0);
dynamic_statistics.host = myHost;
}
ViceLog(0, ("kaserver: couldn't get address of this host.\n"));
exit(1);
}
- bcopy(th->h_addr,myHost,sizeof(afs_int32));
+ memcpy(myHost, th->h_addr, sizeof(afs_int32));
for (i=0; i<cellinfo->numServers; i++)
if (cellinfo->hostAddr[i].sin_addr.s_addr != *myHost) {
afs_int32 code;
*cksumP = 0;
- bzero (block, 8);
+ memset(block, 0, 8);
code = des_key_sched (key, s);
if (code) return KABADKEY;
des_ecb_encrypt (block, block, s, ENCRYPT);
- bcopy (block, &cksum, sizeof(afs_int32));
+ memcpy(&cksum, block, sizeof(afs_int32));
*cksumP = ntohl(cksum);
return 0;
}
fprintf(stderr, "%s: data came out corrupt\n", ti->data);
continue;
}
- bcopy(data.dptr, &rdata, sizeof(kalog_elt));
+ memcpy(&rdata, data.dptr, sizeof(kalog_elt));
printf("%s: last operation from host %x at %s", ti->data, rdata.host,
ctime(&rdata.last_use));
}
* name (we know there is one) and splice in the symlink contents.
*/
if (true_name[0] != '/') {
- last_component = (char *) rindex(orig_name, '/');
+ last_component = (char *) strrchr(orig_name, '/');
strcpy(++last_component, true_name);
strcpy(true_name, orig_name);
}
simplify_name(orig_name, truename);
}
else {
- bp = (char *) rindex(arg, '/');
+ bp = (char *) strrchr(arg, '/');
if (bp) {
orig_name[0] = '.';
orig_name[1] = '/';
/*
* Find rightmost slash, if any.
*/
- bp = (char *) rindex(truename, '/');
+ bp = (char *) strrchr(truename, '/');
if (bp) {
/*
* Found it. Designate everything before it as the parent directory,
static char gpbuf[BUFSIZ];
/* read a password from stdin, stop on \n or eof */
register int i, tc;
- bzero(gpbuf, sizeof(gpbuf));
+ memset(gpbuf, 0, sizeof(gpbuf));
for(i=0; i<(sizeof(gpbuf)-1); i++) {
tc = fgetc(stdin);
if (tc == '\n' || tc == EOF) break;
char *reason; /* string describing errors */
/* blow away command line arguments */
- for (i=1; i<zero_argc; i++) bzero (zero_argv[i], strlen(zero_argv[i]));
+ for (i=1; i<zero_argc; i++) memset(zero_argv[i], 0, strlen(zero_argv[i]));
zero_argc = 0;
/* first determine quiet flag based on -silent switch */
*/
foundPassword = 1;
strncpy (passwd, as->parms[aPASSWORD].items->data, sizeof(passwd));
- bzero (as->parms[aPASSWORD].items->data,
- strlen(as->parms[aPASSWORD].items->data));
+ memset(as->parms[aPASSWORD].items->data, 0, strlen(as->parms[aPASSWORD].items->data));
}
if (as->parms[aLIFETIME].items) {
code = ka_UserAuthenticateGeneral (KA_USERAUTH_VERSION + (dosetpag ? KA_USERAUTH_DOSETPAG2:0), pw->pw_name,
instance, realm, passwd, lifetime, &password_expires, 0, &reason);
- bzero (passwd, sizeof(passwd));
+ memset(passwd, 0, sizeof(passwd));
if (code) {
if (!Silent) {
fprintf (stderr,
char term[64];
struct passwd *pwd;
-char *strcat(), *rindex(), *index(), *malloc(), *realloc();
+char *strcat(), *malloc(), *realloc();
static void timedout(void);
static void showmotd(void);
static void doremoteterm(char *term, struct sgttyb *tp);
quota(Q_SETUID, 0, 0, 0);
/* create a dummy user */
- bzero (&nouser, sizeof(nouser));
+ memset(&nouser, 0, sizeof(nouser));
nouser.pw_name = "";
nouser.pw_passwd = "*";
nouser.pw_dir = nouser.pw_shell = "";
ttyn = ttyname(0);
if (ttyn == (char *)0 || *ttyn == '\0')
ttyn = "/dev/tty??";
- tty = rindex(ttyn, '/');
+ tty = strrchr(ttyn, '/');
if (tty == NULL)
tty = ttyn;
else
setenv("USER=", pwd->pw_name, 1);
setenv("PATH=", ":/usr/ucb:/bin:/usr/bin", 0);
- if ((namep = rindex(pwd->pw_shell, '/')) == NULL)
+ if ((namep = strrchr(pwd->pw_shell, '/')) == NULL)
namep = pwd->pw_shell;
else
namep++;
char *term,
struct sgttyb *tp)
{
- register char *cp = index(term, '/'), **cpp;
+ register char *cp = strchr(term, '/'), **cpp;
char *speed;
if (cp) {
*cp++ = '\0';
speed = cp;
- cp = index(speed, '/');
+ cp = strchr(speed, '/');
if (cp)
*cp++ = '\0';
for (cpp = speeds; cpp < &speeds[NSPEEDS]; cpp++)
pheader[5] = 1; /* NFS protocol exporter # */
/* copy stuff in */
- bcopy(pheader, space, sizeof(pheader));
+ memcpy(space, pheader, sizeof(pheader));
tp = space + sizeof(pheader);
/* finally setup the pioctl call's parameters */
blob.in = space;
blob.out_size = 0;
blob.out = (char *) 0;
- bcopy(&setp, tp, sizeof(afs_int32));
+ memcpy(tp, &setp, sizeof(afs_int32));
tp += sizeof(afs_int32);
strcpy(tp, sysname);
blob.in_size += sizeof(afs_int32) + strlen(sysname) + 1;
if (strcmp(clientName.name, "afs") != 0) continue; /* wrong ticket service */
/* copy stuff in */
- bcopy(pheader, tbuffer, sizeof(pheader));
+ memcpy(tbuffer, pheader, sizeof(pheader));
tp = tbuffer + sizeof(pheader);
- bcopy(&index, tp, sizeof(afs_int32));
+ memcpy(tp, &index, sizeof(afs_int32));
tp += sizeof(afs_int32);
iob.in = tbuffer;
iob.in_size = sizeof(afs_int32) + sizeof(pheader);
else if (code == 0) {
/* check to see if this is the right cell/realm */
tp = tbuffer;
- bcopy(tp, &temp, sizeof(afs_int32)); /* get size of secret token */
+ memcpy(&temp, tp, sizeof(afs_int32)); /* get size of secret token */
tktLen = temp; /* remember size of ticket */
tp += sizeof(afs_int32);
stp = tp; /* remember where ticket is, for later */
tp += temp; /* skip ticket for now */
- bcopy(tp, &temp, sizeof(afs_int32)); /* get size of clear token */
+ memcpy(&temp, tp, sizeof(afs_int32)); /* get size of clear token */
if (temp != sizeof(struct ClearToken)) return KTC_ERROR;
tp += sizeof(afs_int32); /* skip length */
- bcopy(tp, &ct, temp); /* copy token for later use */
+ memcpy(&ct, tp, temp); /* copy token for later use */
tp += temp; /* skip clear token itself */
tp += sizeof(afs_int32); /* skip primary flag */
/* tp now points to the cell name */
gotit = 1;
maxLen = sizeof(token) - sizeof(struct ktc_token) + MAXKTCTICKETLEN;
if (maxLen < tktLen) return KTC_TOOBIG;
- bcopy(stp, token.ticket, tktLen);
+ memcpy(token.ticket, stp, tktLen);
token.startTime = ct.BeginTimestamp;
token.endTime = ct.EndTimestamp;
if (ct.AuthHandle == -1) ct.AuthHandle = 999;
token.kvno = ct.AuthHandle;
- bcopy(ct.HandShakeKey, &token.sessionKey, sizeof(struct ktc_encryptionKey));
+ memcpy(&token.sessionKey, ct.HandShakeKey, sizeof(struct ktc_encryptionKey));
token.ticketLen = tktLen;
if ((token.kvno == 999) || /* old style bcrypt ticket */
(ct.BeginTimestamp && /* new w/ prserver lookup */
pheader[5] = 1; /* NFS protocol exporter # */
/* copy stuff in */
- bcopy(pheader, space, sizeof(pheader));
+ memcpy(space, pheader, sizeof(pheader));
/* finally setup the pioctl call's parameters */
blob.in_size = sizeof(pheader);
pheader[5] = 1; /* NFS protocol exporter # */
/* copy in the header */
- bcopy(pheader, space, sizeof(pheader));
+ memcpy(space, pheader, sizeof(pheader));
tp = space + sizeof(pheader);
/* copy in the size of the encrypted part */
- bcopy(&theTicket.ticketLen, tp, sizeof(afs_int32));
+ memcpy(tp, &theTicket.ticketLen, sizeof(afs_int32));
tp += sizeof(afs_int32);
/* copy in the ticket itself */
- bcopy(theTicket.ticket, tp, theTicket.ticketLen);
+ memcpy(tp, theTicket.ticket, theTicket.ticketLen);
tp += theTicket.ticketLen;
/* copy in "clear token"'s size */
temp = sizeof(struct ClearToken);
- bcopy(&temp, tp, sizeof(afs_int32));
+ memcpy(tp, &temp, sizeof(afs_int32));
tp += sizeof(afs_int32);
/* create the clear token and copy *it* in */
ct.AuthHandle = theTicket.kvno; /* where we hide the key version # */
- bcopy(&theTicket.sessionKey, ct.HandShakeKey, sizeof(ct.HandShakeKey));
+ memcpy(ct.HandShakeKey, &theTicket.sessionKey, sizeof(ct.HandShakeKey));
ct.ViceId = auid;
ct.BeginTimestamp = theTicket.startTime;
ct.EndTimestamp = theTicket.endTime;
- bcopy(&ct, tp, sizeof(ct));
+ memcpy(tp, &ct, sizeof(ct));
tp += sizeof(ct);
/* copy in obsolete primary flag */
temp = 0;
- bcopy(&temp, tp, sizeof(afs_int32));
+ memcpy(tp, &temp, sizeof(afs_int32));
tp += sizeof(afs_int32);
/* copy in cell name, null terminated */
strcpy(tp, server.cell);
printf("knfs: unknown host '%s'.\n", tp);
return -1;
}
- bcopy(the->h_addr, &addr, sizeof(afs_int32));
+ memcpy(&addr, the->h_addr, sizeof(afs_int32));
uid = -1;
if (as->parms[1].items) {
code = util_GetInt32(tp = as->parms[1].items->data, &uid);
{
/* read a password from stdin, stop on \n or eof */
register int i, tc;
- bzero(gpbuf, len);
+ memset(gpbuf, 0, len);
for(i=0;i<len;i++) {
tc = fgetc(stdin);
if (tc == '\n' || tc == EOF) break;
#endif
/* blow away command line arguments */
- for (i=1; i<zero_argc; i++) bzero (zero_argv[i], strlen(zero_argv[i]));
+ for (i=1; i<zero_argc; i++) memset(zero_argv[i], 0, strlen(zero_argv[i]));
zero_argc = 0;
/* first determine quiet flag based on -pipe switch */
*/
foundPassword = 1;
strncpy (passwd, as->parms[aPASSWORD].items->data, sizeof(passwd));
- bzero (as->parms[aPASSWORD].items->data,
- strlen(as->parms[aPASSWORD].items->data));
+ memset(as->parms[aPASSWORD].items->data, 0, strlen(as->parms[aPASSWORD].items->data));
}
if (as->parms[aNEWPASSWORD].items) {
foundNewPassword = 1;
strncpy (npasswd, as->parms[aNEWPASSWORD].items->data,
sizeof(npasswd));
- bzero (as->parms[aNEWPASSWORD].items->data,
- strlen(as->parms[aNEWPASSWORD].items->data));
+ memset(as->parms[aNEWPASSWORD].items->data, 0, strlen(as->parms[aNEWPASSWORD].items->data));
}
if (!foundExplicitCell) strcpy (realm, lcell);
code = read_pass (passwd, sizeof(passwd), "Old password: ", 0);
if (code || (strlen (passwd) == 0)) {
if (code) code = KAREADPW;
- bzero (&mitkey, sizeof(mitkey));
- bzero (&key, sizeof(key));
- bzero (passwd, sizeof(passwd));
+ memset(&mitkey, 0, sizeof(mitkey));
+ memset(&key, 0, sizeof(key));
+ memset(passwd, 0, sizeof(passwd));
if (code) com_err (rn, code, "reading password");
exit (1);
}
printf ("Mismatch - ");
goto no_change;
}
- bzero (verify, sizeof(verify));
+ memset(verify, 0, sizeof(verify));
}
}
if (code = password_bad (npasswd)) { /* assmt here! */
#endif
ka_StringToKey (npasswd, realm, &newkey);
des_string_to_key(npasswd, &newmitkey);
- bzero (npasswd, sizeof(npasswd));
+ memset(npasswd, 0, sizeof(npasswd));
if (lexplicit) ka_ExplicitCell (realm, serverList);
strncpy (pass8, passwd, 8);
pass8[8] = 0;
ka_StringToKey (pass8, realm, &key);
- bzero (pass8, sizeof(pass8));
- bzero (passwd, sizeof(passwd));
+ memset(pass8, 0, sizeof(pass8));
+ memset(passwd, 0, sizeof(passwd));
code = ka_GetAdminToken (pw->pw_name, instance, realm,
&key, ADMIN_LIFETIME, &token, /*!new*/0);
#ifdef notdef
dess2k=0;
}
- bzero (&mitkey, sizeof(mitkey));
- bzero (&key, sizeof(key));
+ memset(&mitkey, 0, sizeof(mitkey));
+ memset(&key, 0, sizeof(key));
if (code == KAUBIKCALL) com_err (rn, code, "(Authentication Server unavailable, try later)");
else if (code) {
if (code == KABADREQUEST)
code = ka_ChangePassword (pw->pw_name, instance, conn, 0, &newmitkey);
else
code = ka_ChangePassword (pw->pw_name, instance, conn, 0, &newkey);
- bzero (&newkey, sizeof(newkey));
- bzero (&newmitkey, sizeof(newmitkey));
+ memset(&newkey, 0, sizeof(newkey));
+ memset(&newmitkey, 0, sizeof(newmitkey));
if (code) {
char * reason;
reason = (char *) error_message(code);
else printf("Password changed.\n\n");
}
}
- bzero (&newkey, sizeof(newkey));
- bzero (&newmitkey, sizeof(newmitkey));
+ memset(&newkey, 0, sizeof(newkey));
+ memset(&newmitkey, 0, sizeof(newmitkey));
/* Might need to close down the ubik_Client connection */
if (conn) {
no_change: /* yuck, yuck, yuck */
if (code) com_err (rn, code, "getting new password");
no_change_no_msg:
- bzero (&key, sizeof(key));
- bzero (npasswd, sizeof(npasswd));
+ memset(&key, 0, sizeof(key));
+ memset(npasswd, 0, sizeof(npasswd));
printf("Password for '%s' in cell '%s' unchanged.\n\n", pw->pw_name, cell);
terminate_child();
exit (code ? code : 1);
#define putstr(name) if ((slen = strlen(name)) >= MAXKTCNAMELEN) return -1;\
else strcpy (answer, name), answer += slen+1
#define putint(num) num = htonl(num), \
- bcopy (&num, answer, sizeof(afs_int32)), \
+ memcpy(answer, &num, sizeof(afs_int32)), \
answer += sizeof(afs_int32)
#define getstr(name) if ((slen = strlen(packet)) >= sizeof(name)) return -1;\
strcpy (name, packet), packet += slen+1
-#define getint(num) bcopy (packet, &num, sizeof(afs_int32)), \
+#define getint(num) memcpy(&num, packet, sizeof(afs_int32)), \
num = ktohl (byteOrder, num), \
packet += sizeof(afs_int32)
if (ticketLen > 255) return KAANSWERTOOLONG;
if (kvno > 255) return KAANSWERTOOLONG;
- bcopy (sessionKey, answer, sizeof(*sessionKey));
+ memcpy(answer, sessionKey, sizeof(*sessionKey));
answer += sizeof(*sessionKey);
putstr (sname);
putstr (sinst);
*answer++ = life;
*answer++ = (unsigned char) kvno;
*answer++ = (unsigned char) ticketLen;
- bcopy (ticket, answer, ticketLen);
+ memcpy(answer, ticket, ticketLen);
answer += ticketLen;
putint (start);
*answer++ = (unsigned char) kvno;
{ short w = (short) cipherLen;
w = htons(w);
- bcopy (&w, answer, sizeof(short));
+ memcpy(answer, &w, sizeof(short));
answer += sizeof(short);
}
- bcopy (cipher, answer, cipherLen);
+ memcpy(answer, cipher, cipherLen);
return 0;
}
"null realm name not allowed");
return;
}
- bcopy (packet, &startTime, sizeof(startTime));
+ memcpy(&startTime, packet, sizeof(startTime));
packet += sizeof(startTime);
startTime = ktohl (pkt->byteOrder, startTime);
pkt->time = startTime;
err_packet (ksoc, pkt, KERB_ERR_TEXT_LENGTH, "ticket too long");
return;
}
- bcopy (packet, ticket, ticketLen);
+ memcpy(ticket, packet, ticketLen);
packet += ticketLen;
if (authLen > sizeof(auth)) {
err_packet (ksoc, pkt, KERB_ERR_TEXT_LENGTH, "authenticator too long");
return;
}
- bcopy (packet, auth, authLen);
+ memcpy(auth, packet, authLen);
pkt->rest = packet + authLen;
code = UDP_GetTicket (ksoc, pkt, kvno, realm, ticket, ticketLen, auth, authLen);
if (code) {
if (inited) return -1;
inited = 1;
- bzero (&taddr, sizeof(taddr));
+ memset(&taddr, 0, sizeof(taddr));
krb4name = "kerberos4";
sp = getservbyname(krb4name, "udp");
taddr.sin_family = AF_INET; /* added for NCR port */
static char gpbuf[BUFSIZ];
/* read a password from stdin, stop on \n or eof */
register int i, tc;
- bzero(gpbuf, sizeof(gpbuf));
+ memset(gpbuf, 0, sizeof(gpbuf));
for(i=0; i<(sizeof(gpbuf)-1); i++) {
tc = fgetc(stdin);
if (tc == '\n' || tc == EOF) break;
char *reason; /* string describing errors */
/* blow away command line arguments */
- for (i=1; i<zero_argc; i++) bzero (zero_argv[i], strlen(zero_argv[i]));
+ for (i=1; i<zero_argc; i++) memset(zero_argv[i], 0, strlen(zero_argv[i]));
zero_argc = 0;
/* first determine quiet flag based on -silent switch */
*/
foundPassword = 1;
strncpy (passwd, as->parms[aPASSWORD].items->data, sizeof(passwd));
- bzero (as->parms[aPASSWORD].items->data,
- strlen(as->parms[aPASSWORD].items->data));
+ memset(as->parms[aPASSWORD].items->data, 0, strlen(as->parms[aPASSWORD].items->data));
}
if (as->parms[aLIFETIME].items) {
string_to_key(key_string, k);
lose:
- bzero(key_string, sizeof (key_string));
+ memset(key_string, 0, sizeof (key_string));
return ok;
}
}
#ifdef BSDUNIX
- bcopy(env, old_env, sizeof(env));
+ memcpy(old_env, env, sizeof(env));
if (setjmp(env))
goto lose;
lose:
if (!ok)
- bzero(s, max);
+ memset(s, 0, max);
#ifdef BSDUNIX
/* turn echo back on */
tty_state.sg_flags |= ECHO;
if (ioctl(0,TIOCSETP,&tty_state))
ok = 0;
pop_signals();
- bcopy(old_env, env, sizeof(env));
+ memcpy(env, old_env, sizeof(env));
#else
#if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV)
ttyb.c_lflag = flags;
#endif
#endif
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 */
}
nentries = (info.st_size-(UBIK_HEADERSIZE + header.headerSize)) / sizeof(struct kaentry);
entrys = (int *)malloc(nentries * sizeof(int));
- bzero(entrys, nentries * sizeof(int));
+ memset(entrys, 0, nentries * sizeof(int));
for (i=0, index=sizeof(header); i<nentries; i++, index+=sizeof(struct kaentry)) {
readDB (index, &entry, sizeof(entry));
static char gpbuf[BUFSIZ];
/* read a password from stdin, stop on \n or eof */
register int i, tc;
- bzero(gpbuf, sizeof(gpbuf));
+ memset(gpbuf, 0, sizeof(gpbuf));
for(i=0; i<(sizeof(gpbuf)-1); i++) {
tc = fgetc(stdin);
if (tc == '\n' || tc == EOF) break;
char *reason; /* string describing errors */
/* blow away command line arguments */
- for (i=1; i<zero_argc; i++) bzero (zero_argv[i], strlen(zero_argv[i]));
+ for (i=1; i<zero_argc; i++) memset(zero_argv[i], 0, strlen(zero_argv[i]));
zero_argc = 0;
/* first determine quiet flag based on -silent switch */
*/
foundPassword = 1;
strncpy (passwd, as->parms[aPASSWORD].items->data, sizeof(passwd));
- bzero (as->parms[aPASSWORD].items->data,
- strlen(as->parms[aPASSWORD].items->data));
+ memset(as->parms[aPASSWORD].items->data, 0, strlen(as->parms[aPASSWORD].items->data));
}
if (as->parms[aLIFETIME].items) {
}
code = storecode;
- bzero (passwd, sizeof(passwd));
+ memset(passwd, 0, sizeof(passwd));
if (code) {
if (!Silent) {
fprintf (stderr,
password[truncate[i]] = 0;
ka_StringToKey (password, "andy.edu", &key);
ka_ReadBytes (answer[i], &correct_key, sizeof(key));
- if (bcmp (&key, &correct_key, sizeof(key)) != 0) {
+ if (memcmp (&key, &correct_key, sizeof(key)) != 0) {
printf ("String to key error converting '%s'; should be '%s' instead got '",
password, answer[i]);
ka_PrintBytes (&key, sizeof(key));
exit (1);
}
}
- bzero (password, sizeof(password));
+ memset(password, 0, sizeof(password));
j=0; /* current password length */
for (i=(sizeof(truncate)/sizeof(int))-1; i>=0; i--) {
while (j<truncate[i]) {
}
ka_StringToKey (password, "andy.edu", &key);
ka_ReadBytes (answer[i], &correct_key, sizeof(key));
- if (bcmp (&key, &correct_key, sizeof(key)) != 0) {
+ if (memcmp (&key, &correct_key, sizeof(key)) != 0) {
printf ("String to key error converting '%s'; should be '%s' instead got '",
password, answer[i]);
ka_PrintBytes (&key, sizeof(key));
{ struct ktc_encryptionKey badkey;
- bcopy (&key, &badkey, sizeof(badkey));
+ memcpy(&badkey, &key, sizeof(badkey));
*(int *)&badkey ^= 1; /* toggle some bit */
code = ubik_Call (KAM_SetPassword, conn, 0, name, inst, 0, badkey);
if (code != KABADKEY) {
com_err (whoami, code, "Trying to set bad key");
exit(1);
}
- bzero (&badkey, sizeof(badkey));
+ memset(&badkey, 0, sizeof(badkey));
code = ubik_Call (KAM_SetPassword, conn, 0, name, inst, 0, badkey);
if (code != KABADKEY) goto abort_5;
code = ubik_Call (KAM_SetPassword, conn, 0, name, inst, 9999, key);
code = ubik_Call (KAM_GetEntry, conn, 0, name, inst, KAMAJORVERSION, &entry);
if (code) goto abort_3;
- if (bcmp (&tentry, &entry, sizeof(entry)) != 0) {
+ if (memcmp (&tentry, &entry, sizeof(entry)) != 0) {
printf ("Entries obtained not the same!\n");
print_entry (&entry, name, inst);
}
}
/* try bashing a ticket to make sure it fails to work */
- bzero (atoken.ticket+10, 1);
+ memset(atoken.ticket+10, 0, 1);
code = ka_AuthServerConn (localCell, KA_MAINTENANCE_SERVICE, &atoken, &conn);
if (code) {
com_err (whoami, code, "contacting admin server with bashed ticket");
if (as->parms[13].items) { /* if password specified */
strncpy (passwd, as->parms[13].items->data, sizeof(passwd));
- bzero (as->parms[13].items->data, strlen (as->parms[13].items->data));
+ memset(as->parms[13].items->data, 0, strlen (as->parms[13].items->data));
} else {
char msg[sizeof(name)+15];
if (as->parms[12].items) strcpy (msg, "Admin Password: ");
/*Copy in the sizes and bodies of the secret and clear tokens*/
inbuff.sTokenSize = sizeof(EncryptedSecretToken);
- bcopy(&sToken, (char *)&inbuff.stoken, sizeof(EncryptedSecretToken));
+ memcpy((char *)&inbuff.stoken, &sToken, sizeof(EncryptedSecretToken));
inbuff.cTokenSize = sizeof(ClearToken);
- bcopy(&cToken, (char*)&inbuff.ctoken, sizeof(ClearToken));
+ memcpy((char*)&inbuff.ctoken, &cToken, sizeof(ClearToken));
/* Copy in the Primary ID flag and the cell name */
#if DB_CELLS
(token.startTime != 0) ||
(token.endTime != cToken.EndTimestamp) ||
(token.ticketLen != sizeof(sToken)) ||
- (bcmp (&cToken.HandShakeKey, &token.sessionKey, sizeof(struct ktc_encryptionKey)) != 0) ||
- (bcmp (&sToken, token.ticket, sizeof(sToken)) != 0)) {
+ (memcmp (&cToken.HandShakeKey, &token.sessionKey, sizeof(struct ktc_encryptionKey)) != 0) ||
+ (memcmp (&sToken, token.ticket, sizeof(sToken)) != 0)) {
fprintf (stdout, "Auth2 token was bad\n");
PrintAuthentication (stdout, server, &token, &client);
return 1;
blob.in_size = sizeof(long);
blob.in = space;
blob.out = space;
- bcopy(&i, space, sizeof(long));
+ memcpy(space, &i, sizeof(long));
code = pioctl(0, VIOCGETCELL, &blob, 1);
if (code < 0) {
if (errno == EDOM) break; /* done with the list */
if (verbose > 1) {
printf("Cell %s on hosts", cellname);
for (j=0; j < 8; j++) {
- bcopy(space + j*sizeof(long), &clear, sizeof(long));
+ memcpy(&clear, space + j*sizeof(long), sizeof(long));
if (clear == 0) break;
#if SLOW
tcp = hostutil_GetNameByINet(clear);
/* First check for various pathological cases */
strcpy (server.cell, "foo.bar.baz");
- bcopy (&token, &ntoken, sizeof(ntoken));
+ memcpy(&ntoken, &token, sizeof(ntoken));
code = ktc_SetToken (&server, &ntoken, &client, 0);
if (code != KTC_NOCELL) {
com_err (whoami, code, "should have gotten bad pioctl error calling SetToken with bogus cell name");
com_err (whoami, code, "calling SetToken with bogus client cell");
goto failed;
}
- bcopy (&token, &ntoken, sizeof(ntoken));
+ memcpy(&ntoken, &token, sizeof(ntoken));
if (token.kvno == 999) ntoken.kvno = 99;
/* Now check out SetToken parsing of specially formed names */
if (as->parms[13].items) { /* if password specified */
strncpy (passwd, as->parms[13].items->data, sizeof(passwd));
- bzero (as->parms[13].items->data, strlen (as->parms[13].items->data));
+ memset(as->parms[13].items->data, 0, strlen (as->parms[13].items->data));
} else {
char msg[sizeof(name)+15];
if (as->parms[12].items) strcpy (msg, "Admin Password: ");
if (!doAuth) {
ka_StringToKey (passwd, cell, &key);
- bzero (passwd, sizeof(passwd));
+ memset(passwd, 0, sizeof(passwd));
}
if (hostUsage) {
- bzero (serversUse, sizeof(serversUse));
- bzero (serversHost, sizeof(serversHost));
+ memset(serversUse, 0, sizeof(serversUse));
+ memset(serversHost, 0, sizeof(serversHost));
}
startTime = time(0);
struct ktc_token token;
code = ka_GetAuthToken (name, instance, realm, key, lifetime, pwexpires);
- bzero (key, sizeof(*key));
+ memset(key, 0, sizeof(*key));
if (code) return code;
code = ka_GetAFSTicket (name, instance, realm, lifetime, flags);
return code;
strncpy (pass8, password, 8);
pass8[8] = 0;
ka_StringToKey (pass8, realm, &key);
- bzero (pass8, sizeof(pass8));
+ memset(pass8, 0, sizeof(pass8));
code = GetTickets (name, instance, realm, &key, lifetime,
password_expires, dosetpag);
if (code == 0) {
static int AddToList();
static int GetFromList();
-#ifdef AFS_ALPHA_ENV
-extern char *index();
-#endif
-
struct freeListEntry {
struct freeListEntry *next;
int size;
acl_NewExternalACL(acl->total, elist);
nextc = *elist;
lids.idlist_val = (afs_int32 *)malloc(ACL_MAXENTRIES *sizeof(afs_int32));
- bzero(lids.idlist_val, ACL_MAXENTRIES * sizeof(afs_int32));
+ memset(lids.idlist_val, 0, ACL_MAXENTRIES * sizeof(afs_int32));
lids.idlist_len = acl->total;
lnames.namelist_len = 0;
lnames.namelist_val = (prname *)0;
if (sscanf(nextc, "%s\t%d\n", lnames.namelist_val[i], &k) != 2)
return(-1);
(*acl)->entries[i].rights = k;
- nextc = (char *) (index(nextc, '\n'));
+ nextc = (strchr(nextc, '\n'));
nextc ++; /* 1 + index can cast ptr to integer */
}
j=i;
for (i = (*acl)->total - 1; i >= (*acl)->total - (*acl)->negative; i--,j++) {
if (sscanf(nextc, "%s\t%d\n", lnames.namelist_val[j], &((*acl)->entries[j].rights)) != 2)
return(-1);
- nextc = (char *) (index(nextc, '\n'));
+ nextc = (strchr(nextc, '\n'));
nextc ++;
}
lids.idlist_len = 0;
int rc = 0;
strcpy(parentDirectory, directory);
- tp = rindex(parentDirectory, '/');
+ tp = strrchr(parentDirectory, '/');
if (tp) {
*tp = 0;
rc = 1;
register afs_int32 code;
struct ptemp *tp;
- bzero(ak, sizeof(*ak));
+ memset(ak, 0, sizeof(*ak));
code = LocalParseLine(adate, &tt);
if (code) return -1;
for(;tt;tt=tt->next) {
int rc = 0;
afs_status_t tst = 0;
- bzero(dest, sizeof(struct nvldbentry));
+ memset(dest, 0, sizeof(struct nvldbentry));
strncpy(dest->name, source->name, sizeof(dest->name));
for (i = 0; i < source->nServers; i++) {
dest->serverNumber[i] = source->serverNumber[i];
afs_status_t tst = 0;
int rc = 0;
- bzero(dest, sizeof(struct vldbentry));
+ memset(dest, 0, sizeof(struct vldbentry));
strncpy(dest->name, source->name, sizeof(dest->name));
if (source->nServers <= OMAXNSERVERS) {
for (i = 0; i < source->nServers; i++) {
goto fail_VLDB_IsSameAddrs;
}
- bzero(&attrs, sizeof(attrs));
+ memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_IPADDR;
attrs.ipaddr = serv1;
- bzero(&addrs, sizeof(addrs));
- bzero(&uuid, sizeof(uuid));
+ memset(&addrs, 0, sizeof(addrs));
+ memset(&uuid, 0, sizeof(uuid));
tst = ubik_Call(VL_GetAddrsU, cellHandle->vos, 0, &attrs, &uuid,
&unique, &nentries, &addrs);
if (tst) {
int releasecount = 0;
struct volser_status volstatus;
- bzero((char *)remembertime, sizeof(remembertime));
- bzero((char *)&results, sizeof(results));
+ memset((char *)remembertime, 0, sizeof(remembertime));
+ memset((char *)&results, 0, sizeof(results));
tst = ubik_Call(VL_SetLock, cellHandle->vos, 0, afromvol, RWVOL, VLOP_RELEASE);
if ((tst) && (tst != VL_RERELEASE)) {
strcpy(vname, entry.name);
strcat(vname, ".readonly");
- bzero(&cookie,sizeof(cookie));
+ memset(&cookie, 0, sizeof(cookie));
strncpy(cookie.name, vname, VOLSER_OLDMAXVOLNAME);
cookie.type = ROVOL;
cookie.parent = entry.volumeId[RWVOL];
goto fail_UV_ReleaseVolume;
}
- bzero (replicas, (sizeof(struct replica)*nservers+1));
- bzero (times, (sizeof(struct release)*nservers+1));
- bzero (toconns, (sizeof(struct rx_connection *)*nservers+1));
- bzero (results.manyResults_val, (sizeof(afs_int32)*nservers+1));
+ memset(replicas, 0, (sizeof(struct replica)*nservers+1));
+ memset(times, 0, (sizeof(struct release)*nservers+1));
+ memset(toconns, 0, (sizeof(struct rx_connection *)*nservers+1));
+ memset(results.manyResults_val, 0, (sizeof(afs_int32)*nservers+1));
/* Create a transaction on the cloned volume */
tst = AFSVolTransCreate(fromconn, cloneVolId, afrompart, ITBusy, &fromtid);
int index, same;
- bzero(&cookie,sizeof(cookie));
+ memset(&cookie, 0, sizeof(cookie));
islocked = 0;
success = 0;
error = 0;
}
else if(tst && (tst == VL_NOENT)) { /*entry doesnot exist */
/*set up a vldb entry for elem */
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
strncpy(entry.name,elem.name,VOLSER_OLDMAXVOLNAME);
if(elem.isValid[RWVOL]) { /*rw exists */
entry.flags |= RW_EXISTS;
for(si = 0;si != -1; si=nsi) {
/*initialize to hint the stub to alloc space */
- bzero(&arrayEntries, sizeof(arrayEntries));
+ memset(&arrayEntries, 0, sizeof(arrayEntries));
if (!VLDB_ListAttributes(cellHandle, &attributes, &nentries,
&arrayEntries, &tst)) {
goto fail_UV_SyncServer;
string_to_key(argv[2], skey);
now = time(0);
- bcopy(&now, session, 4); /* but this is only a test pgm */
- bcopy(&now, session+4, 4);
+ memcpy(session, &now, 4); /* but this is only a test pgm */
+ memcpy(session+4, &now, 4);
code = tkt_MakeTicket(token.ticket, &token.ticketLen, skey, argv[1], "", cellName,
now-300, now+25*3600, session, /* host */ 0, "afs", "");
if (code) {
strcpy(sname.cell, cellName);
token.startTime = 0;
token.endTime = 0x7fffffff;
- bcopy(session, &token.sessionKey, 8);
+ memcpy(&token.sessionKey, session, 8);
token.kvno = 0;
code = ktc_SetToken (&sname, &token, (char *) 0, 0);
if (code) {
*/
foundPassword = TRUE;
strcpy(passwd, argv[currArg]);
- bzero(argv[currArg], strlen(passwd));
+ memset(argv[currArg], 0, strlen(passwd));
currArg++;
#if DB_ARGPARSE
fprintf(stderr, "Found password: '%s' (%d chars), erased from arg list (now '%s').\n",
(void)signal(SIGTSTP, SIG_IGN);
tbuf[0] = '-';
- (void)strcpy(tbuf + 1, (p = rindex(shell, '/')) ? p + 1 : shell);
+ (void)strcpy(tbuf + 1, (p = strrchr(shell, '/')) ? p + 1 : shell);
sia_ses_release(&entity);
execlp(shell, tbuf, 0);
(void)printf("login: no shell: %s.\n", strerror(errno));
if(!fgets(string, size, stream) || ferror(stream) || errno == EINTR)
return NULL;
else
- if(cp=index(string, '\n'))
+ if(cp=strchr(string, '\n'))
*cp = '\0';
else
while((c=getc(stdin)) != '\n' && c != EOF && errno != EINTR)
(cnt + 2)));
if (!P)
return(-1);
- bcopy(environ, P, cnt * sizeof(char *));
+ memcpy(P, environ, cnt * sizeof(char *));
environ = P;
}
environ[cnt + 1] = NULL;
if (!ut.ut_name[0] ||
strncmp(ut.ut_line, line, sizeof(ut.ut_line)))
continue;
- bzero(ut.ut_name, sizeof(ut.ut_name));
+ memset(ut.ut_name, 0, sizeof(ut.ut_name));
#if !defined(AIX) && !defined(AFS_SUN5_ENV)
- bzero(ut.ut_host, sizeof(ut.ut_host));
+ memset(ut.ut_host, 0, sizeof(ut.ut_host));
#endif /* AIX */
(void)time(&ut.ut_time);
(void)fseek(fp, (long)-sizeof(struct utmp), L_INCR);
#else
#define FDS_P_POS (sizeof(int)*8)
#define INTS_PER_FDS(x) (((x)+(FDS_P_POS-1)) / FDS_P_POS)
-#define FD_N_ZERO(nfds, x) bzero((char*)(x), (INTS_PER_FDS(nfds))*sizeof(int))
+#define FD_N_ZERO(nfds, x) memset((char*)(x), 0, (INTS_PER_FDS(nfds))*sizeof(int))
#endif
#if defined(AFS_LINUX22_ENV) && (__GLIBC_MINOR__ > 0)
{
PROCESS lp;
assert(lp = (PROCESS) malloc(sizeof (*lp)));
- bzero((char *) lp, sizeof(*lp));
+ memset((char *) lp, 0, sizeof(*lp));
if (!name) {
char temp[100];
static procnum;
itv.it_interval = itv.it_value = *slice;
}
- bzero((char *)&action, sizeof(action));
+ memset((char *)&action, 0, sizeof(action));
action.sa_sigaction = AlarmHandler;
action.sa_flags = SA_SIGINFO;
itv.it_value.tv_sec = itv.it_value.tv_usec = 0;
- bzero((char *)&action, sizeof(action));
+ memset((char *)&action, 0, sizeof(action));
action.sa_handler = SIG_DFL;
if ((setitimer(ITIMER_REAL, &itv, (struct itimerval *) 0) == -1) ||
fd_set *IOMGR_AllocFDSet(void)
{
fd_set *tmp = (fd_set*)malloc(sizeof(fd_set));
- bzero((char*)tmp, sizeof(fd_set));
+ memset((char*)tmp, 0, sizeof(fd_set));
return tmp;
}
if (ecount == 1)
lwp_cpptr->eventlist[0] = evlist[0];
else
- bcopy(evlist, lwp_cpptr->eventlist, ecount*sizeof(char *));
+ memcpy(lwp_cpptr->eventlist, evlist, ecount*sizeof(char *));
if (wcount > 0) {
lwp_cpptr -> status = WAITING;
move(lwp_cpptr, &runnable[lwp_cpptr->priority], &blocked);
#include <stdio.h>
extern char *malloc();
-extern char *rindex();
#define maxinputdepth 16
#define maxlinesize 1024
if (*what++ != specialchar)
return nestp->status;
- if (cp = rindex(what,'\n'))
+ if (cp = strrchr(what, '\n'))
*cp = 0;
for (n = 0; n < 2; n++)
{
char *cp, *cp2;
cp = &argv[0][sizeof("-D")-1];
- if (cp2 = rindex(cp,'='))
+ if (cp2 = strrchr(cp, '='))
*cp2++ = 0;
if (cp2 == 0)
cp2 = "";
name = (ac > 0) ? (ac--, *av++) : (ac = 0, "mkntpconf");
(void) strcpy(tempfn, name);
- if ((p = rindex(tempfn, '/')) == 0)
+ if ((p = strrchr(tempfn, '/')) == 0)
p = tempfn;
else
p += 1;
peerline(guava, f);
peerline(cluster1, f);
} else {
- if ((p = index(hostname, '.')) != 0
+ if ((p = strchr(hostname, '.')) != 0
&& strcmp(p+1, "srv.cs.cmu.edu") == 0) {
peerline(papaya, f);
peerline(guava, f);
serv.s_addr = 0;
if ((g = fopen("/etc/attributes", "r")) != NULL) {
while (fgets(line, sizeof(line), g) != NULL) {
- if ((p = index(line, ':')) != 0)
+ if ((p = strchr(line, ':')) != 0)
*p = 0;
if (strcmp(line, papaya.s_name) == 0
|| strcmp(line, guava.s_name) == 0)
continue;
- if ((p = index(line, '.')) == 0
+ if ((p = strchr(line, '.')) == 0
|| strcmp(p+1, "srv.cs.cmu.edu") != 0)
continue;
peerline(serv, f);
argv[host]);
continue;
}
- bcopy(hp->h_addr, (char *) &dst.sin_addr,hp->h_length);
+ memcpy((char *) &dst.sin_addr, hp->h_addr, hp->h_length);
}
- bzero((char *)pkt, sizeof(ntp_data));
+ memset((char *)pkt, 0, sizeof(ntp_data));
pkt->status = NTPVERSION_1 | NO_WARNING | MODE_CLIENT;
pkt->stratum = UNSPECIFIED;
#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
-#define FD_ZERO(p) bzero((char *)(p), sizeof(*(p)))
+#define FD_ZERO(p) memset((char *)(p), 0, sizeof(*(p)))
#endif
#ifndef NBBY
if (debug > 6)
printf ("Zeroing aix_adjtime accumulation: %d %d\n",
cum.tv_sec, cum.tv_usec);
- bzero (&cum, sizeof(cum));
+ memset(&cum, 0, sizeof(cum));
}
int adjtime(newdelta, olddelta)
double j;
extern double drift_comp;
- bzero((char *) &sin, sizeof(sin));
+ memset((char *) &sin, 0, sizeof(sin));
fp = fopen(config, "r");
if (fp == NULL) {
fprintf(stderr,"Problem opening NTP initialization file %s\n",
if (hp = gethostbyname(name)) {
if (hp->h_addrtype != AF_INET)
return (0);
- bcopy((char *) hp->h_addr, (char *) &sin->sin_addr,
- hp->h_length);
+ memcpy((char *) &sin->sin_addr, (char *) hp->h_addr, hp->h_length);
sin->sin_family = hp->h_addrtype;
return (1);
}
sigaction(SIGSEGV, &nsa, NULL);
#endif
(void) gethostname(LocalHostName, sizeof LocalHostName);
- if (p = index(LocalHostName, '.')) {
+ if (p = strchr(LocalHostName, '.')) {
*p++ = '\0';
LocalDomain = p;
}
static struct servent *sp = NULL;
afs_int32 HostAddr;
- bzero((char *) &watcher, sizeof(watcher));
+ memset((char *) &watcher, 0, sizeof(watcher));
watcher.sin_family = AF_INET;
HostAddr = inet_addr(host);
watcher.sin_addr.s_addr = (afs_uint32) HostAddr;
fprintf(stderr,"%s: unknown\n", host);
return 0;
}
- bcopy(hp->h_addr, (char *) &watcher.sin_addr, hp->h_length);
+ memcpy((char *) &watcher.sin_addr, hp->h_addr, hp->h_length);
}
sp = getservbyname("ntp", "udp");
if (sp == 0) {
if (hp == 0)
return (inet_ntoa(f->sin_addr));
- if ((p = index(hp->h_name, '.')) && strcmp(p + 1, LocalDomain) == 0)
+ if ((p = strchr(hp->h_name, '.')) && strcmp(p + 1, LocalDomain) == 0)
*p = '\0';
return (hp->h_name);
}
tty.c_iflag = ICRNL;
tty.c_oflag = 0;
tty.c_lflag = 0;
- bzero((char *)tty.c_cc, sizeof tty.c_cc);
+ memset((char *)tty.c_cc, 0, sizeof tty.c_cc);
tty.c_cc[VMIN] = MIN_READ;
tty.c_cc[VTIME] = 0;
if (ioctl(cfd, TCSETA, &tty) < 0) {
#else /* TCSETA Use older Berkeley style IOCTL's */
- bzero((char *)&tty, sizeof tty);
+ memset((char *)&tty, 0, sizeof tty);
tty.sg_ispeed = tty.sg_ospeed = B9600;
tty.sg_flags = ANYP|CRMOD;
tty.sg_erase = tty.sg_kill = '\0';
/* handle bozo kills right */
{ struct sigaction sa;
- bzero((char *)&sa, sizeof(sa));
+ memset((char *)&sa, 0, sizeof(sa));
sa.sa_handler = terminate;
code = sigaction (SIGTERM, &sa, NULL);
if (code) {
struct sysdata sys;
double delay;
- bzero (&peer, sizeof(peer));
- bzero (&sys, sizeof(sys));
+ memset(&peer, 0, sizeof(peer));
+ memset(&sys, 0, sizeof(sys));
pkt.precision = -6;
peer.precision = pkt.precision;
sys.precision = pkt.precision;
char *emalloc();
char *strcpy();
-char *rindex();
CTREEPTR LocateChildNode();
static char path2[MAXPATHLEN+1]; /* $$get rid of this */
* Copy out the candidate mountpoint's pathname into dir, throwing
* off any leaf component from the original path.
*/
- ep = rindex(path, '/');
+ ep = strrchr(path, '/');
for (sp = path, dp = dir; sp < ep; *dp++ = *sp++);
if (dp == dir)
*dp++ = '/';
/*
* Copy out the parent's pathname into parent.
*/
- ep = rindex(dir, '/');
+ ep = strrchr(dir, '/');
for (sp = dir, dp = parent; sp < ep; *dp++ = *sp++);
if (dp == parent)
*dp++ = '/';
register CTREEPTR np;
np = (CTREEPTR) emalloc(sizeof(CTREE));
- bzero((char *)np, sizeof(CTREE));
+ memset((char *)np, 0, sizeof(CTREE));
return(np);
} /*AllocConfigNode*/
int stripcalled = 0;
#endif
-#ifndef rindex
-extern char *rindex(); /* this should always be defined, shouldn't it? */
-#endif
-
#if defined(AFS_HPUX_ENV) && !defined(AFS_HPUX102_ENV)
utimes(file,tvp)
char *file;
char sets[256];
int i;
- bzero (sets, sizeof(sets));
+ memset(sets, 0, sizeof(sets));
while (*set) sets[(int) *set++] = 1;
i = strlen (s);
while (i > 0) if (sets[(int)s[--i]]) return &s[i];
int
stripName(aname)
char *aname;
- {if (rindex(aname, '.') == 0) return 1;
+ {if (strrchr(aname, '.') == 0) return 1;
else return 0;
}
for (i=0;i<fptr;i++)
{/* figure out name to put as entry name for file */
- tp = rindex(fnames[i], '/');
+ tp = strrchr(fnames[i], '/');
if (tp) newNames[i] = tp+1;
else newNames[i] = fnames[i];
}
id = ntohl(e.id);
if ( ((ntohl(e.flags) & (PRGRP | PRINST)) == 0) &&
- (index(e.name,'@')) ) {
+ (strchr(e.name,'@')) ) {
/* Foreign user */
if (id > misc->maxForId) misc->maxForId = id;
} else {
if (code) return code;
code = WalkNextChain (map, misc, ea, &e);
if (code) return code;
- if (index(e.name,'@') == 0) {
+ if (strchr(e.name,'@') == 0) {
misc->nusers++; /* Not a foreign user */
} else {
misc->nforeigns++; /* A foreign user */
rc = misc->recreate;
idmap = misc->idmap;
- bzero (idmap, misc->idRange*sizeof(misc->idmap[0]));
+ memset(idmap, 0, misc->idRange*sizeof(misc->idmap[0]));
do {
found = 0;
for (ei=createLow; ei<misc->nEntries; ei++) {
if (misc->verbose)
printf ("Database has %d entries\n", n);
map = (char *)malloc (n);
- bzero (map, n);
+ memset(map, 0, n);
misc->nEntries = n;
if (misc->verbose) {
code = -1;
goto abort;
}
- bzero (misc->idmap, misc->idRange*sizeof(misc->idmap[0]));
+ memset(misc->idmap, 0, misc->idRange*sizeof(misc->idmap[0]));
if (misc->verbose) {
printf ("\nChecking entry chains\n");
initialize_u_error_table();
pr_dbaseName = AFSDIR_SERVER_PRDB_FILEPATH;
- bzero (&misc, sizeof(misc));
+ memset(&misc, 0, sizeof(misc));
pr_dbaseName = as->parms[0].items->data; /* -database */
misc.listuheader = (as->parms[1].items ? 1 : 0); /* -uheader */
else printf("location %d\n",pos);
}
else if (!strcmp(op,"du")) {
- bzero(&entry,sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
/* scanf("%d",&pos); */
if (GetInt32 (&pos)) code = PRBADARG;
else code = ubik_Call(PR_DumpEntry, pruclient, 0, pos, &entry);
else if (!strcmp(op,"fih")) {
char tname[128];
struct PrUpdateEntry uentry;
- bzero(&uentry, sizeof(uentry));
+ memset(&uentry, 0, sizeof(uentry));
/* scanf("%s",name); */
if (GetString (name, sizeof(name))) {
code = PRBADARG;
else if (!strcmp(op,"fnh")) {
int tid;
struct PrUpdateEntry uentry;
- bzero(&uentry, sizeof(uentry));
+ memset(&uentry, 0, sizeof(uentry));
/* scanf("%d", &id); */
if (GetInt32 (&id)) {
code = PRBADARG;
if (code) ABORT_WITH(tt,PRPERM);
tempu = FindByID(tt,aid);
if (!tempu) ABORT_WITH(tt,PRNOENT);
- bzero(&uentry,sizeof(uentry));
+ memset(&uentry, 0, sizeof(uentry));
code = pr_ReadEntry(tt,0,tempu,&uentry);
if (code != 0) ABORT_WITH(tt,code);
/* we don't allow groups as members of groups at present */
if (!tempu) ABORT_WITH(tt,PRNOENT);
tempg = FindByID(tt,gid);
if (!tempg) ABORT_WITH(tt,PRNOENT);
- bzero(&uentry,sizeof(uentry));
- bzero(&gentry,sizeof(gentry));
+ memset(&uentry, 0, sizeof(uentry));
+ memset(&gentry, 0, sizeof(gentry));
code = pr_ReadEntry(tt,0,tempu,&uentry);
if (code != 0) ABORT_WITH(tt,code);
code = pr_ReadEntry(tt,0,tempg,&gentry);
aentry->ngroups = tentry.ngroups;
aentry->nusers = tentry.nusers;
aentry->count = tentry.count;
- bzero (aentry->reserved, sizeof(aentry->reserved));
+ memset(aentry->reserved, 0, sizeof(aentry->reserved));
code = ubik_EndTrans(tt);
if (code) return code;
return PRSUCCESS;
entry->nusers = tentry->nusers;
entry->count = tentry->count;
strncpy(entry->name,tentry->name,PR_MAXNAMELEN);
- bzero(entry->reserved, sizeof(entry->reserved));
+ memset(entry->reserved, 0, sizeof(entry->reserved));
bulkentries->prentries_len++;
return 0;
}
fprintf (stderr, "ptserver: couldn't get address of this host.\n");
PT_EXIT(1);
}
- bcopy(th->h_addr,&myHost,sizeof(afs_int32));
+ memcpy(&myHost, th->h_addr, sizeof(afs_int32));
/* get list of servers */
code = afsconf_GetExtendedCellInfo(prdir,(char *)0,"afsprot",
com_err (whoami, code,
"Could not get afs tokens, running unauthenticated.");
- bzero (serverconns, sizeof(serverconns)); /* terminate list!!! */
+ memset(serverconns, 0, sizeof(serverconns)); /* terminate list!!! */
for (i = 0;i<info.numServers;i++)
serverconns[i] = rx_NewConnection
(info.hostAddr[i].sin_addr.s_addr, info.hostAddr[i].sin_port,
extern int pr_realmNameLen;
/* We accept foreign names, so we will deal with '@' later */
- if (index (name, ':') || index(name, '\n')) return 0;
+ if (strchr (name, ':') || strchr(name, '\n')) return 0;
if (strlen (name) >= PR_MAXNAMELEN - pr_realmNameLen - 1) return 0;
return 1;
}
if (ntohl(tentry.flags) & PRGRP) {
if ((tentry.count == 0) && !admin) return PRGROUPEMPTY;
/* terminate prefix at colon if there is one */
- if (prefix = index(tentry.name, ':')) *prefix = 0;
+ if (prefix = strchr(tentry.name, ':')) *prefix = 0;
}
prefix = tentry.name;
}
if ((strcmp (prefix, "system") == 0) && !admin) return PRPERM;
strcpy (name, aname); /* in case aname & cname are same */
- suffix = index(name, ':');
+ suffix = strchr(name, ':');
if (suffix == 0) {
/* sysadmin can make groups w/o ':', but they must still look like
* legal user names. */
}
done:
/* check for legal name with either group rules or user rules */
- if (suffix = index(cname, ':')) {
+ if (suffix = strchr(cname, ':')) {
/* check for confusing characters */
- if (index(cname, '\n') || /* restrict so recreate can work */
- index(suffix+1, ':')) /* avoid multiple colons */
+ if (strchr(cname, '\n') || /* restrict so recreate can work */
+ strchr(suffix+1, ':')) /* avoid multiple colons */
return PRBADNAM;
} else {
if (!CorrectUserName (cname)) return PRBADNAM;
struct prentry tentry, tent;
char *atsign;
- bzero(&tentry, sizeof(tentry));
+ memset(&tentry, 0, sizeof(tentry));
if ((oid == 0) || (oid == ANONYMOUSID)) oid = creator;
return PRBADARG;
}
- atsign = index(aname,'@');
+ atsign = strchr(aname, '@');
if (!atsign) {
/* A normal user or group. Pick an id for it */
if (idflag)
afs_int32 hloc;
if (aid == bid) return PRINCONSISTENT;
- bzero(&hentry,sizeof(hentry));
+ memset(&hentry, 0, sizeof(hentry));
temp = FindByID(at,bid);
if (temp == 0) return PRNOENT;
code = pr_ReadEntry(at, 0, temp, &tentry);
} /* for all coentry slots */
hloc = nptr;
nptr = centry.next;
- bcopy(¢ry,&hentry,sizeof(centry));
+ memcpy(&hentry, ¢ry, sizeof(centry));
} /* while there are coentries */
return PRNOENT;
}
afs_int32 i;
afs_int32 nptr;
- if (index(tentry->name,'@')) {
+ if (strchr(tentry->name,'@')) {
if (tentry->flags & PRGRP) {
/* If there are still foreign user accounts from that cell
don't delete the group */
if (inc_header_word (at, instcount, -1)) return PRDBFAIL;
}
else {
- if (index(tentry->name,'@')) {
+ if (strchr(tentry->name,'@')) {
if (inc_header_word (at, foreigncount, -1)) return PRDBFAIL;
} else {
if (inc_header_word (at, usercount, -1)) return PRDBFAIL;
else {
entry->next = nptr;
}
- bzero(&aentry,sizeof(aentry));
+ memset(&aentry, 0, sizeof(aentry));
aentry.flags |= PRCONT;
aentry.id = entry->id;
aentry.next = 0;
char oldname[PR_MAXNAMELEN];
char *atsign;
- bzero(holder,PR_MAXNAMELEN);
- bzero(temp,PR_MAXNAMELEN);
+ memset(holder, 0, PR_MAXNAMELEN);
+ memset(temp, 0, PR_MAXNAMELEN);
loc = FindByID(at,aid);
if (!loc) return PRNOENT;
code = pr_ReadEntry(at,0,loc,&tentry);
}
}
- atsign = index(tentry.name, '@'); /* check for foreign entry */
+ atsign = strchr(tentry.name, '@'); /* check for foreign entry */
/* Change the owner */
if (oid && (oid != tentry.owner)) {
{
char *newatsign;
- newatsign = index (name, '@');
+ newatsign = strchr(name, '@');
if (newatsign != atsign){ /* if they are the same no problem*/
/*if the pointers are not equal the strings better be */
if ((atsign == NULL) || (newatsign == NULL) ||
prlist *alist;
afs_int32 *size;
{
- if (!(index(tentry->name, '@')))
+ if (!(strchr(tentry->name, '@')))
return (AddToPRList (alist, size, AUTHUSERID));
else
return PRSUCCESS;
if (buf[0] == '\n') break;
if (buf[0] != ' ' && buf[0] != '\t') {
/* grab the group name */
- bzero(gname,PR_MAXNAMELEN);
- bzero(owner,PR_MAXNAMELEN);
+ memset(gname, 0, PR_MAXNAMELEN);
+ memset(owner, 0, PR_MAXNAMELEN);
sscanf(buf,"%s %d",gname,&id);
tmp = buf;
skip(&tmp);
skip(&tmp);
stolower(gname);
- ptr = index(gname,':');
+ ptr = strchr(gname, ':');
strncpy(owner,gname,ptr-gname);
if (strcmp(owner,"system") == 0)
strncpy(owner,"system:administrators",PR_MAXNAMELEN);
}
if (!fail) {
/* read members out of buf and add to the group */
- bzero(name,PR_MAXNAMELEN);
+ memset(name, 0, PR_MAXNAMELEN);
while (sscanf(tmp,"%s",name) != EOF) {
- if (index(name,':') == NULL) {
+ if (strchr(name,':') == NULL) {
/* then it's not a group */
code = pr_AddToGroup(name,gname);
report_error (code, name, gname);
}
if (lnames.namelist_val) free(lnames.namelist_val);
}
- bzero(name,PR_MAXNAMELEN);
+ memset(name, 0, PR_MAXNAMELEN);
skip(&tmp);
}
}
/* if we couldn't create the group, and it wasn't already there, don't try to add more users */
if (fail) continue;
/* read members out of buf and add to the group */
- bzero(name,PR_MAXNAMELEN);
+ memset(name, 0, PR_MAXNAMELEN);
tmp = buf;
tmp++;
while (sscanf(tmp,"%s",name) != EOF) {
- if (index(name,':') == NULL) {
+ if (strchr(name,':') == NULL) {
/* then it's not a group */
code = pr_AddToGroup(name,gname);
report_error (code, name, gname);
}
if (lnames.namelist_val) free(lnames.namelist_val);
}
- bzero(name,PR_MAXNAMELEN);
+ memset(name, 0, PR_MAXNAMELEN);
skip(&tmp);
}
}
exit(2);
}
while ((tmp = fgets(buf,150,fp)) != NULL) {
- bzero(name,PR_MAXNAMELEN);
- bzero(uid,8);
- ptr = index(buf,':');
+ memset(name, 0, PR_MAXNAMELEN);
+ memset(uid, 0, 8);
+ ptr = strchr(buf, ':');
strncpy(name,buf,ptr-buf);
- aptr = index(++ptr,':');
- ptr = index(++aptr,':');
+ aptr = strchr(++ptr, ':');
+ ptr = strchr(++aptr, ':');
strncpy(uid,aptr,ptr-aptr);
id = atoi(uid);
if (verbose)
population = (char *)malloc (sqr(number)*sizeof(char));
nFilled = 0;
- bzero (filled, number);
+ memset(filled, 0, number);
nCleaned = 0;
- bzero (cleaned, number);
- bzero (population, sqr(number));
- bzero (users, number*sizeof(afs_int32));
- bzero (groups, number*sizeof(afs_int32));
+ memset(cleaned, 0, number);
+ memset(population, 0, sqr(number));
+ memset(users, 0, number*sizeof(afs_int32));
+ memset(groups, 0, number*sizeof(afs_int32));
ownerUser = lastGroup = 0;
groupOwners = (afs_int32 *) malloc (number*sizeof(afs_int32));
strncpy (cellinfo.hostName[i], serverList->data, MAXHOSTCHARS);
th = gethostbyname(cellinfo.hostName[i]);
if (!th) return UBADHOST;
- bcopy(th->h_addr, &cellinfo.hostAddr[i].sin_addr, sizeof(afs_int32));
+ memcpy(&cellinfo.hostAddr[i].sin_addr, th->h_addr, sizeof(afs_int32));
cellinfo.hostAddr[i].sin_family = AF_INET;
cellinfo.hostAddr[i].sin_port = 0;
}
struct prentry nentry;
if (ntohl(1) != 1) { /* Need to swap bytes. */
- bzero (&nentry, sizeof(nentry)); /* make sure reseved fields are zero */
+ memset(&nentry, 0, sizeof(nentry)); /* make sure reseved fields are zero */
nentry.flags = htonl(tentry->flags);
nentry.id = htonl(tentry->id);
nentry.cellid = htonl(tentry->cellid);
}
code = ubik_Read(tt, (char *) &nentry, sizeof(struct prentry));
if (code) return (code);
- bzero (tentry, sizeof(*tentry)); /* make sure reseved fields are zero */
+ memset(tentry, 0, sizeof(*tentry)); /* make sure reseved fields are zero */
tentry->flags = ntohl(nentry.flags);
tentry->id = ntohl(nentry.id);
tentry->cellid = ntohl(nentry.cellid);
struct contentry nentry;
if (ntohl(1) != 1) { /* No need to swap */
- bzero (&nentry, sizeof(nentry)); /* make reseved fields zero */
+ memset(&nentry, 0, sizeof(nentry)); /* make reseved fields zero */
nentry.flags = htonl(tentry->flags);
nentry.id = htonl(tentry->id);
nentry.cellid = htonl(tentry->cellid);
}
code = ubik_Read(tt, (char *) &nentry, sizeof(struct contentry));
if (code) return (code);
- bzero (tentry, sizeof(*tentry)); /* make reseved fields zero */
+ memset(tentry, 0, sizeof(*tentry)); /* make reseved fields zero */
tentry->flags = ntohl(nentry.flags);
tentry->id = ntohl(nentry.id);
tentry->cellid = ntohl(nentry.cellid);
register afs_int32 code;
struct prentry tentry;
- bzero(&tentry,sizeof(tentry));
+ memset(&tentry, 0, sizeof(tentry));
tentry.next = ntohl(cheader.freePtr);
tentry.flags |= PRFREE;
cheader.freePtr = htonl(pos);
i = IDHash(aid);
entry = ntohl(cheader.idHash[i]);
if (entry == 0) return entry;
- bzero(&tentry,sizeof(tentry));
+ memset(&tentry, 0, sizeof(tentry));
code = pr_ReadEntry(at, 0, entry, &tentry);
if (code != 0) return 0;
if (aid == tentry.id) return entry;
entry = tentry.nextID;
while (entry != 0) {
- bzero(&tentry,sizeof(tentry));
+ memset(&tentry, 0, sizeof(tentry));
code = pr_ReadEntry(at,0,entry,&tentry);
if (code != 0) return 0;
if (aid == tentry.id) return entry;
i = NameHash(aname);
entry = ntohl(cheader.nameHash[i]);
if (entry == 0) return entry;
- bzero(tentryp,sizeof(struct prentry));
+ memset(tentryp, 0, sizeof(struct prentry));
code = pr_ReadEntry(at, 0, entry, tentryp);
if (code != 0) return 0;
if ((strncmp(aname,tentryp->name,PR_MAXNAMELEN)) == 0) return entry;
entry = tentryp->nextName;
while (entry != 0) {
- bzero(tentryp, sizeof(struct prentry));
+ memset(tentryp, 0, sizeof(struct prentry));
code = pr_ReadEntry(at,0,entry, tentryp);
if (code != 0) return 0;
if ((strncmp(aname,tentryp->name,PR_MAXNAMELEN)) == 0) return entry;
if ((aid == PRBADID) || (aid == 0)) return PRINCONSISTENT;
i = IDHash(aid);
current = ntohl(cheader.idHash[i]);
- bzero(&tentry,sizeof(tentry));
- bzero(&bentry,sizeof(bentry));
+ memset(&tentry, 0, sizeof(tentry));
+ memset(&bentry, 0, sizeof(bentry));
trail = 0;
if (current == 0) return PRSUCCESS; /* already gone */
code = pr_ReadEntry(tt,0,current,&tentry);
if ((aid == PRBADID) || (aid == 0)) return PRINCONSISTENT;
i = IDHash(aid);
- bzero(&tentry,sizeof(tentry));
+ memset(&tentry, 0, sizeof(tentry));
code = pr_ReadEntry(tt,0,loc,&tentry);
if (code) return PRDBFAIL;
tentry.nextID = ntohl(cheader.idHash[i]);
i = NameHash(aname);
current = ntohl(cheader.nameHash[i]);
- bzero(&tentry,sizeof(tentry));
- bzero(&bentry,sizeof(bentry));
+ memset(&tentry, 0, sizeof(tentry));
+ memset(&bentry, 0, sizeof(bentry));
trail = 0;
if (current == 0) return PRSUCCESS; /* already gone */
code = pr_ReadEntry(tt,0,current,&tentry);
struct prentry tentry;
i = NameHash(aname);
- bzero(&tentry,sizeof(tentry));
+ memset(&tentry, 0, sizeof(tentry));
code = pr_ReadEntry(tt,0,loc,&tentry);
if (code) return PRDBFAIL;
tentry.nextName = ntohl(cheader.nameHash[i]);
return PRSUCCESS;
}
nptr = ntohl(cheader.orphan);
- bzero(&bentry,sizeof(bentry));
+ memset(&bentry, 0, sizeof(bentry));
loc = 0;
while (nptr != 0) {
code = pr_ReadEntry(at,0,nptr,&tentry);
}
loc = nptr;
nptr = tentry.nextOwned;
- bcopy(&tentry,&bentry, sizeof(tentry));
+ memcpy(&bentry, &tentry, sizeof(tentry));
}
return PRSUCCESS;
}
if ((gid == 0) || (aid == 0)) return 0;
loc = FindByID(at,gid);
if (!loc) return 0;
- bzero(&tentry,sizeof(tentry));
+ memset(&tentry, 0, sizeof(tentry));
code = pr_ReadEntry(at, 0, loc,&tentry);
if (code) return 0;
if (!(tentry.flags & PRGRP)) return 0;
if (tentry.next) {
loc = tentry.next;
while (loc) {
- bzero(¢ry,sizeof(centry));
+ memset(¢ry, 0, sizeof(centry));
code = pr_ReadCoEntry(at,0,loc,¢ry);
if (code) return 0;
for (i=0;i<COSIZE;i++) {
#endif
int rem;
-char *colon(), *index(), *rindex(), *malloc(), *strcpy();
+char *colon(), *malloc(), *strcpy();
int errs;
#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
extern char *sys_errlist[];
*targ++ = 0;
if (*targ == 0)
targ = ".";
- thost = index(argv[argc - 1], '@');
+ thost = strchr(argv[argc - 1], '@');
if (thost) {
*thost++ = 0;
tuser = argv[argc - 1];
*src++ = 0;
if (*src == 0)
src = ".";
- host = index(argv[i], '@');
+ host = strchr(argv[i], '@');
if (host) {
*host++ = 0;
suser = argv[i];
*src++ = 0;
if (*src == 0)
src = ".";
- host = index(argv[i], '@');
+ host = strchr(argv[i], '@');
if (host) {
*host++ = 0;
suser = argv[i];
error("rcp: %s: not a plain file\n", name);
continue;
}
- last = rindex(name, '/');
+ last = strrchr(name, '/');
if (last == 0)
last = name;
else
error("rcp: %s: %s\n", name, sys_errlist[errno]);
return;
}
- last = rindex(name, '/');
+ last = strrchr(name, '/');
if (last == 0)
last = name;
else
extern errno;
struct passwd *getpwnam();
-char *crypt(), *rindex(), *strncat();
+char *crypt(), *strncat();
#if !defined(AFS_AIX_ENV) && !defined(AFS_HPUX_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SUN5_ENV)
char *sprintf();
#endif
addenvvar("PASSWORD_EXPIRES", pwd_expires_str);
}
#endif
- cp = rindex(pwd->pw_shell, '/');
+ cp = strrchr(pwd->pw_shell, '/');
if (cp)
cp++;
else
syslog(LOG_WARNING,MSGSTR(SETDEBUG,"setsockopt (SO_DEBUG): %m")); /*MSG*/
/* set-up signal handler routines for SRC TRACE ON/OFF support */
- bzero((char *)&sa, sizeof(sa));
+ memset((char *)&sa, 0, sizeof(sa));
sa.sa_mask.losigs = sigmask(SIGUSR2);
sa.sa_handler = trace_handler;
sa.sa_flags = SA_RESTART;
hp = gethostbyname(remotehost);
if (hp)
#if defined(BSD_42)
- if (!bcmp(hp->h_addr, (caddr_t)&fromp->sin_addr,
+ if (!memcmp(hp->h_addr, (caddr_t)&fromp->sin_addr,
sizeof(fromp->sin_addr))) {
#else /* BSD_42 */
for (; hp->h_addr_list[0]; hp->h_addr_list++)
- if (!bcmp(hp->h_addr_list[0], (caddr_t)&fromp->sin_addr,
+ if (!memcmp(hp->h_addr_list[0], (caddr_t)&fromp->sin_addr,
sizeof(fromp->sin_addr))) {
#endif /* BSD_42 */
hostok++;
{
struct sigaction sa;
- bzero((char *)&sa, sizeof(sa));
+ memset((char *)&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL;
sigaction(SIGQUIT, &sa, (struct sigaction *)0);
sa.sa_handler = SIG_DFL;
{
struct sigaction sa;
- bzero((char *)&sa, sizeof(sa));
+ memset((char *)&sa, 0, sizeof(sa));
sa.sa_mask.losigs = sigmask(SIGUSR2);
sa.sa_handler = trace_handler;
sigaction(SIGUSR1, &sa, (struct sigaction *)0);
if (n < 4+sizeof (w) || cp[2] != 's' || cp[3] != 's')
return (0);
oobdata[0] &= ~TIOCPKT_WINDOW; /* we know he heard */
- bcopy(cp+4, (char *)&w, sizeof(w));
+ memcpy((char *)&w, cp+4, sizeof(w));
w.ws_row = ntohs(w.ws_row);
w.ws_col = ntohs(w.ws_col);
w.ws_xpixel = ntohs(w.ws_xpixel);
if (n) {
left -= n;
if (left > 0)
- bcopy(cp+n, cp, left);
+ memcpy(cp, cp+n, left);
fcc -= n;
goto top; /* n^2 */
}
int fd;
{
#ifndef AFS_OSF_ENV
- register char *cp = index(term, '/'), **cpp;
+ register char *cp = strchr(term, '/'), **cpp;
#endif
#ifdef AFS_AIX32_ENV
#ifdef _AIX
if (cp) {
*cp++ = '\0';
speed = cp;
- cp = index(speed, '/');
+ cp = strchr(speed, '/');
if (cp)
*cp++ = '\0';
#ifdef _AIX
#else /* AFS_AIX32_ENV */
#ifdef AFS_OSF_ENV
- register char *cp = index(term+ENVSIZE, '/');
+ register char *cp = strchr(term+ENVSIZE, '/');
char *speed;
struct termios tt;
if (cp) {
*cp++ = '\0';
speed = cp;
- cp = index(speed, '/');
+ cp = strchr(speed, '/');
if (cp)
*cp++ = '\0';
cfsetspeed(&tt, atoi(speed));
tt.c_iflag = TTYDEF_IFLAG;
tt.c_oflag = TTYDEF_OFLAG;
tt.c_lflag = TTYDEF_LFLAG;
- bcopy(ttydefchars, tt.c_cc, sizeof(tt.c_cc));
+ memcpy(tt.c_cc, ttydefchars, sizeof(tt.c_cc));
tcsetattr(fd, TCSAFLUSH, &tt);
#else
struct sgttyb sgttyb;
if (cp) {
*cp++ = '\0';
speed = cp;
- cp = index(speed, '/');
+ cp = strchr(speed, '/');
if (cp)
*cp++ = '\0';
for (cpp = speeds; cpp < &speeds[NSPEEDS]; cpp++)
char *h;
{
char localhost[MAXHOSTNAMELEN];
- char *p1, *p2 = index(h, '.');
+ char *p1, *p2 = strchr(h, '.');
#ifdef AFS_OSF_ENV
char *topdomain();
p1 = topdomain(localhost);
p2 = topdomain(h);
#else
- p1 = index(localhost, '.');
+ p1 = strchr(localhost, '.');
#endif
if (p1 == NULL || p2 == NULL || !strcasecmp(p1, p2))
return(1);
/* (5) sessionKey */
bp = bp + index + 1;
- bcopy(bp, token.sessionKey.data, 8);
+ memcpy(token.sessionKey.data, bp, 8);
/* (6) kvno */
exit(1);
}
- bcopy(bp, token.ticket, token.ticketLen);
+ memcpy(token.ticket, bp, token.ticketLen);
bp = bp + token.ticketLen;
# define DPRINTF(args)
#endif
-char *index();
-
#include <syslog.h>
static _checkhost();
struct hostent *hp;
fd_set reads;
- bzero((char *)someSignals, sizeof(someSignals));
+ memset((char *)someSignals, 0, sizeof(someSignals));
someSignals[0] = 1<<(SIGURG-1);
sigBlock = *((sigset_t *)someSignals);
#endif
sin.sin_family = hp->h_addrtype;
#ifdef AFS_OSF_ENV
- bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr, hp->h_length);
+ memcpy((caddr_t)&sin.sin_addr, hp->h_addr_list[0], hp->h_length);
#else
- bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
+ memcpy((caddr_t)&sin.sin_addr, hp->h_addr, hp->h_length);
#endif
sin.sin_port = rport;
/* attempt to remote authenticate first... */
errno = oerrno;
perror(0);
hp->h_addr_list++;
- bcopy(hp->h_addr_list[0], (caddr_t)&sin.sin_addr,
- hp->h_length);
+ memcpy((caddr_t)&sin.sin_addr, hp->h_addr_list[0], hp->h_length);
fprintf(stderr, "Trying %s...\n",
inet_ntoa(sin.sin_addr));
continue;
return(0);
}
ldomain[MAXHOSTNAMELEN] = '\0';
- if ((domainp = index(ldomain, '.')) == (char *)NULL) {
+ if ((domainp = strchr(ldomain, '.')) == (char *)NULL) {
nodomain = 1;
return(0);
}
# define TIOCPKT_WINDOW 0x80
# endif /* TIOCPKT_WINDOW */
-char *index(), *rindex(), *malloc(), *getenv();
+char *malloc(), *getenv();
struct passwd *getpwuid();
char *name;
int rem;
setlocale(LC_ALL,"");
#endif
- host = rindex(argv[0], '/');
+ host = strrchr(argv[0], '/');
if (host)
host++;
else
struct winsize ws;
if (dosigwinch && !nosigwin && ioctl(0, TIOCGWINSZ, &ws) == 0 &&
- bcmp(&ws, &winsize, sizeof (ws))) {
+ memcmp(&ws, &winsize, sizeof (ws))) {
winsize = ws;
sendwindow();
}
*/
check_and_run_afs_vers(argv);
#endif
- bzero(&ign_act, sizeof(ign_act));
+ memset(&ign_act, 0, sizeof(ign_act));
ign_act.sa_handler=SIG_IGN;
#endif
host = strrchr(argv[0], '/');
}
(void) setuid(getuid());
- bzero((char *)someSignals, sizeof(someSignals));
+ memset((char *)someSignals, 0, sizeof(someSignals));
#ifdef AFS_HPUX_ENV
someSignals[0] = mask(SIGINT)|mask(SIGQUIT)|mask(SIGTERM)|mask(SIGHUP);
#else
olen = (ip->ip_hl<<2) - sizeof (struct ip);
opts = (caddr_t)(ip + 1);
i = m->m_len - (sizeof (struct ip) + olen);
- bcopy(opts + olen, opts, (unsigned)i);
+ memcpy(opts, opts + olen, (unsigned)i);
m->m_len -= olen;
if (m->m_flags & M_PKTHDR)
m->m_pkthdr.len -= olen;
m->m_len = 0;
while (len) {
rlen = MIN(len, tl);
- bcopy(tdata, tpa, rlen);
+ memcpy(tpa, tdata, rlen);
asize -= rlen;
len -= rlen;
tpa += rlen;
m_freem(top); /* free mbuf chain */
return 1;
}
- bcopy(addr, mtod(um, caddr_t), sizeof(*addr));
+ memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
um->m_len = sizeof(*addr);
um->m_pkthdr.len = sizeof(*addr);
um->m_flags |= M_PKTHDR;
goto bad;
}
nam->m_len=addr->sin_len=sizeof(struct sockaddr_in);
- bcopy((caddr_t)addr, mtod(nam, caddr_t), addr->sin_len);
+ memcpy(mtod(nam, caddr_t), (caddr_t)addr, addr->sin_len);
code = sosend(asocket, mtod(nam, struct sockaddr *), &u, NULL, NULL, 0);
m_freem(nam);
bad:
/* force UDP checksumming on for AFS */
extern int udpcksum;
udpcksum = 1;
- bcopy(tpro, &parent_proto, sizeof(parent_proto));
+ memcpy(&parent_proto, tpro, sizeof(parent_proto));
tpro->pr_input = rxk_input;
tpro->pr_fasttimo = rxk_fasttimo;
/*
tpa = mtod(m, caddr_t);
while (len) {
rlen = MIN(len, tl);
- bcopy(tdata, tpa, rlen);
+ memcpy(tpa, tdata, rlen);
asize -= rlen;
len -= rlen;
tpa += rlen;
splx(s);
return 1;
}
- bcopy(addr, mtod(um, caddr_t), sizeof(*addr));
+ memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
um->m_len = sizeof(*addr);
/* note that udp_usrreq frees funny mbuf. We hold onto data, but mbuf
* around it is gone. we free address ourselves. */
/* force UDP checksumming on for AFS */
extern int udpcksum;
udpcksum = 1;
- bcopy(tpro, &parent_proto, sizeof(parent_proto));
+ memcpy(&parent_proto, tpro, sizeof(parent_proto));
tpro->pr_input = rxk_input;
tpro->pr_fasttimo = rxk_fasttimo;
/*
tpa = mtod(m, caddr_t);
while (len) {
rlen = MIN(len, tl);
- bcopy(tdata, tpa, rlen);
+ memcpy(tpa, tdata, rlen);
asize -= rlen;
len -= rlen;
tpa += rlen;
splx(s);
return 1;
}
- bcopy(addr, mtod(um, caddr_t), sizeof(*addr));
+ memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
um->m_len = sizeof(*addr);
/* note that udp_usrreq frees funny mbuf. We hold onto data, but mbuf
* around it is gone. we free address ourselves. */
/* force UDP checksumming on for AFS */
int udpcksum;
udpcksum = 1;
- bcopy(tpro, &parent_proto, sizeof(parent_proto));
+ memcpy(&parent_proto, tpro, sizeof(parent_proto));
tpro->pr_input = rxk_input;
tpro->pr_fasttimo = rxk_fasttimo;
rxk_initDone = 1;
/* Guess based on rxk_NewSocket */
bp = allocb((size+SO_MSGOFFSET+1), BPRI_MED);
if (!bp) return ENOBUFS;
- bcopy((caddr_t)addr, (caddr_t)bp->b_rptr+SO_MSGOFFSET, size);
+ memcpy((caddr_t)bp->b_rptr+SO_MSGOFFSET, (caddr_t)addr, size);
bp->b_wptr = bp->b_rptr + (size+SO_MSGOFFSET+1);
- bcopy((caddr_t)dvec, (caddr_t)temp, nvec * sizeof(struct iovec));
+ memcpy((caddr_t)temp, (caddr_t)dvec, nvec * sizeof(struct iovec));
/* devresource.hp.com/Drivers/Docs/Refs/11i/ddRef/Chap02R.pdf has details
on use of uio */
- bzero((caddr_t)&uio, sizeof(uio));
+ memset((caddr_t)&uio, 0, sizeof(uio));
uio.uio_resid = asize;
uio.uio_iov = temp;
uio.uio_iovcnt = nvec;
if (iovcnt > RX_MAXWVECS+2) {
osi_Panic("Too many (%d) iovecs passed to osi_NetReceive\n", iovcnt);
}
- bcopy((char*)iov, tmpvec, iovcnt/*(RX_MAXWVECS+1)*/ * sizeof(struct iovec));
+ memcpy(tmpvec, (char*)iov, iovcnt/*(RX_MAXWVECS+1)*/ * sizeof(struct iovec));
tuio.uio_iov = tmpvec;
tuio.uio_iovcnt = iovcnt;
tuio.uio_fpflags = 0;
if (!code) {
*lengthp = *lengthp - tuio.uio_resid;
if (bp) {
- bcopy((char*)bp->b_rptr, (char*)from, sizeof(struct sockaddr_in));
+ memcpy((char*)from, (char*)bp->b_rptr, sizeof(struct sockaddr_in));
} else {
code = -1;
}
if (iovcnt > RX_MAXWVECS+2) {
osi_Panic("Too many (%d) iovecs passed to osi_NetReceive\n", iovcnt);
}
- bcopy((char*)iov, tmpvec, (RX_MAXWVECS+1) * sizeof(struct iovec));
+ memcpy(tmpvec, (char*)iov, (RX_MAXWVECS+1) * sizeof(struct iovec));
#ifdef AFS_SGI65_ENV
code = soreceive(&bhv, &maddr, &tuio, NULL, NULL);
#else
else {
*lengthp = *lengthp - tuio.uio_resid;
if (maddr) {
- bcopy((char*)mtod(maddr, struct sockaddr_in *), (char*)from,
+ memcpy((char*)from, (char*)mtod(maddr, struct sockaddr_in *),
sizeof(struct sockaddr_in));
m_freem(maddr);
}
last = inetdomain.dom_protoswNPROTOSW;
for (tpro = inetdomain.dom_protosw; tpro < last; tpro++) {
if (tpro->pr_protocol == IPPROTO_UDP) {
- bcopy(tpro, &parent_proto, sizeof(parent_proto));
+ memcpy(&parent_proto, tpro, sizeof(parent_proto));
tpro->pr_input = rxk_input;
tpro->pr_fasttimo = rxk_fasttimo;
rxk_initDone = 1;
if (nvec > RX_MAXWVECS+1) {
osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvec);
}
- bcopy((char*)dvec, (char*)tvecs, nvec * sizeof(struct iovec));
+ memcpy((char*)tvecs, (char*)dvec, nvec * sizeof(struct iovec));
tuio.uio_iov = tvecs;
tuio.uio_iovcnt = nvec;
to = m_get(M_WAIT, MT_SONAME);
to->m_len = sizeof(struct sockaddr_in);
- bcopy((char*)addr, mtod(to, caddr_t), to->m_len);
+ memcpy(mtod(to, caddr_t), (char*)addr, to->m_len);
BHV_PDATA(&bhv) = (void*)asocket;
code = sosend(&bhv, to, &tuio, 0, NULL);
tpa = mtod(m, caddr_t);
while (len) {
rlen = MIN(len, tl);
- bcopy(tdata, tpa, rlen);
+ memcpy(tpa, tdata, rlen);
asize -= rlen;
len -= rlen;
tpa += rlen;
AFS_SBUNLOCK(&asocket->so_snd, NETEVENT_SODOWN, asocket, s1);
return 1;
}
- bcopy(addr, mtod(um, caddr_t), sizeof(*addr));
+ memcpy(mtod(um, caddr_t), addr, sizeof(*addr));
um->m_len = sizeof(*addr);
/* note that udp_usrreq frees funny mbuf. We hold onto data, but mbuf
* around it is gone. we free address ourselves. */
if (msg.msg_name == NULL) {
error = -1;
} else {
- bcopy(msg.msg_name, addr, msg.msg_namelen);
+ memcpy(addr, msg.msg_name, msg.msg_namelen);
kmem_free(msg.msg_name, msg.msg_namelen);
*alength = *alength - uio.uio_resid;
}
t_kclose(udp_tiptr, 0);
return (struct osi_socket *)0;
}
- if (bcmp(reqp->addr.buf, rspp->addr.buf, rspp->addr.len)) {
+ if (memcmp(reqp->addr.buf, rspp->addr.buf, rspp->addr.len)) {
t_kfree(udp_tiptr, (char *)reqp, T_BIND);
t_kfree(udp_tiptr, (char *)rspp, T_BIND);
t_kclose(udp_tiptr, 0);
}
/* Copy the data into the buffer */
- bcopy((char *)dvec[0].iov_base, (char *)bp->b_wptr, dvec[0].iov_len);
+ memcpy((char *)bp->b_wptr, (char *)dvec[0].iov_base, dvec[0].iov_len);
bp->b_datap->db_type = M_DATA;
bp->b_wptr += dvec[0].iov_len;
}
/* Copy the data into the buffer */
- bcopy((char *)dvec[i].iov_base, (char *)dbp->b_wptr, dvec[i].iov_len);
+ memcpy((char *)dbp->b_wptr, (char *)dvec[i].iov_base, dvec[i].iov_len);
dbp->b_datap->db_type = M_DATA;
dbp->b_wptr += dvec[i].iov_len;
udreq->addr.buf = (char *)kmem_alloc(sizeof(struct sockaddr_in), KM_SLEEP);
udreq->opt.len = 0;
udreq->opt.maxlen = 0;
- bcopy((char *)&sin, udreq->addr.buf, sizeof(struct sockaddr_in));
+ memcpy(udreq->addr.buf, (char *)&sin, sizeof(struct sockaddr_in));
udreq->udata.udata_mp = bp;
udreq->udata.len = asize;
/*
* Save the source address
*/
- bcopy(udreq->addr.buf, (char *)addr, sizeof(struct sockaddr_in));
+ memcpy((char *)addr, udreq->addr.buf, sizeof(struct sockaddr_in));
/*
* Copy out the message buffers, take care not to overflow
while (dbp != NULL && tlen > 0) {
blen = dbp->b_wptr - dbp->b_rptr;
if (blen > tlen) {
- bcopy((char *)dbp->b_rptr, tbase, tlen);
+ memcpy(tbase, (char *)dbp->b_rptr, tlen);
length -= tlen;
dbp->b_rptr += tlen;
tlen = 0;
} else {
- bcopy((char *)dbp->b_rptr, tbase, blen);
+ memcpy(tbase, (char *)dbp->b_rptr, blen);
length -= blen;
tlen -= blen;
tbase += blen;
printf("host address is disagreeable length (%d)", hostent->h_length);
exit(1);
}
- bcopy(hostent->h_addr, (char *)&host, sizeof(host));
+ memcpy((char *)&host, hostent->h_addr, sizeof(host));
return host;
}
printf("host address is disagreeable length (%d)", hostent->h_length);
exit(1);
}
- bcopy(hostent->h_addr, (char *)&host, sizeof(host));
+ memcpy((char *)&host, hostent->h_addr, sizeof(host));
return host;
}
work->store = store;
work->count = count;
work->verbose = verbose;
- name = (char *)rindex(file, '/');
+ name = strrchr(file, '/');
if (!name) name = file; else name++;
/* sprintf(tempfile, "/usr/tmp/%s.%s", myHostName, name);*/
sprintf(tempfile, "/usr/tmp/%s", name);
printf("host address is disagreeable length (%d)", hostent->h_length);
exit(1);
}
- bcopy(hostent->h_addr, (char *)&host, sizeof(host));
+ memcpy((char *)&host, hostent->h_addr, sizeof(host));
return host;
}
rxi_nCalls = 0;
rx_connDeadTime = 12;
rx_tranquil = 0; /* reset flag */
- bzero((char *)&rx_stats, sizeof(struct rx_stats));
+ memset((char *)&rx_stats, 0, sizeof(struct rx_stats));
htable = (char *)
osi_Alloc(rx_hashTableSize*sizeof(struct rx_connection *));
PIN(htable, rx_hashTableSize*sizeof(struct rx_connection *)); /* XXXXX */
- bzero(htable, rx_hashTableSize*sizeof(struct rx_connection *));
+ memset(htable, 0, rx_hashTableSize*sizeof(struct rx_connection *));
ptable = (char *) osi_Alloc(rx_hashTableSize*sizeof(struct rx_peer *));
PIN(ptable, rx_hashTableSize*sizeof(struct rx_peer *)); /* XXXXX */
- bzero(ptable, rx_hashTableSize*sizeof(struct rx_peer *));
+ memset(ptable, 0, rx_hashTableSize*sizeof(struct rx_peer *));
/* Malloc up a bunch of packets & buffers */
rx_nFreePackets = 0;
p = (char *) osi_Alloc(size);
#endif
if (!p) osi_Panic("rxi_Alloc error");
- bzero(p, size);
+ memset(p, 0, size);
return p;
}
theader.flags = RX_CLIENT_INITIATED | RX_LAST_PACKET;
theader.serviceId = 0;
- bcopy(&theader, tbuffer, sizeof(theader));
- bcopy(inputData, tp, inputLength);
+ memcpy(tbuffer, &theader, sizeof(theader));
+ memcpy(tp, inputData, inputLength);
code = sendto(socket, tbuffer, inputLength+sizeof(struct rx_header), 0,
(struct sockaddr *) &taddr, sizeof(struct sockaddr_in));
code = recvfrom(socket, tbuffer, sizeof(tbuffer), 0,
(struct sockaddr *) &faddr, &faddrLen);
- bcopy(tbuffer, &theader, sizeof(struct rx_header));
+ memcpy(&theader, tbuffer, sizeof(struct rx_header));
if (counter == ntohl(theader.callNumber)) break;
}
}
code -= sizeof(struct rx_header);
if (code > outputLength) code = outputLength;
- bcopy(tp, outputData, code);
+ memcpy(outputData, tp, code);
return code;
}
for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
if (tpro->pr_protocol == IPPROTO_UDP) {
/* restore original udp protocol switch */
- bcopy((void *)&parent_proto, (void *)tpro, sizeof(parent_proto));
- bzero((void *)&parent_proto, sizeof(parent_proto));
+ memcpy((void *)tpro, (void *)&parent_proto, sizeof(parent_proto));
+ memset((void *)&parent_proto, 0, sizeof(parent_proto));
rxk_initDone = 0;
rxk_shutdownPorts();
return;
afs_uint32 addrs[ADDRSPERSITE];
int mtus[ADDRSPERSITE];
- bzero((void *)addrs, sizeof(addrs));
- bzero((void *)mtus, sizeof(mtus));
+ memset((void *)addrs, 0, sizeof(addrs));
+ memset((void *)mtus, 0, sizeof(mtus));
for (i=0; i<afs_cb_interface.numberOfInterfaces; i++) {
rxmtu = (ntohl(afs_cb_interface.mtu[i]) - RX_IPUDP_SIZE);
struct ifaddr *ifad; /* ifnet points to a if_addrlist of ifaddrs */
afs_uint32 ifinaddr;
- bzero(addrs, sizeof(addrs));
- bzero(mtus, sizeof(mtus));
+ memset(addrs, 0, sizeof(addrs));
+ memset(mtus, 0, sizeof(mtus));
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
TAILQ_FOREACH(ifn, &ifnet, if_link) {
setuerror(ENOBUFS);
goto bad;
}
- bcopy((caddr_t)&myaddr, (caddr_t)bindnam->b_rptr+SO_MSGOFFSET, addrsize);
+ memcpy((caddr_t)bindnam->b_rptr+SO_MSGOFFSET, (caddr_t)&myaddr, addrsize);
bindnam->b_wptr = bindnam->b_rptr + (addrsize+SO_MSGOFFSET+1);
code = sobind(newSocket, bindnam, addrsize);
#ifdef AFS_OSF_ENV
myaddr.sin_len = nam->m_len;
#endif /* AFS_OSF_ENV */
- bcopy(&myaddr, mtod(nam, caddr_t), sizeof(myaddr));
+ memcpy(mtod(nam, caddr_t), &myaddr, sizeof(myaddr));
#ifdef AFS_SGI65_ENV
BHV_PDATA(&bhv) = (void*)newSocket;
code = sobind(&bhv, nam);
r = resid;
while ((resid > 0) && (i < packet->niovecs)) {
j = MIN (resid, packet->wirevec[i].iov_len - (offset - l));
- bcopy ((char *)(packet->wirevec[i].iov_base) + (offset - l), out, j);
+ memcpy(out, (char *)(packet->wirevec[i].iov_base) + (offset - l), j);
resid -= j;
l += packet->wirevec[i].iov_len;
i++;
b = (char*)(packet->wirevec[i].iov_base) + (offset - l);
j = MIN (resid, packet->wirevec[i].iov_len - (offset - l));
- bcopy (in, b, j);
+ memcpy(b, in, j);
resid -= j;
l += packet->wirevec[i].iov_len;
i++;
p = rx_mallocedP = (struct rx_packet *) osi_Alloc(getme);
PIN(p, getme); /* XXXXX */
- bzero((char *)p, getme);
+ memset((char *)p, 0, getme);
NETPRI;
AFS_RXGLOCK();
MUTEX_ENTER(&rx_freePktQ_lock);
getme = apackets * sizeof(struct rx_packet);
p = rx_mallocedP = (struct rx_packet *) osi_Alloc(getme);
- bzero((char *)p, getme);
+ memset((char *)p, 0, getme);
for (e = p + apackets; p<e; p++) {
p->wirevec[0].iov_base = (char *) (p->wirehead);
savelen = p->wirevec[p->niovecs].iov_len;
p->wirevec[p->niovecs].iov_len += RX_EXTRABUFFERSIZE;
- bzero((char *)&msg, sizeof(msg));
+ memset((char *)&msg, 0, sizeof(msg));
msg.msg_name = (char *) &from;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = p->wirevec;
return -1;
}
n = MIN(len, (mp->b_wptr - mp->b_rptr));
- bcopy((char *)mp->b_rptr, cp, n);
+ memcpy(cp, (char *)mp->b_rptr, n);
cp += n;
len -= n;
mp->b_rptr += n;
t = iovs[i].iov_len;
}
m = MIN(n,t);
- bcopy((char *)mp->b_rptr, iovs[i].iov_base + o, m);
+ memcpy(iovs[i].iov_base + o, (char *)mp->b_rptr, m);
mp->b_rptr += m;
o += m;
t -= m;
while (len) {
t = MIN(l1, MIN(l2, (unsigned int)len));
- bcopy (p1, p2, t);
+ memcpy(p2, p1, t);
p1 += t; p2 += t;
l1 -= t; l2 -= t;
len -= t;
struct rx_debugStats tstat;
/* get basic stats */
- bzero ((char *)&tstat, sizeof(tstat)); /* make sure spares are zero */
+ memset((char *)&tstat, 0, sizeof(tstat)); /* make sure spares are zero */
tstat.version = RX_DEBUGI_VERSION;
#ifndef RX_ENABLE_LOCKS
tstat.waitingForPackets = rx_waitingForPackets;
if (tl > 0)
return ap;
- bzero ((char *)&tconn, sizeof(tconn)); /* make sure spares are zero */
+ memset((char *)&tconn, 0, sizeof(tconn)); /* make sure spares are zero */
/* get N'th (maybe) "interesting" connection info */
for(i=0;i<rx_hashTableSize;i++) {
#if !defined(KERNEL)
if (tl > 0)
return ap;
- bzero ((char *)&tpeer, sizeof(tpeer));
+ memset((char *)&tpeer, 0, sizeof(tpeer));
for(i=0;i<rx_hashTableSize;i++) {
#if !defined(KERNEL)
/* the time complexity of the algorithm used here
ap->header.flags = ap->header.flags & ~RX_CLIENT_INITIATED;
rxi_EncodePacketHeader(ap);
- bzero(buf, sizeof(buf));
+ memset(buf, 0, sizeof(buf));
strncpy(buf, cml_version_number+4, sizeof(buf)-1);
rx_packetwrite(ap, 0, 65, buf);
tl = ap->length;
{
register afs_uint32 *buf = (afs_uint32 *)(p->wirevec[0].iov_base); /* MTUXXX */
- bzero((char *)buf, RX_HEADER_SIZE);
+ memset((char *)buf, 0, RX_HEADER_SIZE);
*buf++ = htonl(p->header.epoch);
*buf++ = htonl(p->header.cid);
*buf++ = htonl(p->header.callNumber);
#define rx_packetwrite(p, off, len, in) \
( (off) + (len) > (p)->wirevec[1].iov_len ? \
rx_SlowWritePacket(p, off, len, (char*)(in)) : \
- ((bcopy((char *)(in), (char*)((p)->wirevec[1].iov_base)+(off), (len))),0))
+ ((memcpy((char*)((p)->wirevec[1].iov_base)+(off), (char *)(in), (len))),0))
/* copy data from an RX packet */
#define rx_packetread(p, off, len, out) \
( (off) + (len) > (p)->wirevec[1].iov_len ? \
rx_SlowReadPacket(p, off, len, (char*)out) : \
- ((bcopy((char*)((p)->wirevec[1].iov_base)+(off), (char *)(out), len)),0))
+ ((memcpy((char *)(out), (char*)((p)->wirevec[1].iov_base)+(off), len)),0))
#define rx_computelen(p,l) { register int i; \
for (l=0, i=1; i < p->niovecs; i++ ) l += p->wirevec[i].iov_len; }
while (nbytes && cp) {
t = MIN((int)call->curlen, nbytes);
t = MIN(t, (int)call->nLeft);
- bcopy (call->curpos, buf, t);
+ memcpy(buf, call->curpos, t);
buf += t;
nbytes -= t;
call->curpos += t;
tnLeft = call->nLeft;
if (!call->error && tcurlen > nbytes && tnLeft > nbytes) {
tcurpos = call->curpos;
- bcopy(tcurpos, buf, nbytes);
+ memcpy(buf, tcurpos, nbytes);
call->curpos = tcurpos + nbytes;
call->curlen = tcurlen - nbytes;
call->nLeft = tnLeft - nbytes;
if (!((long)tcurpos & (sizeof(afs_int32)-1))) {
*value = *((afs_int32 *)(tcurpos));
} else {
- bcopy(tcurpos, (char *)value, sizeof(afs_int32));
+ memcpy((char *)value, tcurpos, sizeof(afs_int32));
}
call->curpos = tcurpos + sizeof(afs_int32);
call->curlen = tcurlen - sizeof(afs_int32);
t = MIN((int)call->curlen, nbytes);
t = MIN((int)call->nFree, t);
- bcopy (buf, call->curpos, t);
+ memcpy(call->curpos, buf, t);
buf += t;
nbytes -= t;
call->curpos += t;
tnFree = (int)call->nFree;
if (!call->error && tcurlen >= nbytes && tnFree >= nbytes) {
tcurpos = call->curpos;
- bcopy(buf, tcurpos, nbytes);
+ memcpy(tcurpos, buf, nbytes);
call->curpos = tcurpos + nbytes;
call->curlen = tcurlen - nbytes;
call->nFree = tnFree - nbytes;
if (!((long)tcurpos & (sizeof(afs_int32)-1))) {
*((afs_int32 *)(tcurpos)) = *value;
} else {
- bcopy((char *)value, tcurpos, sizeof(afs_int32));
+ memcpy(tcurpos, (char *)value, sizeof(afs_int32));
}
call->curpos = tcurpos + sizeof(afs_int32);
call->curlen = tcurlen - sizeof(afs_int32);
}
if (nbytes < sd->sd.rd.nLeft) {
sd->sd.rd.nLeft -= nbytes;
- bcopy(sd->sd.rd.nextByte, buf, nbytes);
+ memcpy(buf, sd->sd.rd.nextByte, nbytes);
sd->sd.rd.nextByte += nbytes;
return totalBytes;
}
- bcopy(sd->sd.rd.nextByte, buf, sd->sd.rd.nLeft);
+ memcpy(buf, sd->sd.rd.nextByte, sd->sd.rd.nLeft);
buf += sd->sd.rd.nLeft;
nbytes -= sd->sd.rd.nLeft;
tp = queue_First(&sd->sd.rd.rq, rx_packet);
sd->sd.wd.freePtr = rx_DataOf(queue_First(&sd->sd.wd.wq, rx_packet));
}
if (nbytes < sd->sd.wd.nFree) {
- if (buf) bcopy(buf, sd->sd.wd.freePtr, nbytes), buf += nbytes;
+ if (buf) memcpy(sd->sd.wd.freePtr, buf, nbytes), buf += nbytes;
sd->sd.wd.nFree -= nbytes;
sd->sd.wd.freePtr += nbytes;
nbytes = 0;
break;
}
- if (buf) bcopy(buf, sd->sd.wd.freePtr, sd->sd.wd.nFree), buf += sd->sd.wd.nFree;
+ if (buf) memcpy(sd->sd.wd.freePtr, buf, sd->sd.wd.nFree), buf += sd->sd.wd.nFree;
nbytes -= sd->sd.wd.nFree;
sd->sd.wd.nFree = 0;
if (rx_stream_FlushWrite(sd)) break;
/* If it returns 0, the call status should be checked with rx_Error. */
#define rx_stream_Write(iod, buf, nbytes) \
(iod)->sd.wd.nFree > (nbytes) ? \
- (buf) && bcopy((buf), (iod)->sd.wd.freePtr, (nbytes)), \
+ (buf) && memcpy((iod)->sd.wd.freePtr, (buf), (nbytes)), \
(iod)->sd.wd.nFree -= (nbytes), \
(iod)->sd.wd.freePtr += (nbytes), (nbytes) \
: rx_stream_WriteProc((iod), (buf), (nbytes))
/* If it returns less than requested, the call status should be checked with rx_Error */
#define rx_stream_Read(iod, buf, nbytes) \
(iod)->sd.rd.nLeft > (nbytes) ? \
- bcopy((iod)->sd.rd.nextByte, (buf), (nbytes)), \
+ memcpy((buf), (iod)->sd.rd.nextByte, (nbytes)), \
(iod)->sd.rd.nLeft -= (nbytes), (iod)->sd.rd.nextByte += (nbytes), (nbytes) \
: rx_stream_ReadProc((iod), (buf), (nbytes))
break;
}
- bcopy(&rxtinfo, rxi_tracebuf+rxi_tracepos, sizeof(struct rx_trace));
+ memcpy(rxi_tracebuf+rxi_tracepos, &rxtinfo, sizeof(struct rx_trace));
rxi_tracepos += sizeof(struct rx_trace);
if (rxi_tracepos >= (4096 - sizeof(struct rx_trace)))
rxi_flushtrace();
LOCK_IF
rxi_numNetAddrs = 0;
- bzero(rxi_NetAddrs, sizeof(rxi_NetAddrs));
- bzero(myNetFlags, sizeof(myNetFlags));
- bzero(myNetMTUs, sizeof(myNetMTUs));
- bzero(myNetMasks, sizeof(myNetMasks));
+ memset(rxi_NetAddrs, 0, sizeof(rxi_NetAddrs));
+ memset(myNetFlags, 0, sizeof(myNetFlags));
+ memset(myNetMTUs, 0, sizeof(myNetMTUs));
+ memset(myNetMasks, 0, sizeof(myNetMasks));
UNLOCK_IF
s = socket(AF_INET, SOCK_DGRAM, 0);
#else
ifc.ifc_len = sizeof(ifs);
ifc.ifc_buf = (caddr_t) &ifs[0];
- bzero(&ifs[0], sizeof(ifs));
+ memset(&ifs[0], 0, sizeof(ifs));
#endif
res = ioctl(s, SIOCGIFCONF, &ifc);
if (res < 0) {
printf("rxdebug: host %s not found in host table\n", name);
exit(1);
}
- bcopy(th->h_addr, &onlyHost, sizeof(afs_int32));
+ memcpy(&onlyHost, th->h_addr, sizeof(afs_int32));
} else onlyHost = -1;
if (as->parms[9].items) {
printf("rxdebug: host %s not found in host table\n", hostName);
exit(1);
}
- bcopy(th->h_addr, &host, sizeof(afs_int32));
+ memcpy(&host, th->h_addr, sizeof(afs_int32));
}
else host = htonl(0x7f000001); /* IP localhost */
printf("host address is disagreeable length (%d)", hostent->h_length);
exit(1);
}
- bcopy(hostent->h_addr, (char *)&host, sizeof(host));
+ memcpy((char *)&host, hostent->h_addr, sizeof(host));
return host;
}
struct rxvab_EncryptionKey *akey, *asession;
struct rxvab_Ticket *aticket; {
aticket->ViceId = htonl(71);
- bcopy("testkeyx", &aticket->HandShakeKey, 8);
- bcopy("testkeyx", asession, 8);
+ memcpy(&aticket->HandShakeKey, "testkeyx", 8);
+ memcpy(asession, "testkeyx", 8);
bcrypt_encrypt(aticket, aticket, sizeof(struct rxvab_Ticket), akey);
return 0;
}
printf("could not find host '%s' in host table\n", argv[i+1]);
return -1;
}
- bcopy(th->h_addr, &host, sizeof(long));
+ memcpy(&host, th->h_addr, sizeof(long));
i++;
}
else if (!strcmp(argv[i],"-count")) {
if (!hostent) Abort("host %s not found", hostname);
if (hostent->h_length != 4)
Abort("host address is disagreeable length (%d)", hostent->h_length);
- bcopy(hostent->h_addr, (char *)&host, sizeof(host));
+ memcpy((char *)&host, hostent->h_addr, sizeof(host));
if (setFD>0)
OpenFD(setFD);
if (rx_Init(0) != 0) {
#if defined(KERNEL) && !defined(UKERNEL)
#ifdef AFS_LINUX20_ENV
#include "../h/string.h"
-#define bzero(A,C) memset((A), 0, (C))
+#if 0
+#define bzero(A, C) memset((A), 0, (C))
+#endif
#else
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/param.h>
#ifdef AFS_LINUX20_ENV
#include "../h/string.h"
+#if 0
#define bzero(A,C) memset((A), 0, (C))
+#endif
#else
#include <sys/systm.h>
#endif /* AFS_LINUX20_ENV */
if (target == NULL) {
return (FALSE);
}
- bzero(target, (u_int)nodesize);
+ memset(target, 0, (u_int)nodesize);
break;
case XDR_FREE:
#include <sys/param.h>
#ifdef AFS_LINUX20_ENV
#include "../h/string.h"
+#if 0
#define bzero(A,C) memset((A), 0, (C))
+#endif
#else
#include <sys/systm.h>
#endif
if (target == NULL) {
return (FALSE);
}
- bzero(target, (u_int)nodesize);
+ memset(target, 0, (u_int)nodesize);
break;
case XDR_FREE:
#if defined(KERNEL) && !defined(UKERNEL)
#ifdef AFS_LINUX20_ENV
#include "../h/string.h"
+#if 0
#define bzero(A,C) memset((A), 0, (C))
+#endif
#else
#include <sys/param.h>
#include <sys/systm.h>
if ((xdrs->x_handy -= len) < 0)
return (FALSE);
- bcopy(xdrs->x_private, addr, len);
+ memcpy(addr, xdrs->x_private, len);
xdrs->x_private += len;
return (TRUE);
}
if ((xdrs->x_handy -= len) < 0)
return (FALSE);
- bcopy(addr, xdrs->x_private, len);
+ memcpy(xdrs->x_private, addr, len);
xdrs->x_private += len;
return (TRUE);
}
while (len > 0) {
current = (u_int)rstrm->out_boundry - (u_int)rstrm->out_finger;
current = (len < current) ? len : current;
- bcopy(addr, rstrm->out_finger, current);
+ memcpy(rstrm->out_finger, addr, current);
rstrm->out_finger += current;
addr += current;
len -= current;
continue;
}
current = (len < current) ? len : current;
- bcopy(rstrm->in_finger, addr, current);
+ memcpy(addr, rstrm->in_finger, current);
rstrm->in_finger += current;
addr += current;
len -= current;
if (loc == NULL) {
return (FALSE);
}
- bzero(loc, (int)size);
+ memset(loc, 0, (int)size);
break;
}
}
f_print(fout, "res;\n");
f_print(fout, "\n");
- f_print(fout, "\tbzero(%sres, sizeof(res));\n", ampr(proc->res_type));
+ f_print(fout, "\tmemset(%sres, 0, sizeof(res));\n", ampr(proc->res_type));
f_print(fout,
"\tif (clnt_call(clnt, %s, xdr_%s, argp, xdr_%s, %sres, TIMEOUT) != RPC_SUCCESS) {\n",
proc->proc_name, stringfix(proc->arg_type),
OutFileFlag = NULL;
S_output(cmd.infile, "-DRPC_SERVER", !EXTEND, cmd.outfile, 1);
} else {
- if (OutFileFlag && (rindex(OutFile,'.') == NULL))
+ if (OutFileFlag && (strrchr(OutFile,'.') == NULL))
strcat(OutFile, ".");
if (cmd.rflag) {
C_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_CLIENT", EXTEND, ".cs.c", 1);
if (res == NULL) {
abort();
}
- p = (char *) rindex(file, '.');
+ p = (char *) strrchr(file, '.');
if (p == NULL) {
p = file + strlen(file);
}
- sname = (char *) rindex(file,'/');
+ sname = (char *) strrchr(file, '/');
if (sname == NULL)
sname = file;
else
open_input(infile, define);
cflag = 1;
- bzero(fullname, sizeof(fullname));
+ memset(fullname, 0, sizeof(fullname));
if (append) {
strcpy(fullname, prefix);
strcat(fullname, infile);
open_input(infile, define);
hflag = 1;
- bzero(fullname, sizeof(fullname));
+ memset(fullname, 0, sizeof(fullname));
if (append) {
strcpy(fullname, prefix);
strcat(fullname, infile);
outfilename = extend ? extendfile(fullname, outfile) : outfile;
open_output(infile, outfilename);
strcpy(fullname, outfilename);
- if (p = (char *)index(fullname, '.')) *p = '\0';
+ if (p = strchr(fullname, '.')) *p = '\0';
f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
f_print(fout, "#ifndef _RXGEN_%s_\n", uppercase(fullname));
f_print(fout, "#define _RXGEN_%s_\n\n", uppercase(fullname));
Cflag = 1;
open_input(infile, define);
- bzero(fullname, sizeof(fullname));
+ memset(fullname, 0, sizeof(fullname));
if (append) {
strcpy(fullname, prefix);
strcat(fullname, infile);
Sflag = 1;
open_input(infile, define);
- bzero(fullname, sizeof(fullname));
+ memset(fullname, 0, sizeof(fullname));
if (append) {
strcpy(fullname, prefix);
strcat(fullname, infile);
if (argc < 2) {
return (0);
}
- bzero(flag, sizeof(flag));
+ memset(flag, 0, sizeof(flag));
cmd->outfile = NULL;
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
token tok;
defp = ALLOC(definition);
- bzero((char *)defp, sizeof(definition));
+ memset((char *)defp, 0, sizeof(definition));
get_token(&tok);
switch (tok.kind) {
case TOK_STRUCT:
do {
get_token(tokp);
Proc_list = ALLOC(proc1_list);
- bzero((char *)Proc_list, sizeof(proc1_list));
+ memset((char *)Proc_list, 0, sizeof(proc1_list));
Proc_list->pl.param_flag = 0;
switch (tokp->kind) {
case TOK_IN:
*Proc_listp = Proc_list;
Proc_listp = &Proc_list->next;
decls = ALLOC(decl_list);
- bzero((char *)decls, sizeof(decl_list));
+ memset((char *)decls, 0, sizeof(decl_list));
decls->decl = dec;
*tailp = decls;
tailp = &decls->next;
for (plist1 = defp->pc.plists; plist1; plist1 = plist1->next) {
if ((plist1->component_kind == DEF_PARAM) && streq(plist->pl.param_type, plist1->pl.param_type) && !(plist1->pl.param_flag & PROCESSED_PARAM)) {
char *star="";
- char *pntr = index(plist1->pl.param_type, '*');
+ char *pntr = strchr(plist1->pl.param_type, '*');
if (pntr) star = "*";
if (plist1->pl.param_flag & OUT_STRING) {
f_print(fout, ", *%s%s", star, plist1->pl.param_name);
for (plist = defp->pc.plists; plist; plist = plist->next) {
if ((plist->component_kind == DEF_PARAM) && !(plist->pl.param_flag & PROCESSED_PARAM)) {
if (plist->pl.param_flag & INDIRECT_PARAM) {
- char pres, *pntr = index(plist->pl.param_type, '*');
+ char pres, *pntr = strchr(plist->pl.param_type, '*');
if (pntr){ --pntr; pres = *pntr; *pntr = (char)0; }
f_print(fout, "\t%s %s", plist->pl.param_type, plist->pl.param_name);
*pntr = pres;
- } else if (index(plist->pl.param_type, '*') == 0) {
+ } else if (strchr(plist->pl.param_type, '*') == 0) {
f_print(fout, "\t%s %s", plist->pl.param_type, plist->pl.param_name);
} else {
plist->pl.param_flag |= FREETHIS_PARAM;
if ((plist1->component_kind == DEF_PARAM) && streq(plist->pl.param_type, plist1->pl.param_type) && !(plist1->pl.param_flag & PROCESSED_PARAM)) {
if (plist1->pl.param_flag & INDIRECT_PARAM) {
f_print(fout, ", %s", plist1->pl.param_name);
- } else if (index(plist1->pl.param_type, '*') == 0) {
+ } else if (strchr(plist1->pl.param_type, '*') == 0) {
f_print(fout, ", %s", plist1->pl.param_name);
} else {
plist1->pl.param_flag |= FREETHIS_PARAM;
f_print(fout, "\t\treturn;\n");
f_print(fout, "\t}\n");
- f_print(fout, "\tbzero(&%s, sizeof(%s));\n", ARG, ARG);
+ f_print(fout, "\tmemset(&%s, 0, sizeof(%s));\n", ARG, ARG);
printif("getargs", TRANSP, "&", ARG);
printerr("decode", TRANSP);
f_print(fout, "\t\treturn;\n");
reinitialize()
{
int i;
- bzero(curline, MAXLINESIZE);
+ memset(curline, 0, MAXLINESIZE);
where = curline;
linenum = 0;
defined = NULL;
rxkad_stats.bytesDecrypted[rxkad_TypeIndex(tp->type)] += len;
UNLOCK_RXKAD_STATS
- bcopy ((void *)ivec, (void *)xor, sizeof(xor));
+ memcpy((void *)xor, (void *)ivec, sizeof(xor));
for (i = 0; len ; i++) {
data = rx_data(packet, i, tlen);
if (!data || !tlen)
*/
rx_PutInt32(packet, 1*sizeof(afs_int32), 0);
- bcopy ((void *)ivec, (void *)xor, sizeof(xor));
+ memcpy((void *)xor, (void *)ivec, sizeof(xor));
for (i = 0; len ; i++) {
data = rx_data(packet, i, tlen);
if (!data || !tlen)
#endif
#if 0
- bcopy (clear, &L, sizeof(afs_int32));
- bcopy (clear+1, &R, sizeof(afs_int32));
+ memcpy(&L, clear, sizeof(afs_int32));
+ memcpy(&R, clear+1, sizeof(afs_int32));
#else
L = ntohl(*clear);
R = ntohl(*(clear+1));
}
}
#if 0
- bcopy (&L, cipher, sizeof(afs_int32));
- bcopy (&R, cipher+1, sizeof(afs_int32));
+ memcpy(cipher, &L, sizeof(afs_int32));
+ memcpy(cipher+1, &R, sizeof(afs_int32));
#else
*cipher = htonl(L);
*(cipher+1) = htonl(R);
if (encrypt) {
for (i = 0; length > 0; i++, length -= 8) {
/* get input */
- bcopy (input, t_input, sizeof(t_input));
+ memcpy(t_input, input, sizeof(t_input));
input += sizeof(t_input);
/* zero pad */
fc_ecb_encrypt (xor, t_output, key, encrypt);
/* copy temp output and save it for cbc */
- bcopy (t_output, output, sizeof(t_output));
+ memcpy(output, t_output, sizeof(t_output));
output += sizeof(t_output);
/* calculate xor value for next round from plain & cipher text */
/* decrypt */
for (i = 0; length > 0; i++, length -= 8) {
/* get input */
- bcopy (input, t_input, sizeof(t_input));
+ memcpy(t_input, input, sizeof(t_input));
input += sizeof(t_input);
/* no padding for decrypt */
t_output[1] ^= xor[1] ;
/* copy temp output */
- bcopy (t_output, output, sizeof(t_output));
+ memcpy(output, t_output, sizeof(t_output));
output += sizeof(t_output);
/* calculate xor value for next round from plain & cipher text */
afs_uint32 xor[2];
for (i=0; i<10; i++) msg[i]=htonl(i);
- bcopy ("abcdefgh", &key, sizeof(struct ktc_encryptionKey));
+ memcpy(&key, "abcdefgh", sizeof(struct ktc_encryptionKey));
fc_keysched (&key, schedule);
print_msg ("Starting msg is:", msg, sizeof(msg));
- bcopy(&key, xor, 2*sizeof(afs_int32));
+ memcpy(xor, &key, 2*sizeof(afs_int32));
fc_cbc_encrypt (msg, out, sizeof(msg), schedule, &key, ENCRYPT);
- bcopy(&key, xor, 2*sizeof(afs_int32));
+ memcpy(xor, &key, 2*sizeof(afs_int32));
fc_cbc_encrypt (out, dec, sizeof(msg), schedule, &key, DECRYPT);
- if (bcmp (msg, dec, sizeof(msg)) != 0)
+ if (memcmp (msg, dec, sizeof(msg)) != 0)
printf ("Encryption FAILED!\n");
print_msg ("Encrypted is:", out, sizeof(out));
print_msg ("Decrypted is:", dec, sizeof(dec));
#endif
e[0] = 0x11111111;
e[1] = 0xaaaaaaaa;
- bcopy ("abcdefgh", &key, sizeof(struct ktc_encryptionKey));
+ memcpy(&key, "abcdefgh", sizeof(struct ktc_encryptionKey));
for (rounds=2; rounds<=MAXROUNDS; rounds +=2) {
#ifdef TCRYPT
ROUNDS = rounds;
if (aobj) {
/* block is ready for encryption with session key, let's go for it. */
tcp = (struct rxkad_cprivate *) aobj->privateData;
- bcopy((void *)tcp->ivec, (void *)xor, 2*sizeof(afs_int32));
+ memcpy((void *)xor, (void *)tcp->ivec, 2*sizeof(afs_int32));
fc_cbc_encrypt((char *) &tgen, (char *) &tgen, sizeof(tgen),
tcp->keysched, xor, ENCRYPT);
} else {
/* Create a session key so that we can encrypt it */
}
- bcopy(((char *)&tgen) + sizeof(tgen) - ENCRYPTIONBLOCKSIZE,
- (void *)Cuid, ENCRYPTIONBLOCKSIZE);
+ memcpy((void *)Cuid, ((char *)&tgen) + sizeof(tgen) - ENCRYPTIONBLOCKSIZE, ENCRYPTIONBLOCKSIZE);
Cuid[0] = (Cuid[0] & ~0x40000000) | 0x80000000;
Cuid[1] &= RX_CIDMASK;
rx_SetEpoch (Cuid[0]); /* for future rxnull connections */
size = sizeof(struct rx_securityClass);
tsc = (struct rx_securityClass *) rxi_Alloc (size);
- bzero ((void *)tsc, size);
+ memset((void *)tsc, 0, size);
tsc->refCount = 1; /* caller gets one for free */
tsc->ops = &rxkad_client_ops;
size = sizeof(struct rxkad_cprivate);
tcp = (struct rxkad_cprivate *) rxi_Alloc (size);
- bzero ((void *)tcp, size);
+ memset((void *)tcp, 0, size);
tsc->privateData = (char *) tcp;
tcp->type |= rxkad_client;
tcp->level = level;
code = fc_keysched (sessionkey, tcp->keysched);
if (code) return 0; /* bad key */
- bcopy ((void *)sessionkey, (void *)tcp->ivec, sizeof(tcp->ivec));
+ memcpy((void *)tcp->ivec, (void *)sessionkey, sizeof(tcp->ivec));
tcp->kvno = kvno; /* key version number */
tcp->ticketLen = ticketLen; /* length of ticket */
- bcopy(ticket, tcp->ticket, ticketLen);
+ memcpy(tcp->ticket, ticket, ticketLen);
LOCK_RXKAD_STATS
rxkad_stats_clientObjects++;
if (v2) {
int i;
afs_uint32 xor[2];
- bzero ((void *)&r_v2, sizeof(r_v2));
+ memset((void *)&r_v2, 0, sizeof(r_v2));
r_v2.version = htonl(RXKAD_CHALLENGE_PROTOCOL_VERSION);
r_v2.spare = 0;
(void) rxkad_SetupEndpoint (aconn, &r_v2.encrypted.endpoint);
r_v2.kvno = htonl(tcp->kvno);
r_v2.ticketLen = htonl(tcp->ticketLen);
r_v2.encrypted.endpoint.cksum = rxkad_CksumChallengeResponse (&r_v2);
- bcopy((void *)tcp->ivec, (void *)xor, 2*sizeof(afs_int32));
+ memcpy((void *)xor, (void *)tcp->ivec, 2*sizeof(afs_int32));
fc_cbc_encrypt (&r_v2.encrypted, &r_v2.encrypted,
sizeof(r_v2.encrypted), tcp->keysched, xor, ENCRYPT);
response = (char *)&r_v2;
responseSize = sizeof(r_v2);
} else {
- bzero ((void *)&r_old, sizeof(r_old));
+ memset((void *)&r_old, 0, sizeof(r_old));
r_old.encrypted.incChallengeID = htonl(challengeID + 1);
r_old.encrypted.level = htonl((afs_int32)tcp->level);
r_old.kvno = htonl(tcp->kvno);
afs_uint32 xor[2];
rxkad_SetupEndpoint(aconnp, &tendpoint);
- bcopy(aivec, (void *)xor, 2*sizeof(afs_int32));
+ memcpy((void *)xor, aivec, 2*sizeof(afs_int32));
fc_cbc_encrypt(&tendpoint, &tendpoint, sizeof(tendpoint),
aschedule, xor, ENCRYPT);
- bcopy(((char *)&tendpoint) + sizeof(tendpoint) - ENCRYPTIONBLOCKSIZE,
- aresult, ENCRYPTIONBLOCKSIZE);
+ memcpy(aresult, ((char *)&tendpoint) + sizeof(tendpoint) - ENCRYPTIONBLOCKSIZE, ENCRYPTIONBLOCKSIZE);
return 0;
}
if (rx_IsServerConn(aconn)) {
int size = sizeof(struct rxkad_sconn);
aconn->securityData = (char *) rxi_Alloc (size);
- bzero(aconn->securityData, size); /* initialize it conveniently */
+ memset(aconn->securityData, 0, size); /* initialize it conveniently */
}
else { /* client */
struct rxkad_cprivate *tcp;
int size = sizeof(struct rxkad_cconn);
tccp = (struct rxkad_cconn *) rxi_Alloc (size);
aconn->securityData = (char *) tccp;
- bzero(aconn->securityData, size); /* initialize it conveniently */
+ memset(aconn->securityData, 0, size); /* initialize it conveniently */
tcp = (struct rxkad_cprivate *) aobj->privateData;
if (!(tcp->type & rxkad_client)) return RXKADINCONSISTENCY;
rxkad_SetLevel(aconn, tcp->level); /* set header and trailer sizes */
size = sizeof(struct rx_securityClass);
tsc = (struct rx_securityClass *) osi_Alloc (size);
- bzero (tsc, size);
+ memset(tsc, 0, size);
tsc->refCount = 1; /* caller has one reference */
tsc->ops = &rxkad_server_ops;
size = sizeof(struct rxkad_sprivate);
tsp = (struct rxkad_sprivate *) osi_Alloc (size);
- bzero (tsp, size);
+ memset(tsp, 0, size);
tsc->privateData = (char *) tsp;
tsp->type |= rxkad_server; /* so can identify later */
if (rx_IsUsingPktCksum(aconn)) sconn->cksumSeen = 1;
if (sconn->cksumSeen) {
- bzero (&c_v2, sizeof(c_v2));
+ memset(&c_v2, 0, sizeof(c_v2));
c_v2.version = htonl(RXKAD_CHALLENGE_PROTOCOL_VERSION);
c_v2.challengeID = htonl(sconn->challengeID);
c_v2.level = htonl((afs_int32)sconn->level);
challenge = (char *)&c_v2;
challengeSize = sizeof(c_v2);
} else {
- bzero (&c_old, sizeof(c_old));
+ memset(&c_old, 0, sizeof(c_old));
c_old.challengeID = htonl(sconn->challengeID);
c_old.level = htonl((afs_int32)sconn->level);
challenge = (char *)&c_old;
code = fc_keysched (&sessionkey, sconn->keysched);
if (code) return RXKADBADKEY;
- bcopy (&sessionkey, sconn->ivec, sizeof(sconn->ivec));
+ memcpy(sconn->ivec, &sessionkey, sizeof(sconn->ivec));
if (sconn->cksumSeen) {
/* using v2 response */
int i;
afs_uint32 xor[2];
- bcopy(sconn->ivec, xor, 2*sizeof(afs_int32));
+ memcpy(xor, sconn->ivec, 2*sizeof(afs_int32));
fc_cbc_encrypt (&v2r.encrypted, &v2r.encrypted, sizeof(v2r.encrypted),
sconn->keysched, xor, DECRYPT);
cksum = rxkad_CksumChallengeResponse (&v2r);
return RXKADSEALEDINCON;
(void) rxkad_SetupEndpoint (aconn, &endpoint);
v2r.encrypted.endpoint.cksum = 0;
- if (bcmp (&endpoint, &v2r.encrypted.endpoint, sizeof(endpoint)) != 0)
+ if (memcmp (&endpoint, &v2r.encrypted.endpoint, sizeof(endpoint)) != 0)
return RXKADSEALEDINCON;
for (i=0; i<RX_MAXCALLS; i++) {
v2r.encrypted.callNumbers[i] = ntohl(v2r.encrypted.callNumbers[i]);
else { /* save the info for later retreival */
int size = sizeof(struct rxkad_serverinfo);
rock = (struct rxkad_serverinfo *) osi_Alloc (size);
- bzero (rock, size);
+ memset(rock, 0, size);
rock->kvno = kvno;
- bcopy (&client, &rock->client, sizeof(rock->client));
+ memcpy(&rock->client, &client, sizeof(rock->client));
sconn->rock = rock;
}
return 0;
sParms = (struct serverParms *) osi_Alloc (sizeof(*sParms));
cParms = (struct clientParms *) osi_Alloc (sizeof(*cParms));
- bzero (sParms, sizeof(*sParms));
- bzero (cParms, sizeof(*cParms));
+ memset(sParms, 0, sizeof(*sParms));
+ memset(cParms, 0, sizeof(*cParms));
sParms->whoami = cParms->whoami = whoami;
if (!(startServer || startClient)) {
fprintf (stderr, "host %s not found\n", aname);
return errno;
}
- bcopy(th->h_addr, &addr, sizeof(addr));
+ memcpy(&addr, th->h_addr, sizeof(addr));
return addr;
}
#endif
assert (i < MAX_CTHREADS);
w = (struct worker *) osi_Alloc (sizeof(struct worker));
- bzero (w, sizeof(*w));
+ memset(w, 0, sizeof(*w));
w->next = workers;
workers = w;
w->index = i;
DivideUpCalls (parms->slowCalls, parms->threads, slowCalls);
DivideUpCalls (parms->copiousCalls, parms->threads, copiousCalls);
- bzero (&c, sizeof(c));
+ memset(&c, 0, sizeof(c));
c.conn = conn;
c.sendLen = parms->sendLen;
c.recvLen = parms->recvLen;
int i;
struct multiChannel mc;
- bzero (&mc, sizeof(mc));
+ memset(&mc, 0, sizeof(mc));
mc.conn = conn;
for (i=0; i<RX_MAXCALLS; i++) {
codes[i] = RXKST_PROCESSRUNNING;
IN long kvno;
OUT struct ktc_encryptionKey *key;
{
- bcopy (&serviceKey, key, sizeof(*key));
+ memcpy(key, &serviceKey, sizeof(*key));
return 0;
}
getstr (inst, 0);
getstr (realm, 0);
- bcopy (ticket, host, sizeof (*host));
+ memcpy(host, ticket, sizeof (*host));
ticket += sizeof(*host);
*host = ktohl (flags, *host);
- bcopy (ticket, sessionKey, sizeof (struct ktc_encryptionKey));
+ memcpy(sessionKey, ticket, sizeof (struct ktc_encryptionKey));
ticket += sizeof (struct ktc_encryptionKey);
lifetime = *ticket++;
- bcopy (ticket, start, sizeof (*start));
+ memcpy(start, ticket, sizeof (*start));
ticket += sizeof(*start);
*start = ktohl (flags, *start);
*end = life_to_time (*start, lifetime);
strcpy (ticket, name); \
ticket += slen+1
#define putint(num) num = htonl(num);\
- bcopy (&num, ticket, sizeof(num));\
+ memcpy(ticket, &num, sizeof(num));\
ticket += sizeof(num)
static int assemble_athena_ticket (ticket, ticketLen, name, inst, realm,
putstr (realm, 0);
putint (host);
- bcopy (sessionKey, ticket, sizeof(struct ktc_encryptionKey));
+ memcpy(ticket, sessionKey, sizeof(struct ktc_encryptionKey));
ticket += sizeof(struct ktc_encryptionKey);
life = time_to_life (start, end);
* Fill in the top fields (except the disk fields, which will be
* done elsewhere), then create the light onodes.
*/
- bcopy((char *)a_skt, (char *)&(a_line->skt), sizeof(struct sockaddr_in));
+ memcpy((char *)&(a_line->skt), (char *)a_skt, sizeof(struct sockaddr_in));
a_line->numDisks = 0;
a_line->base_line = a_lineNum + scout_screen.base_line_num;
a_line->num_lines = 1;
rn, a_numservers, sktbytes);
scout_CleanExit(-1);
}
- bzero(FSSktArray, sktbytes);
+ memset(FSSktArray, 0, sktbytes);
/*
* Sweep through the server names provided, filling in the socket
rn, fullsrvname);
return(-1);
}
- bcopy(he->h_addr, &(curr_skt->sin_addr.s_addr), 4);
+ memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
curr_skt->sin_family = htons(AF_INET); /*Internet family*/
curr_skt->sin_port = htons(7000); /*FileServer port*/
rn, mini_line_bytes, a_numservers);
return(-1);
}
- bzero(mini_lines, mini_line_bytes);
+ memset(mini_lines, 0, mini_line_bytes);
/*
* Set up each line in the mini_lines, creating and initializing
printf("host %s not found; %s call aborted\n", afs_server, syscall);
return 0;
}
- bcopy(th->h_addr, &hostAddr, sizeof(hostAddr));
+ memcpy(&hostAddr, th->h_addr, sizeof(hostAddr));
return hostAddr;
}
if (!(inbuffer = (char *)malloc(ins)))
return (-1); /* helpless here */
if (data->in_size)
- bcopy(data->in, inbuffer, data->in_size);
+ memcpy(inbuffer, data->in, data->in_size);
InData.rmtbulk_len = data->in_size;
InData.rmtbulk_val = inbuffer;
inparam_conversion(cmd, InData.rmtbulk_val, 0);
data.in = (char *)malloc(InData->rmtbulk_len + PIOCTL_HEADER*sizeof(afs_int32));
if (!data.in) return (-1); /* helpless here */
if (!strcmp(path, NIL_PATHP)) pathp = (char *)0; /* It meant to be NIL */
- bcopy(blob, data.in, sizeof(blob));
+ memcpy(data.in, blob, sizeof(blob));
inparam_conversion(cmd, InData->rmtbulk_val, 1);
- bcopy(InData->rmtbulk_val, data.in+sizeof(blob), InData->rmtbulk_len);
+ memcpy(data.in+sizeof(blob), InData->rmtbulk_val, InData->rmtbulk_len);
data.in_size = InData->rmtbulk_len + PIOCTL_HEADER*sizeof(afs_int32);
data.out = OutData->rmtbulk_val;
data.out_size = OutData->rmtbulk_len;
* each time we call the authenticate routine.
*/
ka_Init(0);
- bzero(meths, sizeof(struct secmethod_table));
+ memset(meths, 0, sizeof(struct secmethod_table));
/*
* Initialize the exported interface routines. Except the authenticate one
* the others are currently mainly noops.
for (i = 0; i < info->numServers; i++) {
if (i == me) continue;
ts = (struct ubik_server *) malloc(sizeof(struct ubik_server));
- bzero(ts, sizeof(struct ubik_server));
+ memset(ts, 0, sizeof(struct ubik_server));
ts->next = ubik_servers;
ubik_servers = ts;
ts->addr[0] = info->hostAddr[i].sin_addr.s_addr;
while (servAddr = *aservers++) {
if (i >= MAXSERVERS) return UNHOSTS; /* too many hosts */
ts = (struct ubik_server *) malloc(sizeof(struct ubik_server));
- bzero(ts, sizeof(struct ubik_server));
+ memset(ts, 0, sizeof(struct ubik_server));
ts->next = ubik_servers;
ubik_servers = ts;
ts->addr[0] = servAddr; /* primary address in net byte order */
struct buffer *tb;
int i;
- bcopy(&ubik_dbase->version, &aparm->localVersion, sizeof(struct ubik_version));
+ memcpy(&aparm->localVersion, &ubik_dbase->version, sizeof(struct ubik_version));
aparm->lockedPages = 0;
aparm->writeLockedPages = 0;
tb = Buffers;
int i;
struct buffer *tb;
Buffers = (struct buffer *) malloc(abuffers * sizeof(struct buffer));
- bzero(Buffers, abuffers * sizeof(struct buffer));
+ memset(Buffers, 0, abuffers * sizeof(struct buffer));
BufferData = (char *) malloc(abuffers * PAGESIZE);
nbuffers = abuffers;
for(i=0;i<PHSIZE;i++) phTable[i] = 0;
/* can't find it */
tb = newslot(dbase, fid, page);
if (!tb) return 0;
- bzero(tb->data, PAGESIZE);
+ memset(tb->data, 0, PAGESIZE);
tb->lockers++;
code = (*dbase->read)(dbase, fid, tb->data, page*PAGESIZE, PAGESIZE);
if ((tb = newslot(dbase, fid, page)) == 0) return (char *) 0;
tb->lockers++;
- bzero(tb->data, PAGESIZE);
+ memset(tb->data, 0, PAGESIZE);
return tb->data;
}
offset = apos & (PAGESIZE-1);
len = PAGESIZE - offset;
if (len > alen) len = alen;
- bcopy(bp+offset, abuffer, len);
+ memcpy(abuffer, bp+offset, len);
abuffer += len;
apos += len;
alen -= len;
if (!bp) {
bp = DNew(dbase, afile, apos>>LOGPAGESIZE);
if (!bp) return UIOERROR;
- bzero(bp, PAGESIZE);
+ memset(bp, 0, PAGESIZE);
}
/* otherwise, min of remaining bytes and end of buffer to user mode */
offset = apos & (PAGESIZE-1);
len = PAGESIZE-offset;
if (len > alen) len = alen;
- bcopy(abuffer, bp+offset, len);
+ memcpy(bp+offset, abuffer, len);
abuffer += len;
apos += len;
alen -= len;
if (code) return code;
}
tt = (struct ubik_trans *) malloc(sizeof(struct ubik_trans));
- bzero(tt, sizeof(struct ubik_trans));
+ memset(tt, 0, sizeof(struct ubik_trans));
tt->dbase = adbase;
tt->next = adbase->activeTrans;
adbase->activeTrans = tt;
if (!code) {
/* we got a new file, set up its header */
urecovery_state |= UBIK_RECHAVEDB;
- bcopy(&tversion, &ubik_dbase->version, sizeof(struct ubik_version));
+ memcpy(&ubik_dbase->version, &tversion, sizeof(struct ubik_version));
(*ubik_dbase->sync)(ubik_dbase, 0); /* get data out first */
/* after data is good, sync disk with correct label */
code = (*ubik_dbase->setlabel)(ubik_dbase, 0, &ubik_dbase->version);
This way, good label is only on good database. */
(*ubik_dbase->sync)(dbase, file);
code = (*ubik_dbase->setlabel)(dbase, file, avers);
- bcopy(avers, &ubik_dbase->version, sizeof(struct ubik_version));
+ memcpy(&ubik_dbase->version, avers, sizeof(struct ubik_version));
udisk_Invalidate(dbase, file); /* new dbase, flush disk buffers */
LWP_NoYieldSignal(&dbase->version);
DBRELE(dbase);
tdb->pathName = (char *) malloc(strlen(pathName)+1);
strcpy(tdb->pathName, pathName);
tdb->activeTrans = (struct ubik_trans *) 0;
- bzero(&tdb->version, sizeof(struct ubik_version));
- bzero(&tdb->cachedVersion, sizeof(struct ubik_version));
+ memset(&tdb->version, 0, sizeof(struct ubik_version));
+ memset(&tdb->cachedVersion, 0, sizeof(struct ubik_version));
Lock_Init(&tdb->versionLock);
tdb->flags = 0;
tdb->read = uphys_read;
dbase = transPtr->dbase;
DBHOLD(dbase);
- bzero(&dbase->cachedVersion, sizeof(struct ubik_version));
+ memset(&dbase->cachedVersion, 0, sizeof(struct ubik_version));
/* see if we're still up-to-date */
if (!urecovery_AllBetter(dbase, transPtr->flags & TRREADANY)) {
udisk_abort(transPtr);
dbase = transPtr->dbase;
DBHOLD(dbase);
- bzero(&dbase->cachedVersion, sizeof(struct ubik_version));
+ memset(&dbase->cachedVersion, 0, sizeof(struct ubik_version));
/* give up if no longer current */
if (!urecovery_AllBetter(dbase, transPtr->flags & TRREADANY)) {
success:
udisk_end(transPtr);
/* update version on successful EndTrans */
- bcopy(&dbase->version, &dbase->cachedVersion, sizeof(struct ubik_version));
+ memcpy(&dbase->cachedVersion, &dbase->version, sizeof(struct ubik_version));
DBRELE(dbase);
return 0;
iovec[transPtr->iovec_info.iovec_wrt_len].position = transPtr->seekPos;
iovec[transPtr->iovec_info.iovec_wrt_len].length = length;
- bcopy(buffer,
- &transPtr->iovec_data.iovec_buf_val[transPtr->iovec_data.iovec_buf_len],
- length);
+ memcpy(&transPtr->iovec_data.iovec_buf_val[transPtr->iovec_data.iovec_buf_len], buffer, length);
transPtr->iovec_info.iovec_wrt_len++;
transPtr->iovec_data.iovec_buf_len += length;
gethostname(hostname, sizeof(hostname));
th = gethostbyname(hostname);
if (!th) return UBADHOST;
- bcopy(th->h_addr, &myHost, sizeof(afs_int32));
+ memcpy(&myHost, th->h_addr, sizeof(afs_int32));
*ahost = myHost;
inServer = 0; /* haven't seen -servers yet */
/* otherwise this is a new host name */
th = gethostbyname(tp);
if (!th) return UBADHOST;
- bcopy(th->h_addr, &temp, sizeof(afs_int32));
+ memcpy(&temp, th->h_addr, sizeof(afs_int32));
if (temp != myHost) {
if (counter++ >= MAXSERVERS) return UNHOSTS;
*aothers++ = temp;
printf("udebug: host %s not found in host table\n", hostName);
exit(1);
}
- bcopy(th->h_addr, &hostAddr, sizeof(afs_int32));
+ memcpy(&hostAddr, th->h_addr, sizeof(afs_int32));
}
else hostAddr = htonl(0x7f000001); /* IP localhost */
aparm->altAddr[i] = ntohl(ts->addr[i+1]);
aparm->lastVoteTime = ts->lastVoteTime;
aparm->lastBeaconSent = ts->lastBeaconSent;
- bcopy(&ts->version, &aparm->remoteVersion, sizeof(struct ubik_version));
+ memcpy(&aparm->remoteVersion, &ts->version, sizeof(struct ubik_version));
aparm->lastVote = ts->lastVote;
aparm->up = ts->up;
aparm->beaconSinceDown = ts->beaconSinceDown;
(urecovery_state & UBIK_RECHAVEDB ) ) {
aparm->recoveryState |= UBIK_RECLABELDB;
}
- bcopy(&ubik_dbVersion, &aparm->syncVersion, sizeof(struct ubik_version));
- bcopy(&ubik_dbTid, &aparm->syncTid, sizeof(struct ubik_tid));
+ memcpy(&aparm->syncVersion, &ubik_dbVersion, sizeof(struct ubik_version));
+ memcpy(&aparm->syncTid, &ubik_dbTid, sizeof(struct ubik_tid));
aparm->activeWrite = (ubik_dbase->flags & DBWRITING);
aparm->tidCounter = ubik_dbase->tidCounter;
aparm->addr = ntohl(ts->addr[0]); /* primary interface */
aparm->lastVoteTime = ts->lastVoteTime;
aparm->lastBeaconSent = ts->lastBeaconSent;
- bcopy(&ts->version, &aparm->remoteVersion, sizeof(struct ubik_version));
+ memcpy(&aparm->remoteVersion, &ts->version, sizeof(struct ubik_version));
aparm->lastVote = ts->lastVote;
aparm->up = ts->up;
aparm->beaconSinceDown = ts->beaconSinceDown;
(urecovery_state & UBIK_RECHAVEDB ) ) {
aparm->recoveryState |= UBIK_RECLABELDB;
}
- bcopy(&ubik_dbVersion, &aparm->syncVersion, sizeof(struct ubik_version));
- bcopy(&ubik_dbTid, &aparm->syncTid, sizeof(struct ubik_tid));
+ memcpy(&aparm->syncVersion, &ubik_dbVersion, sizeof(struct ubik_version));
+ memcpy(&aparm->syncTid, &ubik_dbTid, sizeof(struct ubik_tid));
aparm->activeWrite = (ubik_dbase->flags & DBWRITING);
aparm->tidCounter = ubik_dbase->tidCounter;
printf("host %s not found \n", aname);
exit(1);
}
- bcopy(th->h_addr, &addr, sizeof(addr));
+ memcpy(&addr, th->h_addr, sizeof(addr));
return addr;
}
return errno;
usd = (usd_handle_t) malloc(sizeof(*usd));
- bzero(usd, sizeof(*usd));
+ memset(usd, 0, sizeof(*usd));
usd->handle = (void *)fd;
usd->read = usd_FileRead;
usd->write = usd_FileWrite;
*usdP = NULL;
usd = (usd_handle_t) malloc(sizeof(*usd));
- bzero(usd, sizeof(*usd));
+ memset(usd, 0, sizeof(*usd));
usd->handle = (void *)((unsigned long)0);
usd->read = usd_FileRead;
usd->write = usd_FileWrite;
*usdP = NULL;
usd = (usd_handle_t) malloc(sizeof(*usd));
- bzero(usd, sizeof(*usd));
+ memset(usd, 0, sizeof(*usd));
usd->handle = (void *)((unsigned long)1);
usd->read = usd_FileRead;
usd->write = usd_FileWrite;
return nterr_nt2unix(GetLastError(), EIO);
usd = (usd_handle_t) malloc(sizeof(*usd));
- bzero(usd, sizeof(*usd));
+ memset(usd, 0, sizeof(*usd));
_ASSERT(sizeof(devhandle) <= sizeof(usd->handle));
*usdP = NULL;
usd = (usd_handle_t) malloc(sizeof(*usd));
- bzero(usd, sizeof(*usd));
+ memset(usd, 0, sizeof(*usd));
usd->handle = (void *)0;
usd->read = usd_DeviceRead;
usd->write = usd_DeviceWrite;
*usdP = NULL;
usd = (usd_handle_t) malloc(sizeof(*usd));
- bzero(usd, sizeof(*usd));
+ memset(usd, 0, sizeof(*usd));
usd->handle = (void *)1;
usd->read = usd_DeviceRead;
usd->write = usd_DeviceWrite;
#include "y.tab.h"
#include "uss_common.h"
-extern char *index();
int line=1;
#ifdef DEBUG
#define dprint(x) {fprintf(stderr, x); fflush(stderr);}
}
out_cp = out;
- while ((in_var = index(in_text, '$')) != NULL) {
+ while ((in_var = strchr(in_text, '$')) != NULL) {
while(in_text < in_var)
*out_cp++ = *in_text++;
VarNo = *(in_var+1);
*out_cp++ = *in_text++;
if (isQuotedString) {
- nullP = index(out, '"');
+ nullP = strchr(out, '"');
if (nullP == (char *)0)
nullP = out_cp;
}
* we cheat and return ``.''.
*/
strcpy(a_parentBuff, a_path);
- rightSlashP = (char *) rindex(a_parentBuff, '/');
+ rightSlashP = (char *) strrchr(a_parentBuff, '/');
if (rightSlashP) {
*rightSlashP = 0;
*a_componentPP = rightSlashP+1;
extern int errno;
extern afs_int32 KAM_CreateUser();
-extern char *index();
#define uss_kauth_MAX_SIZE 2048
static char gpbuf[BUFSIZ];
/* read a password from stdin, stop on \n or eof */
register int i, tc;
- bzero(gpbuf, sizeof(gpbuf));
+ memset(gpbuf, 0, sizeof(gpbuf));
for(i=0; i<(sizeof(gpbuf)-1); i++) {
tc = fgetc(stdin);
if (tc == '\n' || tc == EOF) break;
uss_whoami, UserCell);
return(-1);
}
- if (index(UserPrincipal, ':') != NULL) {
+ if (strchr(UserPrincipal, ':') != NULL) {
fprintf(stderr, "%s: User name '%s' can't have a colon\n",
uss_whoami, UserPrincipal);
return(-1);
char temp[1000];
extern int line;
-extern char *rindex();
static int Copy();
static int Echo();
}
if (stbuf.st_mode & S_IFDIR) {
- if ((cp = rindex(a_path, '/')) == NULL) {
+ if ((cp = strrchr(a_path, '/')) == NULL) {
strcat(a_proto, "/");
strcat(a_proto, a_path);
}
/*
* If a full pathname was given, just take it as is.
*/
- if (index(a_fileToOpen, '/')) {
+ if (strchr(a_fileToOpen, '/')) {
strcpy(tmp_str, a_fileToOpen);
rv = fopen(a_fileToOpen, "r");
}
#undef USS_PTSERVER_DB
extern int line;
-extern char *rindex();
/*
th = gethostbyname(a_name);
if (!th)
return(0);
- bcopy(th->h_addr, &addr, sizeof(addr));
+ memcpy(&addr, th->h_addr, sizeof(addr));
return(addr);
} /*uss_vol_GetServer*/
/* decimal address, return fake hostent with only hostaddr field good */
tval = 0;
dots = 0;
- bzero(addr, sizeof(addr));
+ memset(addr, 0, sizeof(addr));
while ((tc = *ahost++)) {
if (tc == '.') {
if (dots >= 3) return (struct hostent *) 0; /* too many dots */
afs_int32 int32Date;
struct ktime_date *kdptr;
{
- bzero(kdptr, sizeof(*kdptr));
+ memset(kdptr, 0, sizeof(*kdptr));
kdptr->day = int32Date % (MAX_DAY_VALUE + 1);
if ( kdptr->day != 0 )
afs_int32 value, digit_limit;
afs_int32 type_index;
- bzero(relDatePtr, sizeof(*relDatePtr));
+ memset(relDatePtr, 0, sizeof(*relDatePtr));
type_index = 0;
while ( 1 )
{
struct ktime tk;
-bzero(&tk, sizeof(tk));
+memset(&tk, 0, sizeof(tk));
if ( ParseTime(&tk, astr) )
return (-1); /* syntax error */
register afs_int32 code;
struct ptemp *tp;
- bzero(ak, sizeof(*ak));
+ memset(ak, 0, sizeof(*ak));
code = LocalParseLine(adate, &tt);
if (code) return -1;
for(;tt;tt=tt->next) {
#ifdef KERNEL
#include "../afs/sysincludes.h"
#include "../afs/afsincludes.h"
-#define uuid_memcmp(A,B,C) bcmp(A,B,C)
-#define uuid_memcpy(A,B,C) bcopy(B,A,C)
+#define uuid_memcmp(A,B,C) memcmp(A, B, C)
+#define uuid_memcpy(A,B,C) memcpy(A, B, C)
#else /* KERNEL */
#include <stdio.h>
#include <errno.h>
tbuffer[0] = '\0';
return tbuffer;
}
- bzero(tbuffer, buflen);
+ memset(tbuffer, 0, buflen);
tempString[1] = tempString[2] = 0;
strcpy(tbuffer, "/vicep");
if (avalue < 0 || avalue >= (26*26+26)) {
afs_uint32 *p;
/* get list of file servers in NW byte order */
- bzero(&addrs, sizeof(addrs));
- bzero(&spare3, sizeof(spare3));
+ memset(&addrs, 0, sizeof(addrs));
+ memset(&spare3, 0, sizeof(spare3));
code=ubik_Call(VL_GetAddrs,client,0,Handle,spare2,&spare3,
&server_count,&addrs);
if(code)
printf("cmdebug: can't resolve address for host %s.\n", hostName);
exit(1);
}
- bcopy(thp->h_addr, &addr, sizeof(afs_int32));
+ memcpy(&addr, thp->h_addr, sizeof(afs_int32));
secobj = rxnull_NewServerSecurityObject();
conn = rx_NewConnection(addr, htons(port), 1, secobj, 0);
if (!conn) {
{
char *tp;
strcpy(tspace, apath);
- tp = rindex(tspace, '/');
+ tp = strrchr(tspace, '/');
if (tp) {
*tp = 0;
}
struct cmd_syndesc ts;
/* copy useful stuff from our command slot; we may later have to reorder */
- bcopy(as, &ts, sizeof(ts)); /* copy whole thing */
+ memcpy(&ts, as, sizeof(ts)); /* copy whole thing */
return SetVolCmd(&ts);
}
blob.out_size = MAXSIZE;
blob.in_size = 0;
blob.out = space;
- bzero(space, sizeof(space));
+ memset(space, 0, sizeof(space));
code = pioctl(ti->data, VIOCWHEREIS, &blob, 1);
if (code) {
Die(errno, ti->data);
* name (we know there is one) and splice in the symlink value.
*/
if (true_name[0] != '/') {
- last_component = (char *) rindex(orig_name, '/');
+ last_component = (char *) strrchr(orig_name, '/');
strcpy(++last_component, true_name);
strcpy(true_name, orig_name);
}
/*
* Find rightmost slash, if any.
*/
- last_component = (char *) rindex(true_name, '/');
+ last_component = (char *) strrchr(true_name, '/');
if (last_component) {
/*
* Found it. Designate everything before it as the parent directory,
blob.in_size = strlen(last_component)+1;
blob.out_size = MAXSIZE;
blob.out = space;
- bzero(space, MAXSIZE);
+ memset(space, 0, MAXSIZE);
code = pioctl(parent_dir, VIOC_AFS_STAT_MT_PT, &blob, 1);
/* Check for a cellname in the volume specification, and complain
* if it doesn't match what was specified with -cell */
- if (tmpName = index(volName, ':')) {
+ if (tmpName = strchr(volName, ':')) {
*tmpName = '\0';
if (cellName) {
if (strcasecmp(cellName,volName)) {
for(ti=as->parms[0].items; ti; ti=ti->next) {
/* once per file */
- tp = (char *) rindex(ti->data, '/');
+ tp = (char *) strrchr(ti->data, '/');
if (tp) {
strncpy(tbuffer, ti->data, code=tp-ti->data); /* the dir name */
tbuffer[code] = 0;
struct afsconf_cell info;
struct chservinfo checkserv;
- bzero(&checkserv,sizeof(struct chservinfo));
+ memset(&checkserv, 0, sizeof(struct chservinfo));
blob.in_size=sizeof(struct chservinfo);
blob.in=(caddr_t)&checkserv;
blob.out_size = MAXSIZE;
blob.out = space;
- bzero(space, sizeof(afs_int32)); /* so we assure zero when nothing is copied back */
+ memset(space, 0, sizeof(afs_int32)); /* so we assure zero when nothing is copied back */
/* prepare flags for checkservers command */
temp = 2; /* default to checking local cell only */
Die(errno, 0);
return 1;
}
- bcopy(space, &temp, sizeof(afs_int32));
+ memcpy(&temp, space, sizeof(afs_int32));
if (checkserv.tinterval >= 0) {
if (checkserv.tinterval > 0)
printf("The new down server probe interval (%d secs) is now in effect (old interval was %d secs)\n",
else {
printf("These servers unavailable due to network or server problems: ");
for(j=0; ; j++) {
- bcopy(space + j*sizeof(afs_int32), &temp, sizeof(afs_int32));
+ memcpy(&temp, space + j*sizeof(afs_int32), sizeof(afs_int32));
if (temp == 0) break;
tp = hostutil_GetNameByINet(temp);
printf(" %s", tp);
struct gaginfo gagflags;
struct cmd_item *show;
- bzero (&gagflags, sizeof(struct gaginfo));
+ memset(&gagflags, 0, sizeof(struct gaginfo));
blob.in_size = sizeof(struct gaginfo);
blob.in = (caddr_t) &gagflags;
blob.out_size = MAXSIZE;
blob.out = space;
- bzero(space, sizeof(afs_int32)); /* so we assure zero when nothing is copied back */
+ memset(space, 0, sizeof(afs_int32)); /* so we assure zero when nothing is copied back */
if (show = as->parms[0].items) {
if (!strcasecmp (show->data, "user"))
for(i=0;;i++) {
tp = space;
- bcopy(&i, tp, sizeof(afs_int32));
+ memcpy(tp, &i, sizeof(afs_int32));
blob.out_size = MAXSIZE;
blob.in_size = sizeof(afs_int32);
blob.in = space;
afs_int32 addr;
char *name, tbuffer[20];
- bcopy(tp + j*sizeof(afs_int32), &addr, sizeof(afs_int32));
+ memcpy(&addr, tp + j*sizeof(afs_int32), sizeof(afs_int32));
if (addr == 0) break;
if (resolve) {
scount = ((cellname[0] != '\0') ? MAXCELLHOSTS : MAXHOSTS);
/* Now setup and do the NEWCELL pioctl call */
- bzero(space, (scount+1) * sizeof(afs_int32));
+ memset(space, 0, (scount+1) * sizeof(afs_int32));
tp = space;
lp = (afs_int32 *)tp;
*lp++ = 0x12345678;
pn, ti->data);
}
else {
- bcopy(thp->h_addr, tp, sizeof(afs_int32));
+ memcpy(tp, thp->h_addr, sizeof(afs_int32));
tp += sizeof(afs_int32);
}
}
return 1;
}
}
- else bcopy(thp->h_addr, &hostAddr, sizeof(afs_int32));
+ else memcpy(&hostAddr, thp->h_addr, sizeof(afs_int32));
}
}
else {
input += strlen(ti->data);
*(input++) = '\0';
}
- bcopy(&setp, space, sizeof(afs_int32));
+ memcpy(space, &setp, sizeof(afs_int32));
code = pioctl(0, VIOC_AFS_SYSNAME, &blob, 1);
if (code) {
Die(errno, 0);
return 0;
}
input = space;
- bcopy(input, &setp, sizeof(afs_int32));
+ memcpy(&setp, input, sizeof(afs_int32));
input += sizeof(afs_int32);
if (!setp) {
fprintf(stderr, "No sysname name value was found\n");
pn, info->numServers, VLDB_MAXSERVERS);
exit(1);
}
- bzero(serverconns, sizeof(serverconns));
+ memset(serverconns, 0, sizeof(serverconns));
for (i = 0;i<info->numServers;i++)
serverconns[i] = rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
info->hostAddr[i].sin_port, USER_SERVICE_ID,
}
sp = (struct spref *) (gblob.in + gblob.in_size);
- bcopy (thostent->h_addr_list[t], &(sp->server.s_addr), sizeof(afs_uint32));
+ memcpy(&(sp->server.s_addr), thostent->h_addr_list[t], sizeof(afs_uint32));
sp->rank = (rank > MAXUSHORT ? MAXUSHORT : rank);
gblob.in_size += sizeof(struct spref);
ssp->num_servers++;
blob.in = (char *)&tsb;
blob.out = (char *)&tsb2;
blob.in_size = blob.out_size = sizeof(struct sbstruct);
- bzero (&tsb2, sizeof(tsb2));
+ memset(&tsb2, 0, sizeof(tsb2));
/* once per -file */
for (ti=as->parms[1].items; ti; ti=ti->next) {
if (code) Die(errno, (char *) 0);
else {
tp = space;
- bcopy(tp, &flag, sizeof(afs_int32));
+ memcpy(&flag, tp, sizeof(afs_int32));
printf("Security level is currently ");
if (flag == 1)
printf("crypt (data security).\n");
* name (we know there is one) and splice in the symlink value.
*/
if (true_name[0] != '/') {
- last_component = (char *) rindex(orig_name, '/');
+ last_component = (char *) strrchr(orig_name, '/');
strcpy(++last_component, true_name);
strcpy(true_name, orig_name);
}
/*
* Find rightmost slash, if any.
*/
- last_component = (char *) rindex(true_name, '/');
+ last_component = (char *) strrchr(true_name, '/');
if (last_component) {
/*
* Found it. Designate everything before it as the parent directory,
blob.in = last_component;
blob.in_size = strlen(last_component)+1;
blob.out_size = 0;
- bzero(space, MAXSIZE);
+ memset(space, 0, MAXSIZE);
code = pioctl(parent_dir, VIOC_AFS_FLUSHMOUNT, &blob, 1);
if (dummy > bufferSize) /* find biggest log */
bufferSize = dummy;
lip = (struct logInfo *) malloc(sizeof(struct logInfo));
- bzero((char *)lip, sizeof(*lip));
+ memset((char *)lip, 0, sizeof(*lip));
lip->nextp = allInfo;
allInfo = lip;
lip->name = (char *) malloc(strlen(tname)+1);
if (dummy > bufferSize) /* find biggest log */
bufferSize = dummy;
lip = (struct logInfo *) malloc(sizeof(struct logInfo));
- bzero((char *)lip, sizeof(*lip));
+ memset((char *)lip, 0, sizeof(*lip));
lip->nextp = allInfo;
allInfo = lip;
lip->name = (char *) malloc(strlen(tname)+1);
states |= ICL_SETF_PERSISTENT;
setp = (struct afs_icl_set *) osi_Alloc(sizeof(struct afs_icl_set));
- bzero((caddr_t)setp, sizeof(*setp));
+ memset((caddr_t)setp, 0, sizeof(*setp));
setp->refCount = 1;
if (states & ICL_SETF_FREED)
states &= ~ICL_SETF_ACTIVE; /* if freed, can't be active */
exit (1);
}
}
- bzero((char *)setInfo, infoSize);
+ memset((char *)setInfo, 0, infoSize);
return setInfo;
}
}
}
- bzero((char *)logInfo, infoSize);
+ memset((char *)logInfo, 0, infoSize);
return logInfo;
}
int chainCount[NSERVERS];
if (pnt) {
- bzero((char*)chainCount, sizeof(chainCount));
+ memset((char*)chainCount, 0, sizeof(chainCount));
printf("\n\nPrinting 'afs_servers' structures...\n");
}
findsym( "afs_servers", &symoff);
/* Verify against afs_totalServers. */
if (pnt) {
- bzero((char*)chainCount, sizeof(chainCount));
+ memset((char*)chainCount, 0, sizeof(chainCount));
if (findsym( "afs_totalServers", &symoff)) {
kread(kmem, symoff, (char*)&afs_totalServers, sizeof(afs_int32));
if (afs_totalServers != nServers) {
{
int i;
- bzero(buf,len);
+ memset(buf, 0, len);
#ifdef AFS_OSF_ENV
if (mem) {
#define MAXACL 400
-extern char *index ();
-extern char *rindex ();
#if !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
extern sys_nerr;
extern char *sys_errlist[];
strcpy(parent, file);
- p = rindex(parent, '/');
+ p = strrchr(parent, '/');
if (!p) {
strcpy(parent, ".");
}
/*
* Find rightmost slash, if any.
*/
- last_component = (char *) rindex(true_name, '/');
+ last_component = (char *) strrchr(true_name, '/');
if (last_component) {
/*
* Found it. Designate everything before it as the parent directory,
blob->in_size = strlen(last_component)+1;
blob->out_size = MAXSIZE;
blob->out = space;
- bzero(space, MAXSIZE);
+ memset(space, 0, MAXSIZE);
code = pioctl(parent_dir, VIOC_AFS_STAT_MT_PT, blob, 0);
register struct dinode *dp;
struct inodesc curino;
- bzero((char *)&curino, sizeof(struct inodesc));
+ memset((char *)&curino, 0, sizeof(struct inodesc));
if (statemap[inumber] != DSTATE)
errexit("BAD INODE %d TO DESCEND", statemap[inumber]);
#if defined(ACLS) && defined(AFS_HPUX_ENV)
idesc->id_loc = 0;
for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
dsize = dp->d_reclen;
- bcopy((char *)dp, dbuf, dsize);
+ memcpy(dbuf, (char *)dp, dsize);
idesc->id_dirp = (struct direct *)dbuf;
if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
bp = getdirblk(idesc->id_blkno, blksiz);
- bcopy(dbuf, (char *)dp, dsize);
+ memcpy((char *)dp, dbuf, dsize);
dirty(bp);
sbdirty();
}
dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
dirp->d_reclen = newent.d_reclen;
dirp->d_namlen = strlen(idesc->id_name);
- bcopy(idesc->id_name, dirp->d_name, (int)dirp->d_namlen + 1);
+ memcpy(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1);
return (ALTERED|STOP);
}
{
register struct direct *dirp = idesc->id_dirp;
- if (bcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
+ if (memcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
return (KEEPON);
dirp->d_ino = idesc->id_parent;
return (ALTERED|STOP);
char tempname[BUFSIZ];
extern int pass4check();
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
dp = ginode(orphan);
lostdir = (dp->di_mode & IFMT) == IFDIR;
pwarn("UNREF %s ", lostdir ? "DIR" : "FILE");
return (0);
}
len = strlen(lfname);
- bcopy(lfname, pathp, len + 1);
+ memcpy(pathp, lfname, len + 1);
pathp += len;
len = lftempname(tempname, orphan);
if (makeentry(lfdir, orphan, tempname) == 0) {
}
lncntp[orphan]--;
*pathp++ = '/';
- bcopy(tempname, pathp, len + 1);
+ memcpy(pathp, tempname, len + 1);
pathp += len;
if (lostdir) {
dp = ginode(orphan);
if (parent < ROOTINO || parent >= maxino ||
ino < ROOTINO || ino >= maxino)
return (0);
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
idesc.id_func = mkentry;
idesc.id_number = parent;
dblksize(&sblock, dp, lastbn + 1));
if (bp->b_errs)
goto bad;
- bcopy(bp->b_un.b_buf, firstblk, DIRBLKSIZ);
+ memcpy(firstblk, bp->b_un.b_buf, DIRBLKSIZ);
bp = getdirblk(newblk, sblock.fs_bsize);
if (bp->b_errs)
goto bad;
- bcopy(firstblk, bp->b_un.b_buf, DIRBLKSIZ);
+ memcpy(bp->b_un.b_buf, firstblk, DIRBLKSIZ);
for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
cp < &bp->b_un.b_buf[sblock.fs_bsize];
cp += DIRBLKSIZ)
- bcopy((char *)&emptydir, cp, sizeof emptydir);
+ memcpy(cp, (char *)&emptydir, sizeof emptydir);
dirty(bp);
bp = getdirblk(dp->di_db[lastbn + 1],
dblksize(&sblock, dp, lastbn + 1));
if (bp->b_errs)
goto bad;
- bcopy((char *)&emptydir, bp->b_un.b_buf, sizeof emptydir);
+ memcpy(bp->b_un.b_buf, (char *)&emptydir, sizeof emptydir);
pwarn("NO SPACE LEFT IN %s", pathname);
if (preen)
printf(" (EXPANDED)\n");
freeino(ino);
return (0);
}
- bcopy((char *)&dirhead, bp->b_un.b_buf, sizeof dirhead);
+ memcpy(bp->b_un.b_buf, (char *)&dirhead, sizeof dirhead);
for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
cp < &bp->b_un.b_buf[sblock.fs_fsize];
cp += DIRBLKSIZ)
- bcopy((char *)&emptydir, cp, sizeof emptydir);
+ memcpy(cp, (char *)&emptydir, sizeof emptydir);
dirty(bp);
dp->di_nlink = 2;
inodirty();
inp->i_isize = dp->di_size;
inp->i_numblks = dp->di_blocks * sizeof(daddr_t);
inp->i_parent = parent;
- bcopy((char *)&dp->di_db[0], (char *)&inp->i_blks[0],
- (int)inp->i_numblks);
+ memcpy((char *)&inp->i_blks[0], (char *)&dp->di_db[0], (int)inp->i_numblks);
}
#endif
if (ino == ROOTINO) {
if (dirp->d_ino != idesc->id_parent)
return (KEEPON);
- bcopy(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1);
+ memcpy(idesc->id_name, dirp->d_name, (int)dirp->d_namlen + 1);
return (STOP|FOUND);
}
extern int pass4check();
struct dinode *dp;
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass4check;
idesc.id_number = ino;
msgprintf("%s: AFS file system partition was modified; forcing full salvage\n", devname);
devname = unrawname(devname);
- special = (char *) rindex(devname, '/');
+ special = (char *) strrchr(devname, '/');
if (!special++) special = devname;
strcpy(pname, "/etc/vfsck."); /* Using /etc, rather than /tmp, since
/tmp is a link to /usr/tmp on some systems, and isn't mounted now */
/*
* Find all allocated blocks.
*/
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass1check;
inumber = 0;
continue;
dp = ginode(inumber);
if ((dp->di_mode & IFMT) == 0) {
- if (bcmp((char *)dp->di_db, (char *)zino.di_db,
+ if (memcmp((char *)dp->di_db, (char *)zino.di_db,
NDADDR * sizeof(daddr_t)) ||
- bcmp((char *)dp->di_ib, (char *)zino.di_ib,
- NIADDR * sizeof(daddr_t)) ||
+ memcmp((char *)dp->di_ib, (char *)zino.di_ib, NIADDR * sizeof(daddr_t)) ||
#if defined(ACLS) && defined(AFS_HPUX_ENV)
dp->di_mode || dp->di_size || dp->di_contin) {
if (dp->di_contin != 0)
struct inodesc idesc;
ino_t inumber;
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass1bcheck;
duphead = duplist;
register struct dinode *dp;
struct inodesc rootdesc;
- bzero((char *)&rootdesc, sizeof(struct inodesc));
+ memset((char *)&rootdesc, 0, sizeof(struct inodesc));
rootdesc.id_type = ADDR;
rootdesc.id_func = pass2check;
rootdesc.id_number = ROOTINO;
#endif
} else if (dirp->d_reclen < 2 * entrysize) {
proto.d_reclen = dirp->d_reclen;
- bcopy((char *)&proto, (char *)dirp, entrysize);
+ memcpy((char *)dirp, (char *)&proto, entrysize);
if (reply("FIX") == 1)
ret |= ALTERED;
} else {
n = dirp->d_reclen - entrysize;
proto.d_reclen = entrysize;
- bcopy((char *)&proto, (char *)dirp, entrysize);
+ memcpy((char *)dirp, (char *)&proto, entrysize);
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
dirp = (struct direct *)((char *)(dirp) + entrysize);
- bzero((char *)dirp, n);
+ memset((char *)dirp, 0, n);
dirp->d_reclen = n;
if (reply("FIX") == 1)
ret |= ALTERED;
idesc->id_entryno++;
lncntp[dirp->d_ino]--;
dirp = (struct direct *)((char *)(dirp) + n);
- bzero((char *)dirp, n);
+ memset((char *)dirp, 0, n);
dirp->d_reclen = n;
}
if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
#endif
} else {
proto.d_reclen = dirp->d_reclen;
- bcopy((char *)&proto, (char *)dirp, entrysize);
+ memcpy((char *)dirp, (char *)&proto, entrysize);
if (reply("FIX") == 1)
ret |= ALTERED;
}
*pathp = '\0';
errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
}
- bcopy(dirp->d_name, pathp, (int)dirp->d_namlen + 1);
+ memcpy(pathp, dirp->d_name, (int)dirp->d_namlen + 1);
pathp += dirp->d_namlen;
idesc->id_entryno++;
n = 0;
ino_t inumber, orphan;
int loopcnt;
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
for (inumber = ROOTINO; inumber <= lastino; inumber++) {
#if defined(ACLS) && defined(AFS_HPUX_ENV)
#endif /* ACLS */
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
idesc.id_type = ADDR;
idesc.id_func = pass4check;
for (inumber = ROOTINO; inumber <= lastino; inumber++) {
struct cg *ocg = (struct cg *) buf;
#endif /* AFS_NEWCG_ENV */
- bzero((char *)newcg, (int)fs->fs_cgsize);
+ memset((char *)newcg, 0, (int)fs->fs_cgsize);
newcg->cg_niblk = fs->fs_ipg;
#ifdef AFS_NEWCG_ENV
postype = (int) fs->fs_postblformat;
#endif /* AFS_NEWCG_ENV */
}
- bzero((char *)&idesc[0], sizeof idesc);
+ memset((char *)&idesc[0], 0, sizeof idesc);
for (i = 0; i < 3; i++)
idesc[i].id_type = ADDR;
- bzero((char *)&cstotal, sizeof(struct csum));
+ memset((char *)&cstotal, 0, sizeof(struct csum));
(void)time(&now);
#ifdef notdef
/* this is the original from UCB/McKusick, but it is clearly wrong. It is
newcg->cg_irotor = cg->cg_irotor;
else
newcg->cg_irotor = 0;
- bzero((char *)&newcg->cg_frsum[0], sizeof newcg->cg_frsum);
+ memset((char *)&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum);
#ifdef AFS_NEWCG_ENV
- bzero((char *)&cg_blktot(newcg)[0], sumsize + mapsize);
+ memset((char *)&cg_blktot(newcg)[0], 0, sumsize + mapsize);
#else /* AFS_NEWCG_ENV */
- bzero((char *)newcg->cg_btot, sizeof(newcg->cg_btot));
- bzero((char *)newcg->cg_b, sizeof(newcg->cg_b));
- bzero((char *)newcg->cg_iused, sizeof(newcg->cg_iused));
- bzero((char *)newcg->cg_free, howmany(fs->fs_fpg, NBBY));
+ memset((char *)newcg->cg_btot, 0, sizeof(newcg->cg_btot));
+ memset((char *)newcg->cg_b, 0, sizeof(newcg->cg_b));
+ memset((char *)newcg->cg_iused, 0, sizeof(newcg->cg_iused));
+ memset((char *)newcg->cg_free, 0, howmany(fs->fs_fpg, NBBY));
#endif /* AFS_NEWCG_ENV */
#ifdef AFS_NEWCG_ENV
if (fs->fs_postblformat == FS_42POSTBLFMT)
cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
cs = &fs->fs_cs(fs, c);
- if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
+ if (memcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN CYL GROUP (SUPERBLK)")) {
- bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
+ memcpy((char *)cs, (char *)&newcg->cg_cs, sizeof *cs);
sbdirty();
}
#ifdef AFS_NEWCG_ENV
if (cvtflag) {
- bcopy((char *)newcg, (char *)cg, (int)fs->fs_cgsize);
+ memcpy((char *)cg, (char *)newcg, (int)fs->fs_cgsize);
cgdirty();
continue;
}
#endif /* AFS_NEWCG_ENV */
#ifdef AFS_NEWCG_ENV
- if (bcmp(cg_inosused(newcg),
+ if (memcmp(cg_inosused(newcg),
cg_inosused(cg), mapsize) != 0 &&
dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
- bcopy(cg_inosused(newcg), cg_inosused(cg), mapsize);
+ memcpy(cg_inosused(cg), cg_inosused(newcg), mapsize);
cgdirty();
}
#else /* AFS_NEWCG_ENV */
- if (bcmp(newcg->cg_iused,
+ if (memcmp(newcg->cg_iused,
cg->cg_iused, mapsize) != 0 &&
dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
- bcopy(newcg->cg_iused, cg->cg_iused, mapsize);
+ memcpy(cg->cg_iused, newcg->cg_iused, mapsize);
cgdirty();
}
#endif /* AFS_NEWCG_ENV */
- if ((bcmp((char *)newcg, (char *)cg, basesize) != 0 ||
+ if ((memcmp((char *)newcg, (char *)cg, basesize) != 0 ||
#ifdef AFS_NEWCG_ENV
- bcmp((char *)&cg_blktot(newcg)[0],
- (char *)&cg_blktot(cg)[0], sumsize) != 0) &&
+ memcmp((char *)&cg_blktot(newcg)[0], (char *)&cg_blktot(cg)[0], sumsize) != 0) &&
#else /* AFS_NEWCG_ENV */
- bcmp((char *)newcg->cg_btot,
- (char *)cg->cg_btot, sumsize) != 0) &&
+ memcmp((char *)newcg->cg_btot, (char *)cg->cg_btot, sumsize) != 0) &&
#endif /* AFS_NEWCG_ENV */
dofix(&idesc[2], "SUMMARY INFORMATION BAD")) {
#ifdef AFS_NEWCG_ENV
- bcopy((char *)newcg, (char *)cg, basesize);
- bcopy((char *)&cg_blktot(newcg)[0],
- (char *)&cg_blktot(cg)[0], sumsize);
+ memcpy((char *)cg, (char *)newcg, basesize);
+ memcpy((char *)&cg_blktot(cg)[0], (char *)&cg_blktot(newcg)[0], sumsize);
#else /* AFS_NEWCG_ENV */
- bcopy((char *)newcg, (char *)cg, basesize);
- bcopy((char *)newcg->cg_btot, (char *)cg->cg_btot, sumsize);
+ memcpy((char *)cg, (char *)newcg, basesize);
+ memcpy((char *)cg->cg_btot, (char *)newcg->cg_btot, sumsize);
#endif /* AFS_NEWCG_ENV */
cgdirty();
}
if (fs->fs_postblformat == FS_42POSTBLFMT)
fs->fs_nrpos = savednrpos;
#endif /* AFS_NEWCG_ENV */
- if (bcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
+ if (memcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
&& dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
- bcopy((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs);
+ memcpy((char *)&fs->fs_cstotal, (char *)&cstotal, sizeof *cs);
fs->fs_ronly = 0;
sbfine(fs);
sbdirty();
return(SKIP);
entry->next = NULL;
entry->flags = 0;
- bcopy((char *)&pl_descp[1], entry->name,
- pl_descp->pl_namelen);
+ memcpy(entry->name, (char *)&pl_descp[1], pl_descp->pl_namelen);
entry->blkno = idesc->id_blkno;
entry->blksize = blksize;
entry->offset = idesc->id_loc;
/* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY))
char *malloc(), *calloc();
-char *index();
struct disklabel *getdisklabel();
setup(dev)
}
#endif /* AFS_NEWCG_ENV */
if (asblk.b_dirty) {
- bcopy((char *)&sblock, (char *)&altsblock,
- (int)sblock.fs_sbsize);
+ memcpy((char *)&altsblock, (char *)&sblock, (int)sblock.fs_sbsize);
flush(fswritefd, &asblk);
}
/*
#if !defined(__alpha) && !defined(AFS_SUN56_ENV)
#if !defined(AFS_HPUX110_ENV)
/* HPUX110 will use UpdateAlternateSuper() below */
- bcopy((char *)sblock.fs_csp, (char *)altsblock.fs_csp,
- sizeof sblock.fs_csp);
+ memcpy((char *)altsblock.fs_csp, (char *)sblock.fs_csp, sizeof sblock.fs_csp);
#endif /* ! AFS_HPUX110_ENV */
#endif /* ! __alpha */
#if defined(AFS_SUN56_ENV)
- bcopy((char *)sblock.fs_u.fs_csp_pad, (char *)altsblock.fs_u.fs_csp_pad,
- sizeof (sblock.fs_u.fs_csp_pad));
+ memcpy((char *)altsblock.fs_u.fs_csp_pad, (char *)sblock.fs_u.fs_csp_pad, sizeof (sblock.fs_u.fs_csp_pad));
#endif
- bcopy((char *)sblock.fs_fsmnt, (char *)altsblock.fs_fsmnt,
- sizeof sblock.fs_fsmnt);
+ memcpy((char *)altsblock.fs_fsmnt, (char *)sblock.fs_fsmnt, sizeof sblock.fs_fsmnt);
#ifndef AFS_HPUX_ENV
- bcopy((char *)sblock.fs_sparecon, (char *)altsblock.fs_sparecon,
- sizeof sblock.fs_sparecon);
+ memcpy((char *)altsblock.fs_sparecon, (char *)sblock.fs_sparecon, sizeof sblock.fs_sparecon);
#endif
#if defined(AFS_DEC_ENV)
- bcopy((char *)sblock.fs_extra, (char *)altsblock.fs_extra,
- sizeof sblock.fs_extra);
+ memcpy((char *)altsblock.fs_extra, (char *)sblock.fs_extra, sizeof sblock.fs_extra);
altsblock.fs_deftimer = sblock.fs_deftimer;
altsblock.fs_lastfsck = sblock.fs_lastfsck;
altsblock.fs_gennum = sblock.fs_gennum;
#if defined(AFS_HPUX110_ENV)
UpdateAlternateSuper(&sblock, &altsblock);
#endif /* AFS_HPUX110_ENV */
- if (bcmp((char *)&sblock, (char *)&altsblock, (int)sblock.fs_sbsize)) {
+ if (memcmp((char *)&sblock, (char *)&altsblock, (int)sblock.fs_sbsize)) {
#ifdef __alpha
- if (bcmp((char *)&sblock.fs_blank[0],
+ if (memcmp((char *)&sblock.fs_blank[0],
(char *)&altsblock.fs_blank[0],
MAXCSBUFS*sizeof(int))) {
- bzero((char *)sblock.fs_blank,
- sizeof(sblock.fs_blank));
+ memset((char *)sblock.fs_blank, 0, sizeof(sblock.fs_blank));
} else {
#endif /* __alpha */
badsb(listerr,
#endif
rwerror("SEEK", blk);
errs = 0;
- bzero(buf, (int)size);
+ memset(buf, 0, (int)size);
printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
#ifdef AFS_SUN5_ENV
for (cp = buf, i = 0; i < btodb(size); i++, cp += DEV_BSIZE) {
strcpy(namebuf, "?");
return;
}
- bzero((char *)&idesc, sizeof(struct inodesc));
+ memset((char *)&idesc, 0, sizeof(struct inodesc));
idesc.id_type = DATA;
cp = &namebuf[BUFSIZ - 1];
*cp = '\0';
cp -= len;
if (cp < &namebuf[MAXNAMLEN])
break;
- bcopy(namebuf, cp, len);
+ memcpy(cp, namebuf, len);
*--cp = '/';
ino = idesc.id_number;
}
strcpy(namebuf, "?");
return;
}
- bcopy(cp, namebuf, &namebuf[BUFSIZ] - cp);
+ memcpy(namebuf, cp, &namebuf[BUFSIZ] - cp);
}
void
SetCallBackStruct(AddCallBack(client->host, Fid), CallBack);
else {
struct AFSFid myFid;
- bzero(&myFid, sizeof(struct AFSFid));
+ memset(&myFid, 0, sizeof(struct AFSFid));
myFid.Volume = Fid->Volume;
SetCallBackStruct(AddVolCallBack(client->host, &myFid), CallBack);
}
SetCallBackStruct(AddCallBack(client->host, Fid), CallBack);
else {
struct AFSFid myFid;
- bzero(&myFid, sizeof(struct AFSFid));
+ memset(&myFid, 0, sizeof(struct AFSFid));
myFid.Volume = Fid->Volume;
SetCallBackStruct(AddVolCallBack(client->host, &myFid), CallBack);
}
&CallBacks->AFSCBs_val[i]);
else {
struct AFSFid myFid;
- bzero(&myFid, sizeof(struct AFSFid));
+ memset(&myFid, 0, sizeof(struct AFSFid));
myFid.Volume = tfid->Volume;
SetCallBackStruct(AddVolCallBack(client->host, &myFid),
&CallBacks->AFSCBs_val[i]);
assert((SetAccessList(&targetptr, &volptr, &newACL, &newACLSize,
&parentwhentargetnotdir, (AFSFid *)0, 0)) == 0);
assert(parentwhentargetnotdir == 0);
- bcopy((char *)VVnodeACL(parentptr), (char *)newACL, VAclSize(parentptr));
+ memcpy((char *)newACL, (char *)VVnodeACL(parentptr), VAclSize(parentptr));
/* update the status for the target vnode */
Update_TargetVnodeStatus(targetptr, TVS_MKDIR, client, InStatus,
FS_LOCK
AFSCallStats.GetStatistics++, AFSCallStats.TotalCalls++;
FS_UNLOCK
- bzero(Statistics, sizeof(*Statistics));
+ memset(Statistics, 0, sizeof(*Statistics));
SetAFSStats(Statistics);
SetVolumeStats(Statistics);
SetSystemStats(Statistics);
*/
dataBytes = sizeof(struct afs_Stats);
dataBuffP = (afs_int32 *)malloc(dataBytes);
- bcopy(&afs_cmstats, dataBuffP, dataBytes);
+ memcpy(dataBuffP, &afs_cmstats, dataBytes);
a_dataP->AFS_CollData_len = dataBytes>>2;
a_dataP->AFS_CollData_val = dataBuffP;
#else
dataBytes = sizeof(struct afs_PerfStats);
dataBuffP = (afs_int32 *)osi_Alloc(dataBytes);
- bcopy(&afs_perfstats, dataBuffP, dataBytes);
+ memcpy(dataBuffP, &afs_perfstats, dataBytes);
a_dataP->AFS_CollData_len = dataBytes>>2;
a_dataP->AFS_CollData_val = dataBuffP;
break;
dataBytes = sizeof(struct fs_stats_FullPerfStats);
dataBuffP = (afs_int32 *)osi_Alloc(dataBytes);
- bcopy(&afs_FullPerfStats, dataBuffP, dataBytes);
+ memcpy(dataBuffP, &afs_FullPerfStats, dataBytes);
a_dataP->AFS_CollData_len = dataBytes>>2;
a_dataP->AFS_CollData_val = dataBuffP;
#endif
return(EINVAL);
if ((newACL->size + 4) > VAclSize(targetptr))
return(E2BIG);
- bcopy((char *) newACL,(char *) VVnodeACL(targetptr),(int)(newACL->size));
+ memcpy((char *) VVnodeACL(targetptr), (char *) newACL, (int)(newACL->size));
acl_FreeACL(&newACL);
return(0);
return(EINVAL);
if ((newACL->size + 4) > VAclSize(targetptr))
return(E2BIG);
- bcopy((char *) newACL,(char *) VVnodeACL(targetptr),(int)(newACL->size));
+ memcpy((char *) VVnodeACL(targetptr), (char *) newACL, (int)(newACL->size));
acl_FreeACL(&newACL);
return(0);
for (part = DiskPartitionList; part && i < AFS_MSTATDISKS; part = part->next) {
stats->Disks[i].TotalBlocks = part->totalUsable;
stats->Disks[i].BlocksAvailable = part->free;
- bzero(stats->Disks[i].Name, AFS_DISKNAMESIZE);
+ memset(stats->Disks[i].Name, 0, AFS_DISKNAMESIZE);
strncpy(stats->Disks[i].Name, part->name, AFS_DISKNAMESIZE);
i++;
}
register struct CallBack *cb;
time_t now;
- bzero(&fid, sizeof(fid));
+ memset(&fid, 0, sizeof(fid));
argc--; argv++;
while (argc && **argv == '-') {
noptions++;
printf("usage: pxclient <serverHost>\n");
exit(1);
}
- bzero((char *)&host, sizeof(struct sockaddr_in));
+ memset((char *)&host, 0, sizeof(struct sockaddr_in));
host.sin_family = AF_INET;
host.sin_addr.s_addr = inet_addr(av[0]);
if (host.sin_addr.s_addr != -1) {
hp = gethostbyname(av[0]);
if (hp) {
host.sin_family = hp->h_addrtype;
- bcopy(hp->h_addr, (caddr_t)&host.sin_addr, hp->h_length);
+ memcpy((caddr_t)&host.sin_addr, hp->h_addr, hp->h_length);
hostname = hp->h_name;
} else {
printf("unknown server host %s\n", av[0]);
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &filelength);
++argp;
- bzero(&InStatus, sizeof(struct afsStoreStatus));
+ memset(&InStatus, 0, sizeof(struct afsStoreStatus));
sscanf(&(*argp)[0], "%d", &mode);
++argp;
sscanf(&(*argp)[0], "%d", &owner);
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
- bzero(&InStatus, sizeof(struct afsStoreStatus));
+ memset(&InStatus, 0, sizeof(struct afsStoreStatus));
sscanf(&(*argp)[0], "%d", &mode);
++argp;
sscanf(&(*argp)[0], "%d", &owner);
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
name = &argp[0][0];
++argp;
- bzero(&nameFid, sizeof(struct afsFidName));
+ memset(&nameFid, 0, sizeof(struct afsFidName));
strcpy(nameFid.name, name);
code = ubik_Call(AFS_RemoveFile, cstruct, 0, &fid, &nameFid, &hyp0, 0,
&OutDirStatus, &OutFidStatus, &outFid, &tsync);
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
name = &argp[0][0];
++argp;
- bzero(&InStatus, sizeof(struct afsStoreStatus));
+ memset(&InStatus, 0, sizeof(struct afsStoreStatus));
sscanf(&(*argp)[0], "%d", &mode);
++argp;
sscanf(&(*argp)[0], "%d", &owner);
++argp;
sscanf(&(*argp)[0], "%d", &ounique);
++argp;
- bzero(&OldDirFid, sizeof(struct afsFid));
+ memset(&OldDirFid, 0, sizeof(struct afsFid));
OldDirFid.Volume.low = 10; /* XXX */
OldDirFid.Vnode = ovnode;
OldDirFid.Unique = ounique;
oname = &argp[0][0];
++argp;
- bzero(&OldName, sizeof(struct afsFidName));
+ memset(&OldName, 0, sizeof(struct afsFidName));
strcpy(OldName.name, oname);
sscanf(&(*argp)[0], "%d", &nvnode);
++argp;
sscanf(&(*argp)[0], "%d", &nunique);
++argp;
- bzero(&NewDirFid, sizeof(struct afsFid));
+ memset(&NewDirFid, 0, sizeof(struct afsFid));
NewDirFid.Volume.low = 10; /* XXX */
NewDirFid.Vnode = nvnode;
NewDirFid.Unique = nunique;
nname = &argp[0][0];
++argp;
- bzero(&NewName, sizeof(struct afsFidName));
+ memset(&NewName, 0, sizeof(struct afsFidName));
strcpy(NewName.name, nname);
code = ubik_Call(AFS_Rename, cstruct, 0, &OldDirFid, &OldName, &NewDirFid, &NewName, &hyp0, 0,
&OutOldDirStatus, &OutNewDirStatus,
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
linkcontents = &argp[0][0];
++argp;
- bzero(&InStatus, sizeof(struct afsStoreStatus));
+ memset(&InStatus, 0, sizeof(struct afsStoreStatus));
sscanf(&(*argp)[0], "%d", &mode);
++argp;
sscanf(&(*argp)[0], "%d", &owner);
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&existingFid, sizeof(struct afsFid));
+ memset(&existingFid, 0, sizeof(struct afsFid));
existingFid.Volume.low = 10; /* XXX */
existingFid.Vnode = vnode;
existingFid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
name = &argp[0][0];
++argp;
- bzero(&InStatus, sizeof(struct afsStoreStatus));
+ memset(&InStatus, 0, sizeof(struct afsStoreStatus));
sscanf(&(*argp)[0], "%d", &mode);
++argp;
sscanf(&(*argp)[0], "%d", &owner);
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
name = &argp[0][0];
++argp;
- bzero(&nameFid, sizeof(struct afsFidName));
+ memset(&nameFid, 0, sizeof(struct afsFidName));
strcpy(nameFid.name, name);
code = ubik_Call(AFS_RemoveDir, cstruct, 0, &fid, &nameFid, &hyp0, 0,
&OutDirStatus, &outFid, &tsync);
++argp;
sscanf(&(*argp)[0], "%d", &length);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
++argp;
sscanf(&(*argp)[0], "%d", &unique);
++argp;
- bzero(&fid, sizeof(struct afsFid));
+ memset(&fid, 0, sizeof(struct afsFid));
fid.Volume.low = 10; /* XXX */
fid.Vnode = vnode;
fid.Unique = unique;
sscanf(&(*argp)[0], "%d", &tokenId);
++argp;
- bzero(&MinToken, sizeof(struct afsToken));
+ memset(&MinToken, 0, sizeof(struct afsToken));
MinToken.tokenID.low = tokenId; /* XXX */
code = ubik_Call(AFS_GetToken, cstruct, 0, &fid, &MinToken, &hyp0, 0,
&RealToken, &OutStatus, &tsync);
struct afsFidExp fx;
int code;
- bzero(&fx, sizeof(struct afsFidExp));
+ memset(&fx, 0, sizeof(struct afsFidExp));
sscanf(&(*argp)[0], "%d", &fx.fid.Volume.low);
++argp;
sscanf(&(*argp)[0], "%d", &fx.fid.Vnode);
sscanf(&(*argp)[0], "%d", &numExec);
++argp;
sscanf(&(*argp)[0], "%d", &fx.keepAliveTime);
- bzero(&fex, sizeof(struct afsBulkFEX));
+ memset(&fex, 0, sizeof(struct afsBulkFEX));
fex.afsBulkFEX_val = &fx;
fex.afsBulkFEX_len = 1;
code = ubik_Call(AFS_BulkKeepAlive, cstruct, 0, &fex, numExec, 0, 0, 0, &spare4);
entry = CEFree;
CEFree = entry->next;
CEs++;
- bzero((char *)entry, CLIENT_TO_ZERO(entry));
+ memset((char *)entry, 0, CLIENT_TO_ZERO(entry));
return(entry);
} /*GetCE*/
entry = HTFree;
HTFree = entry->next;
HTs++;
- bzero((char *)entry, HOST_TO_ZERO(entry));
+ memset((char *)entry, 0, HOST_TO_ZERO(entry));
return(entry);
} /*GetHT*/
afs_uint32 now = FT_ApproxTime();
- bzero((char *)&zerofid, sizeof(zerofid));
+ memset((char *)&zerofid, 0, sizeof(zerofid));
/*
* Send a probe to the workstation if it hasn't been heard from in
* 15 minutes
{
IH_RELEASE(file->dirh_handle);
- bzero((char *)file, sizeof(DirHandle));
+ memset((char *)file, 0, sizeof(DirHandle));
}
FidZero (file)
DirHandle * file;
{
- bzero((char *)file, sizeof(DirHandle));
+ memset((char *)file, 0, sizeof(DirHandle));
}
FidEq (afile, bfile)
#if !defined (AFS_AIX_ENV) && !defined (AFS_HPUX_ENV)
/* Soon should handle aix profiling */
AllocProfBuf();
- bzero (profBuf, profBufSize);
+ memset(profBuf, 0, profBufSize);
/* the following code is to replace the monitor call below */
/* monitor (PROFSTART, &etext, profBuf, profBufSize, 0); */
profileHeader.startpc = PROFSTART;
code = afsconf_GetKey(confDir, akvno, tkey.key);
if (code)
return code;
- bcopy(tkey.key, akey, sizeof(tkey.key));
+ memcpy(akey, tkey.key, sizeof(tkey.key));
return 0;
} /*get_key*/
}
else {
char hoststr[16];
- bcopy(he->h_addr, &FS_HostAddr_NBO, 4);
+ memcpy(&FS_HostAddr_NBO, he->h_addr, 4);
afs_inet_ntoa_r(FS_HostAddr_NBO, hoststr);
FS_HostAddr_HBO = ntohl(FS_HostAddr_NBO);
ViceLog(0,("FileServer %s has address %s (0x%x or 0x%x in host byte order)\n",
/*
* Zero all xstat-related structures.
*/
- bzero((char *)(&afs_perfstats), sizeof(struct afs_PerfStats));
+ memset((char *)(&afs_perfstats), 0, sizeof(struct afs_PerfStats));
#if FS_STATS_DETAILED
- bzero((char *)(&afs_FullPerfStats), sizeof(struct fs_stats_FullPerfStats));
+ memset((char *)(&afs_FullPerfStats), 0, sizeof(struct fs_stats_FullPerfStats));
/*
* That's not enough. We have to set reasonable minima for
char *apath; {
register char *tp;
strcpy(tspace, apath);
- tp = rindex(tspace, '/');
+ tp = strrchr(tspace, '/');
if (tp) {
*tp = 0;
}
if (fromv == 1) {
if (tov == 1) {
- bcopy (fromaddr, toaddr, sizeof(struct vlheader_1));
+ memcpy(toaddr, fromaddr, sizeof(struct vlheader_1));
tvp1 = (struct vlheader_1 *) toaddr;
w = write (fd, tvp1, sizeof(struct vlheader_1));
} else if (tov == 2 || tov == 3) {
tvp1 = (struct vlheader_1 *) fromaddr;
tvp2 = (struct vlheader_2 *) toaddr;
- bzero(tvp2, sizeof(struct vlheader_2));
+ memset(tvp2, 0, sizeof(struct vlheader_2));
tvp2->vital_header.vldbversion = htonl(tov);
tvp2->vital_header.headersize = htonl(sizeof(struct vlheader_2));
diff = ntohl(tvp2->vital_header.headersize) -
return EINVAL;
} else if (fromv == 2 || fromv == 3 || fromv == 4) {
if (tov == 2 || tov == 3 || tov == 4) {
- bcopy (fromaddr, toaddr, sizeof(struct vlheader_2));
+ memcpy(toaddr, fromaddr, sizeof(struct vlheader_2));
tvp2 = (struct vlheader_2 *) toaddr;
tvp2->vital_header.vldbversion = htonl(tov);
w = write (fd, tvp2, sizeof(struct vlheader_2));
} else if (tov == 1) {
tvp2 = (struct vlheader_2 *) fromaddr;
tvp1 = (struct vlheader_1 *) toaddr;
- bzero(tvp1, sizeof(struct vlheader_1));
+ memset(tvp1, 0, sizeof(struct vlheader_1));
tvp1->vital_header.vldbversion = htonl(1);
tvp1->vital_header.headersize = htonl(sizeof(struct vlheader_1));
diff = ntohl(tvp1->vital_header.headersize) - ntohl(tvp2->vital_header.headersize);
vl.nextIdHash[1] = vlentryp->nextIdHash[1];
vl.nextIdHash[2] = vlentryp->nextIdHash[2];
vl.nextNameHash = vlentryp->nextNameHash;
- bcopy(vlentryp->name, vl.name, 65);
+ memcpy(vl.name, vlentryp->name, 65);
for (i = 0; i < 8; i++) {
vl.serverNumber[i] = vlentryp->serverNumber[i];
vl.serverPartition[i] = vlentryp->serverPartition[i];
struct vlentry_2 vl;
struct vlentry_3 *xnvlentry = (struct vlentry_3 *) vlentryp;
- bzero((char *)&vl, sizeof (struct vlentry_2));
+ memset((char *)&vl, 0, sizeof (struct vlentry_2));
vl.volumeId[0] = xnvlentry->volumeId[0];
vl.volumeId[1] = xnvlentry->volumeId[1];
vl.volumeId[2] = xnvlentry->volumeId[2];
}
if (ntohl(xnvlentry->nextNameHash))
vl.nextNameHash = xnvlentry->nextNameHash;
- bcopy(xnvlentry->name, vl.name, 65);
+ memcpy(vl.name, xnvlentry->name, 65);
for (i = 0; i < 8; i++) {
vl.serverNumber[i] = xnvlentry->serverNumber[i];
vl.serverPartition[i] = xnvlentry->serverPartition[i];
diff = (tovers == 1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2))
- (fromvers == 1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2));
- bzero((char *)&vl, sizeof (struct vlentry_1));
+ memset((char *)&vl, 0, sizeof (struct vlentry_1));
vl.volumeId[0] = xnvlentry->volumeId[0];
vl.volumeId[1] = xnvlentry->volumeId[1];
vl.volumeId[2] = xnvlentry->volumeId[2];
if (ntohl(xnvlentry->nextNameHash))
vl.nextNameHash = htonl(ntohl(xnvlentry->nextNameHash) + diff);
- bcopy(xnvlentry->name, vl.name, 65);
+ memcpy(vl.name, xnvlentry->name, 65);
for (i = 0; i < 8; i++) {
vl.serverNumber[i] = xnvlentry->serverNumber[i];
vl.serverPartition[i] = xnvlentry->serverPartition[i];
* blocks go away and all vlentries after them move up in the vldb file.
* When this happens, the linked list pointers need to be updated.
*/
- bcopy(vlentryp, &vl, sizeof(vl));
+ memcpy(&vl, vlentryp, sizeof(vl));
for (i=0; i<3; i++) {
vl.nextIdHash[i] = Conv4to3(vl.nextIdHash[i]);
}
char *apath; {
register char *tp;
strcpy(tspace, apath);
- tp = rindex(tspace, '/');
+ tp = strrchr(tspace, '/');
if (tp) {
*tp = 0;
}
struct vlheader_2 *tvp2;
int i,j,diff;
- bcopy (fromaddr, toaddr, sizeof(struct vlheader_2));
+ memcpy(toaddr, fromaddr, sizeof(struct vlheader_2));
tvp2 = (struct vlheader_2 *) toaddr;
tvp2->vital_header.vldbversion = htonl(2);
}
th = gethostbyname(aname);
if (!th) return 0;
- bcopy(th->h_addr, &addr, sizeof(addr));
+ memcpy(&addr, th->h_addr, sizeof(addr));
return addr;
}
while (1) {
char line[500];
int nargs, releasetype;
- bzero(&entry, sizeof(entry));
- bzero(&updateentry, sizeof(updateentry));
- bzero(&listbyattributes, sizeof(listbyattributes));
+ memset(&entry, 0, sizeof(entry));
+ memset(&updateentry, 0, sizeof(updateentry));
+ memset(&listbyattributes, 0, sizeof(listbyattributes));
printf("vl> ");
if (fgets(line, 499, stdin) == NULL) {
printf("\n");
} else if (!strcmp(oper,"ls")) {
afs_int32 index, count, next_index;
for (index = 0; 1; index = next_index) {
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
code = ubik_Call(VL_ListEntry,cstruct,0,index,&count,&next_index,&entry);
if (code) {
printf("VL_ListEntry returned code = %d\n", code);
}
printf("Enumerating all entries in vldb...\n");
for (index = 0; 1; index = next_index) {
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
code = ubik_Call(VL_ListEntry,cstruct,0,index,&count,&next_index,&entry);
if (code) {
printf("VL_ListEntry returned code = %d\n", code);
}
printf("Volumes not found in main hash tables in vldb...\n");
for (index = 0; 1; index = next_index) {
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
code = ubik_Call(VL_ListEntry,cstruct,0,index,&count,&next_index,&entry);
if (code) {
printf("VL_ListEntry returned code = %d\n", code);
exit(1);
}
printf("Volumes not found in main hash tables in vldb will be fixed...\n");
- bzero(&updateentry, sizeof(updateentry));
+ memset(&updateentry, 0, sizeof(updateentry));
for (index = 0; 1; index = next_index) {
int n1=0, n2=0, n3=0, n4=0;
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
code = ubik_Call(VL_ListEntry,cstruct,0,index,&count,&next_index,&entry);
if (code) {
printf("VL_ListEntry returned code = %d\n", code);
bulkentries entries;
struct vldbentry *entry;
- bzero(&entries,sizeof(entries));
+ memset(&entries, 0, sizeof(entries));
fill_listattributes_entry(&listbyattributes, argp, nargs);
display_listattributes_entry(&listbyattributes, 0);
code = ubik_Call(VL_ListAttributes, cstruct, 0, &listbyattributes, &nentries, &entries);
for (si=0; si!=-1; si=nsi) {
nentries = 0;
- bzero(&entries,sizeof(entries));
+ memset(&entries, 0, sizeof(entries));
code = ubik_Call(VL_ListAttributesN2, cstruct, 0,
&listbyattributes, name, si,
&nentries, &entries, &nsi);
fill_listattributes_entry(&listbyattributes, argp, nargs);
display_listattributes_entry(&listbyattributes, 0);
- bzero(&linkedvldbs, sizeof(vldb_list));
+ memset(&linkedvldbs, 0, sizeof(vldb_list));
code = ubik_Call(VL_LinkedList, cstruct, 0, &listbyattributes,
&netries, &linkedvldbs);
if (code) {
fill_listattributes_entry(&listbyattributes, argp, nargs);
display_listattributes_entry(&listbyattributes, 0);
- bzero(&linkedvldbs, sizeof(vldb_list));
+ memset(&linkedvldbs, 0, sizeof(vldb_list));
code = ubik_Call(VL_LinkedListN, cstruct, 0, &listbyattributes,
&netries, &linkedvldbs);
if (code) {
sscanf(&(*argp)[0], "%d", &voltype);
code = ubik_Call(VL_GetEntryByID, cstruct, 0, id, voltype, &entry);
display_entry(&entry, code);
- bzero(&updateentry, sizeof(updateentry));
+ memset(&updateentry, 0, sizeof(updateentry));
updateentry.Mask = VLUPDATE_VOLNAMEHASH;
printf("\tRehashing namehash table for %s (%d)\n", entry.name, entry.volumeId[RWVOL]);
code = ubik_Call(VL_UpdateEntry, cstruct, 0, entry.volumeId[RWVOL], -1, &updateentry, 0);
} else if (!strcmp(oper,"undelete")) {
afs_int32 index, count, next_index;
- bzero(&updateentry, sizeof(updateentry));
+ memset(&updateentry, 0, sizeof(updateentry));
sscanf(&(*argp)[0], "%d", &id);
++argp, --nargs;
sscanf(&(*argp)[0], "%d", &voltype);
}
printf("Searching vldb for volume %d...\n", id);
for (index = 0; 1; index = next_index) {
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
code = ubik_Call(VL_ListEntry,cstruct,0,index,&count,&next_index,&entry);
if (code) {
printf("VL_ListEntry returned code = %d\n", code);
struct vldbentry *entry;
afsUUID uuid;
- bzero(&uuid,sizeof(uuid));
+ memset(&uuid, 0, sizeof(uuid));
sscanf(&(*argp)[0], "%d", &i);
++argp, --nargs;
- bcopy(&i, uuid.node, sizeof(i));
+ memcpy(uuid.node, &i, sizeof(i));
if (nargs < 0 || nargs > 16) {
printf("Illegal # entries = %d\n", nargs);
printf("cmdebug: can't resolve address for host %s");
continue;
}
- bcopy((afs_int32 *)h1->h_addr, &a1, sizeof(afs_uint32));
+ memcpy(&a1, (afs_int32 *)h1->h_addr, sizeof(afs_uint32));
++argp, --nargs;
printf(" to %s\n", *argp);
printf("cmdebug: can't resolve address for host %s", *argp);
continue;
}
- bcopy((afs_int32 *)h2->h_addr, &a2, sizeof(afs_uint32));
+ memcpy(&a2, (afs_int32 *)h2->h_addr, sizeof(afs_uint32));
printf("changing 0x%x to 0x%x\n", ntohl(a1), ntohl(a2));
code = ubik_Call(VL_ChangeAddr, cstruct, 0, ntohl(a1), ntohl(a2));
int ipindex, ipaddrs;
afsUUID nulluuid;
- bzero(&nulluuid, sizeof(nulluuid));
+ memset(&nulluuid, 0, sizeof(nulluuid));
if (verbose)
printf("Check Multihomed blocks\n");
maxentries = (header.vital_header.eofPtr / sizeof(vlentry)) + 1;
record = (struct er *)malloc(maxentries * sizeof(struct er));
- bzero((char *)record, (maxentries * sizeof(struct er)));
- bzero((char *)serveraddrs, sizeof(serveraddrs));
+ memset((char *)record, 0, (maxentries * sizeof(struct er)));
+ memset((char *)serveraddrs, 0, sizeof(serveraddrs));
/* Will fill in the record array of entries it found */
ReadAllEntries(&header);
goto abort;
}
- bzero(&tentry, sizeof(struct nvlentry));
+ memset(&tentry, 0, sizeof(struct nvlentry));
/* Convert to its internal representation; both in host byte order */
if (errorcode = vldbentry_to_vlentry(trans, newentry, &tentry)) {
FreeBlock(trans, blockindex);
goto abort;
}
- bzero(&tentry, sizeof(struct nvlentry));
+ memset(&tentry, 0, sizeof(struct nvlentry));
/* Convert to its internal representation; both in host byte order */
if (errorcode = nvldbentry_to_vlentry(trans, newentry, &tentry)) {
FreeBlock(trans, blockindex);
if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op))
return errorcode;
VLog(5, ("GetStats %\n", rxinfo(rxcall)));
- bcopy((char *)&cheader.vital_header, (char *) vital_header, sizeof(vital_vlheader));
- bcopy((char *)&dynamic_statistics, (char *) stats, sizeof(vldstats));
+ memcpy((char *) vital_header, (char *)&cheader.vital_header, sizeof(vital_vlheader));
+ memcpy((char *) stats, (char *)&dynamic_statistics, sizeof(vldstats));
return(ubik_EndTrans(trans));
}
COUNT_REQ(VLGETADDRS);
addrsp->bulkaddrs_len = *nentries = 0;
addrsp->bulkaddrs_val = 0;
- bzero (spare3, sizeof (struct VLCallBack));
+ memset(spare3, 0, sizeof (struct VLCallBack));
if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op))
return errorcode;
{
int i, j;
- bzero(VldbEntry, sizeof(struct vldbentry));
+ memset(VldbEntry, 0, sizeof(struct vldbentry));
strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
for (i=0; i < OMAXNSERVERS; i++) {
if (VlEntry->serverNumber[i] == BADSERVERID) break;
{
int i, j;
- bzero(VldbEntry, sizeof(struct vldbentry));
+ memset(VldbEntry, 0, sizeof(struct vldbentry));
strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
for (i=0; i < NMAXNSERVERS; i++) {
if (VlEntry->serverNumber[i] == BADSERVERID) break;
{
int i, j;
- bzero(VldbEntry, sizeof(struct vldbentry));
+ memset(VldbEntry, 0, sizeof(struct vldbentry));
strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name));
for (i=0; i < NMAXNSERVERS; i++) {
if (VlEntry->serverNumber[i] == BADSERVERID) break;
/* Change the registered uuuid addresses */
if (exp) {
- bzero(&tuuid, sizeof(afsUUID));
+ memset(&tuuid, 0, sizeof(afsUUID));
afs_htonuuid(&tuuid);
exp->ex_hostuuid = tuuid;
code = vlwrite(atrans, DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[base]),
printf("vlserver: couldn't get address of this host (%s).\n", hostname);
exit(1);
}
- bcopy(th->h_addr,&myHost,sizeof(afs_int32));
+ memcpy(&myHost, th->h_addr, sizeof(afs_int32));
#if !defined(AFS_HPUX_ENV) && !defined(AFS_NT40_ENV) && !defined(AFS_DJGPP_ENV)
signal(SIGXCPU, CheckSignal_Signal);
vldb_confdir = tdir; /* Preserve our configuration dir */
/* rxvab no longer supported */
- bzero(&tkey, sizeof(tkey));
+ memset(&tkey, 0, sizeof(tkey));
if (noAuth) afsconf_SetNoAuthFlag(tdir, 1);
}
rx_SetRxDeadTime(50);
- bzero(HostAddress, sizeof(HostAddress));
+ memset(HostAddress, 0, sizeof(HostAddress));
initialize_dstats();
sc[0] = rxnull_NewServerSecurityObject();
for (i=0;i<MAXTYPES;i++)
nentry.nextIdHash[i] = htonl(nep->nextIdHash[i]);
nentry.nextNameHash = htonl(nep->nextNameHash);
- bcopy(nep->name, nentry.name, VL_MAXNAMELEN);
- bcopy(nep->serverNumber, nentry.serverNumber, NMAXNSERVERS);
- bcopy(nep->serverPartition, nentry.serverPartition, NMAXNSERVERS);
- bcopy(nep->serverFlags, nentry.serverFlags, NMAXNSERVERS);
+ memcpy(nentry.name, nep->name, VL_MAXNAMELEN);
+ memcpy(nentry.serverNumber, nep->serverNumber, NMAXNSERVERS);
+ memcpy(nentry.serverPartition, nep->serverPartition, NMAXNSERVERS);
+ memcpy(nentry.serverFlags, nep->serverFlags, NMAXNSERVERS);
bufp = (char *)&nentry;
} else {
- bzero(&oentry, sizeof(struct vlentry));
+ memset(&oentry, 0, sizeof(struct vlentry));
nep = (struct nvlentry *)buffer;
for (i=0;i<MAXTYPES;i++)
oentry.volumeId[i] = htonl(nep->volumeId[i]);
for (i=0;i<MAXTYPES;i++)
oentry.nextIdHash[i] = htonl(nep->nextIdHash[i]);
oentry.nextNameHash = htonl(nep->nextNameHash);
- bcopy(nep->name, oentry.name, VL_MAXNAMELEN);
- bcopy(nep->serverNumber, oentry.serverNumber, OMAXNSERVERS);
- bcopy(nep->serverPartition, oentry.serverPartition, OMAXNSERVERS);
- bcopy(nep->serverFlags, oentry.serverFlags, OMAXNSERVERS);
+ memcpy(oentry.name, nep->name, VL_MAXNAMELEN);
+ memcpy(oentry.serverNumber, nep->serverNumber, OMAXNSERVERS);
+ memcpy(oentry.serverPartition, nep->serverPartition, OMAXNSERVERS);
+ memcpy(oentry.serverFlags, nep->serverFlags, OMAXNSERVERS);
bufp = (char *)&oentry;
}
return vlwrite(trans, offset, bufp, length);
for(i=0;i<MAXTYPES;i++)
nbufp->nextIdHash[i] = ntohl(nep->nextIdHash[i]);
nbufp->nextNameHash = ntohl(nep->nextNameHash);
- bcopy(nep->name, nbufp->name, VL_MAXNAMELEN);
- bcopy(nep->serverNumber, nbufp->serverNumber, NMAXNSERVERS);
- bcopy(nep->serverPartition, nbufp->serverPartition, NMAXNSERVERS);
- bcopy(nep->serverFlags, nbufp->serverFlags, NMAXNSERVERS);
+ memcpy(nbufp->name, nep->name, VL_MAXNAMELEN);
+ memcpy(nbufp->serverNumber, nep->serverNumber, NMAXNSERVERS);
+ memcpy(nbufp->serverPartition, nep->serverPartition, NMAXNSERVERS);
+ memcpy(nbufp->serverFlags, nep->serverFlags, NMAXNSERVERS);
} else {
oep = (struct vlentry *)bufp;
nbufp = (struct nvlentry *)buffer;
- bzero(nbufp, sizeof (struct nvlentry));
+ memset(nbufp, 0, sizeof (struct nvlentry));
for(i=0;i<MAXTYPES;i++)
nbufp->volumeId[i] = ntohl(oep->volumeId[i]);
nbufp->flags = ntohl(oep->flags);
for(i=0;i<MAXTYPES;i++)
nbufp->nextIdHash[i] = ntohl(oep->nextIdHash[i]);
nbufp->nextNameHash = ntohl(oep->nextNameHash);
- bcopy(oep->name, nbufp->name, VL_MAXNAMELEN);
- bcopy(oep->serverNumber, nbufp->serverNumber, NMAXNSERVERS);
- bcopy(oep->serverPartition, nbufp->serverPartition, NMAXNSERVERS);
- bcopy(oep->serverFlags, nbufp->serverFlags, NMAXNSERVERS);
+ memcpy(nbufp->name, oep->name, VL_MAXNAMELEN);
+ memcpy(nbufp->serverNumber, oep->serverNumber, NMAXNSERVERS);
+ memcpy(nbufp->serverPartition, oep->serverPartition, NMAXNSERVERS);
+ memcpy(nbufp->serverFlags, oep->serverFlags, NMAXNSERVERS);
}
return 0;
}
vldbversion = ntohl(cheader.vital_header.vldbversion);
if (!ubcode && (vldbversion != 0)) {
- bcopy(cheader.IpMappedAddr, HostAddress, sizeof(cheader.IpMappedAddr));
+ memcpy(HostAddress, cheader.IpMappedAddr, sizeof(cheader.IpMappedAddr));
for (i=0; i<MAXSERVERID+1; i++) { /* cvt HostAddress to host order */
HostAddress[i] = ntohl(HostAddress[i]);
}
printf("Can't read VLDB header, re-initialising...\n");
/* try to write a good header */
- bzero(&cheader,sizeof(cheader));
+ memset(&cheader, 0, sizeof(cheader));
cheader.vital_header.vldbversion = htonl(VLDBVERSION);
cheader.vital_header.headersize = htonl(sizeof(cheader));
/* DANGER: Must get this from a master place!! */
if (!ex_addr[base])
ERROR_EXIT(VL_NOMEM);
}
- bzero((char *)ex_addr[base], VL_ADDREXTBLK_SIZE);
+ memset((char *)ex_addr[base], 0, VL_ADDREXTBLK_SIZE);
/* Write the full extension block at end of vldb */
ex_addr[base]->ex_flags = htonl(VLCONTBLOCK);
}
cheader.vital_header.allocs++;
if (write_vital_vlheader(trans)) return 0;
- bzero (tentry, sizeof(nvlentry)); /* zero new entry */
+ memset(tentry, 0, sizeof(nvlentry)); /* zero new entry */
return blockindex;
}
/* check validity of blockindex just to be on the safe side */
if (!index_OK (trans, blockindex)) return VL_BADINDEX;
- bzero (&tentry, sizeof(nvlentry));
+ memset(&tentry, 0, sizeof(nvlentry));
tentry.nextIdHash[0] = cheader.vital_header.freePtr; /* already in network order */
tentry.flags = htonl(VLFREE);
cheader.vital_header.freePtr = htonl(blockindex);
/* initialize a clone header */
int ci_InitHead(struct clone_head *ah)
{
- bzero(ah, sizeof(*ah));
+ memset(ah, 0, sizeof(*ah));
return 0;
}
#endif
if (wpath) {
strcpy(pbuf, pbuffer);
- ptr = (char *)rindex(pbuf, '/');
+ ptr = (char *)strrchr(pbuf, '/');
if (ptr) {
*ptr = '\0';
strcpy(wpath, pbuf);
} else
return (char *)0;
}
- ptr = (char *)rindex(pbuffer, '/');
+ ptr = (char *)strrchr(pbuffer, '/');
if (ptr) {
strcpy(pbuffer, ptr+1);
return pbuffer;
return (char *) 0; /* failed */
}
-extern char *rindex();
char *unrawname(name)
char *name;
{
char *dp;
struct stat stb;
- if ((dp = rindex(name, '/')) == 0)
+ if ((dp = strrchr(name, '/')) == 0)
return (name);
if (stat(name, &stb) < 0)
return (name);
static char rawbuf[32];
char *dp;
- if ((dp = rindex(name, '/')) == 0)
+ if ((dp = strrchr(name, '/')) == 0)
return (0);
*dp = 0;
(void)strcpy(rawbuf, name);
{
int sd;
- bzero(addr, sizeof(*addr));
+ memset(addr, 0, sizeof(*addr));
assert((sd = socket(AF_INET, SOCK_STREAM, 0)) >= 0);
addr->sin_addr.s_addr = htonl(0x7f000001);
addr->sin_family = AF_INET; /* was localhost->h_addrtype */
/* record the info */
if (!allInodes || allInodes->freePtr >= MAXATONCE) {
ti = (struct ilist *) malloc(sizeof(struct ilist));
- bzero(ti, sizeof(*ti));
+ memset(ti, 0, sizeof(*ti));
ti->next = allInodes;
allInodes = ti;
}
Device device;
{
static SalvageCacheCheck = 1;
- bzero(dir, sizeof(DirHandle));
+ memset(dir, 0, sizeof(DirHandle));
dir->dirh_device = device;
dir->dirh_volume = volume;
{
IH_RELEASE(file->dirh_handle);
- bzero(file, sizeof(DirHandle));
+ memset(file, 0, sizeof(DirHandle));
}
FidZero (file)
DirHandle * file;
{
- bzero(file, sizeof(DirHandle));
+ memset(file, 0, sizeof(DirHandle));
}
FidEq (afile, bfile)
/* next, obliterate the index and fflush (and fsync) it */
STREAM_SEEK(afile, *aoffset, 0); /* seek back to start of vnode index region */
- bzero(buf, sizeof(buf)); /* zero out our proto-vnode */
+ memset(buf, 0, sizeof(buf)); /* zero out our proto-vnode */
for(i=0;i<nscanned;i++) {
if (STREAM_WRITE(buf, vcp->diskSize, 1, afile) != 1)
goto fail;
#define contentsDInode 0x08 /* list contents of dir inode */
#define volInfo 0x10 /* list info from vol header */
-extern char *rindex();
extern DirEnt *lookup();
extern char *getFileName(), *getDirName(), *printStack();
extern DirEnt* hash[];
} else {
/* growing file - grow in a reasonable increment */
char *buf = (char *)malloc(16*1024);
- bzero(buf, 16*1024);
+ memset(buf, 0, 16*1024);
FDH_WRITE(fdP, buf, 16*1024);
free(buf);
}
#else /* AFS_PTHREAD_ENV */
LWP_CurrentProcess(&vnp->writer);
#endif /* AFS_PTHREAD_ENV */
- bzero(&vnp->disk, sizeof(vnp->disk));
+ memset(&vnp->disk, 0, sizeof(vnp->disk));
vnp->changed_newTime = 0; /* set this bit when vnode is updated */
vnp->changed_oldTime = 0; /* set this on CopyOnWrite. */
vnp->delete = 0;
if (vnp->delete) {
/* No longer any directory entries for this vnode. Free the Vnode */
- bzero(&vnp->disk, sizeof (vnp->disk));
+ memset(&vnp->disk, 0, sizeof (vnp->disk));
mlkLastDelete = vnp->vnodeNumber;
/* delete flag turned off further down */
VNLog(202, 2, vnp->vnodeNumber, (afs_int32) vnp);
if (dsizeOnly && !saveinodes)
printf("Volume-Id\t Volsize Auxsize Inodesize AVolsize SizeDiff (VolName)\n");
while (dp = readdir(dirp)) {
- p = (char *)rindex(dp->d_name, '.');
+ p = (char *)strrchr(dp->d_name, '.');
if (p != NULL && strcmp(p, VHDREXT) == 0) {
HandleVolume(partP, dp->d_name);
Totvolsize += totvolsize;
Log("Can't salvage '%s'. Not enough memory\n", partP->name);
return;
}
- bzero(thisjob, sizeof(struct job));
+ memset(thisjob, 0, sizeof(struct job));
thisjob->partP = partP;
thisjob->jobnumb = jobcount;
jobcount++;
if (deleteMe)
*deleteMe = 0;
- bzero(&tempHeader, sizeof(tempHeader));
+ memset(&tempHeader, 0, sizeof(tempHeader));
tempHeader.stamp.magic = VOLUMEHEADERMAGIC;
tempHeader.stamp.version = VOLUMEHEADERVERSION;
tempHeader.id = isp->volumeId;
isp->volSummary->header.volumeAcl = 0;
isp->volSummary->header.volumeMountTable = 0;
- if (bcmp(&isp->volSummary->header, &tempHeader, sizeof(struct VolumeHeader))) {
+ if (memcmp(&isp->volSummary->header, &tempHeader, sizeof(struct VolumeHeader))) {
/* We often remove the name before calling us, so we make a fake one up */
if (isp->volSummary->fileName) {
strcpy(name, isp->volSummary->fileName);
}
}
if (headerFd) {
- bcopy(&tempHeader,&isp->volSummary->header,sizeof(struct VolumeHeader));
+ memcpy(&isp->volSummary->header, &tempHeader, sizeof(struct VolumeHeader));
if (Testing) {
if (!Showmode) Log("It would have written a new header file for volume %u\n", isp->volumeId);
} else {
/* The following code should be moved into vutil.c */
if (sp->inodeType == VI_VOLINFO) {
struct timeval tp;
- bzero(&header.volumeInfo, sizeof (header.volumeInfo));
+ memset(&header.volumeInfo, 0, sizeof (header.volumeInfo));
header.volumeInfo.stamp = sp->stamp;
header.volumeInfo.id = isp->volumeId;
header.volumeInfo.parentId = isp->RWvolumeId;
if (VNDISK_GET_INO(vnode) == 0) {
if (RW) {
/* Log("### DEBUG ### Deleted Vnode with 0 inode (vnode %d)\n", vnodeNumber); */
- bzero(vnode, vcp->diskSize);
+ memset(vnode, 0, vcp->diskSize);
vnodeChanged = 1;
}
}
if (vcp->magic != vnode->vnodeMagic) {
/* bad magic #, probably partially created vnode */
Log("Partially allocated vnode %d deleted.\n", vnodeNumber);
- bzero(vnode, vcp->diskSize);
+ memset(vnode, 0, vcp->diskSize);
vnodeChanged = 1;
goto vnodeDone;
}
} else {
if (!Showmode) Log("Vnode %d (unique %d): bad directory vnode (no inode number listed); vnode deleted, vnode mod time=%s", vnodeNumber, vnode->uniquifier, ctime((time_t *)&(vnode->serverModifyTime)));
}
- bzero(vnode, vcp->diskSize);
+ memset(vnode, 0, vcp->diskSize);
vnodeChanged = 1;
} else {
/* Should not reach here becuase we checked for
assert(fdP != NULL);
size = FDH_SIZE(fdP);
assert(size != -1);
- bzero(buf, 1024);
+ memset(buf, 0, 1024);
if (size > 1024) size = 1024;
code = FDH_READ(fdP, buf, size);
assert(code == size);
/* Remember rootdir DirSummary _after_ it has been judged */
if (dir.vnodeNumber == 1 && dir.unique == 1) {
- bcopy(&dir, rootdir, sizeof(struct DirSummary));
+ memcpy(rootdir, &dir, sizeof(struct DirSummary));
*rootdirfound = 1;
}
code = IH_DEC(alinkH, VNDISK_GET_INO(&vnode), vid);
assert(code == 0);
}
- bzero(&vnode, sizeof(vnode));
+ memset(&vnode, 0, sizeof(vnode));
}
} else if (vnp->count) {
if (!Showmode) {
void VolumeHeaderToDisk(VolumeDiskHeader_t *dh, VolumeHeader_t *h)
{
- bzero((char*)dh, sizeof(VolumeDiskHeader_t));
+ memset((char*)dh, 0, sizeof(VolumeDiskHeader_t));
dh->stamp = h->stamp;
dh->id = h->id;
dh->parent = h->parent;
*/
void DiskToVolumeHeader(VolumeHeader_t *h, VolumeDiskHeader_t *dh)
{
- bzero((char*)h, sizeof(VolumeHeader_t));
+ memset((char*)h, 0, sizeof(VolumeHeader_t));
h->stamp = dh->stamp;
h->id = dh->id;
h->parent = dh->parent;
* area and mark it as initialized.
*/
if (! (V_stat_initialized(vp))) {
- bzero((char *)(V_stat_area(vp)), VOL_STATS_BYTES);
+ memset((char *)(V_stat_area(vp)), 0, VOL_STATS_BYTES);
V_stat_initialized(vp) = 1;
}
#endif /* TRANSARC_VOL_STATS */
assert(bp != NULL);
index->bitmap = bp;
bp += index->bitmapSize;
- bzero(bp, VOLUME_BITMAP_GROWSIZE);
+ memset(bp, 0, VOLUME_BITMAP_GROWSIZE);
index->bitmapOffset = index->bitmapSize;
index->bitmapSize += VOLUME_BITMAP_GROWSIZE;
*bp = 1;
* All we need to do is bzero the entire VOL_STATS_BYTES of
* the detailed volume statistics area.
*/
- bzero((char *)(V_stat_area(vp)), VOL_STATS_BYTES);
+ memset((char *)(V_stat_area(vp)), 0, VOL_STATS_BYTES);
#endif /* TRANSARC_VOL_STATS */
} /*It's been more than a day of collection*/
*ec = 0;
- bzero(&vol, sizeof (vol));
+ memset(&vol, 0, sizeof (vol));
vol.id = volumeId;
vol.parentId = parentId;
vol.copyDate = time(0); /* The only date which really means when this
nearInode %= partition->f_files;
#endif
VLockPartition(partname);
- bzero(&tempHeader, sizeof (tempHeader));
+ memset(&tempHeader, 0, sizeof (tempHeader));
tempHeader.stamp.magic = VOLUMEHEADERMAGIC;
tempHeader.stamp.version = VOLUMEHEADERVERSION;
tempHeader.id = vol.id;
id = to->id;
parent = to->parentId;
copydate = to->copyDate;
- bcopy(from, to, sizeof(*from));
+ memcpy(to, from, sizeof(*from));
to->id = id;
to->parentId = parent;
to->copyDate = copydate;
ClearVolumeStats_r(vol)
register VolumeDiskData *vol;
{
- bzero(vol->weekUse, sizeof(vol->weekUse));
+ memset(vol->weekUse, 0, sizeof(vol->weekUse));
vol->dayUse = 0;
vol->dayUseDate = 0;
}
{
register tag;
afs_uint32 trash;
- bzero(vol, sizeof(*vol));
+ memset(vol, 0, sizeof(*vol));
while ((tag = iod_getc(iodp)) > D_MAX && tag != EOF) {
switch (tag) {
case 'i':
/* Pad the rest of the buffer with zeros. Remember offset we started
* padding. Keep total tally of padding.
*/
- bzero(p+n, howMany-n);
+ memset(p+n, 0, howMany-n);
if (!pad)
offset = (status.st_size - nbytes) + n;
pad += (howMany-n);
char buf[SIZEOF_LARGEDISKVNODE], zero[SIZEOF_LARGEDISKVNODE];
register struct VnodeDiskObject *vnode = (struct VnodeDiskObject *) buf;
- bzero(zero, sizeof(zero)); /* zero out our proto-vnode */
+ memset(zero, 0, sizeof(zero)); /* zero out our proto-vnode */
fdP = IH_OPEN(vp->vnodeIndex[class].handle);
if (fdP == NULL)
return -1;
if (nVnodes > 0) {
Buf = (afs_int32 *) malloc(nVnodes * sizeof(afs_int32));
if (Buf == NULL) return 1;
- bzero((char *)Buf, nVnodes * sizeof(afs_int32));
+ memset((char *)Buf, 0, nVnodes * sizeof(afs_int32));
STREAM_SEEK(afile, offset = vcp->diskSize, 0);
while (1) {
code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
V_pref(vp, nearInode);
while (tag == D_VNODE) {
int haveStuff = 0;
- bzero(buf, sizeof (buf));
+ memset(buf, 0, sizeof (buf));
if (!ReadInt32(iodp, (afs_uint32 *)&vnodeNumber))
break;
afs_int32 device;
{
private SalvageCacheCheck = 1;
- bzero(dir, sizeof(DirHandle));
+ memset(dir, 0, sizeof(DirHandle));
dir->dirh_volume = volume;
dir->dirh_device = device;
{
IH_RELEASE(file->dirh_handle);
- bzero(file, sizeof(DirHandle));
+ memset(file, 0, sizeof(DirHandle));
}
FidZero (file)
DirHandle * file;
{
- bzero(file, sizeof(DirHandle));
+ memset(file, 0, sizeof(DirHandle));
}
FidEq (afile, bfile)
char tag, c;
afs_int32 magic;
-/* bzero(&dh, sizeof(dh)); */
+/* memset(&dh, 0, sizeof(dh)); */
magic = ntohl(readvalue(4));
dh->version = ntohl(readvalue(4));
int code, i, done, entries;
char tag, c;
-/* bzero(&vh, sizeof(vh)); */
+/* memset(&vh, 0, sizeof(vh)); */
done = 0;
while (!done) {
afs_int32 vnode;
afs_int32 mode=0;
-/* bzero(&vn, sizeof(vn)); */
+/* memset(&vn, 0, sizeof(vn)); */
vn.dataSize = 0;
vn.vnode = 0;
vn.parent = 0;
}
rx_GetIFInfo();
rx_SetRxDeadTime(420);
- bzero(busyFlags, sizeof(busyFlags));
+ memset(busyFlags, 0, sizeof(busyFlags));
/* Open FileLog and map stdout, stderr into it */
OpenLog(AFSDIR_SERVER_VOLSERLOG_FILEPATH);
int code;
int length;
- bzero(vnode, SIZEOF_LARGEDISKVNODE);
+ memset(vnode, 0, SIZEOF_LARGEDISKVNODE);
V_pref(vp, nearInode);
inodeNumber = IH_CREATE(V_linkHandle(vp), V_device(vp),
int i, nconns, is_incremental;
if (results)
- bzero(results, sizeof(manyResults));
+ memset(results, 0, sizeof(manyResults));
if (!afsconf_SuperUser(tdir, acid, caller))
return VOLSERBAD_ACCESS;/*not a super user*/
partList.partId[j++] = i;
}
pEntries->partEntries_val = (afs_int32 *) malloc(j * sizeof(int));
- bcopy((char *)&partList, (char *)pEntries->partEntries_val, j * sizeof(int));
+ memcpy((char *)pEntries->partEntries_val, (char *)&partList, j * sizeof(int));
pEntries->partEntries_len = j;
#else
code = stat("/",&rbuf); /*interested in buf->st_dev*/
}
}
pEntries->partEntries_val = (afs_int32 *) malloc(j * sizeof(int));
- bcopy((char *)&partList, (char *)pEntries->partEntries_val, j * sizeof(int));
+ memcpy((char *)pEntries->partEntries_val, (char *)&partList, j * sizeof(int));
pEntries->partEntries_len = j;
#endif
return 0;
/*
* Copy out the stat fields in a single operation.
*/
- bcopy((char *)&(volDiskDataP->stat_reads[0]),
- (char *)&(xInfoP->stat_reads[0]),
- numStatBytes);
+ memcpy((char *)&(xInfoP->stat_reads[0]), (char *)&(volDiskDataP->stat_reads[0]), numStatBytes);
/*
* We're done copying. Detach the volume and iterate (at this
/*
* Copy out the stat fields in a single operation.
*/
- bcopy((char *)&(volDiskDataP->stat_reads[0]),
- (char *)&(xInfoP->stat_reads[0]),
- numStatBytes);
+ memcpy((char *)&(xInfoP->stat_reads[0]), (char *)&(volDiskDataP->stat_reads[0]), numStatBytes);
/*
* We're done copying. Detach the volume and iterate.
}
}
tt = (struct volser_trans *) malloc(sizeof(struct volser_trans));
- bzero(tt, sizeof(struct volser_trans));
+ memset(tt, 0, sizeof(struct volser_trans));
tt->volid = avol;
tt->partition = apart;
tt->next = allTrans;
static void qInit(ahead)
struct tqHead *ahead;
{
- bzero((char *)ahead, sizeof(struct tqHead));
+ memset((char *)ahead, 0, sizeof(struct tqHead));
return;
}
} else {
th = gethostbyname(aname);
if (!th) return 0;
- bcopy(th->h_addr, &addr, sizeof(addr));
+ memcpy(&addr, th->h_addr, sizeof(addr));
}
if (addr == htonl(0x7f000001)) { /* local host */
if (code) return 0;
th = gethostbyname(hostname); /* returns host byte order */
if (!th) return 0;
- bcopy(th->h_addr, &addr, sizeof(addr));
+ memcpy(&addr, th->h_addr, sizeof(addr));
}
return (addr);
fprintf(STDOUT,"The partitions on the server are:\n");
for(i = 0 ; i < cnt ; i++){
if(dummyPartList.partFlags[i] & PARTVALID){
- bzero(pname,sizeof(pname));
+ memset(pname, 0, sizeof(pname));
MapPartIdIntoName(dummyPartList.partId[i],pname);
fprintf(STDOUT," %10s ",pname);
total++;
}
/* Zero out search attributes */
- bzero(&attributes,sizeof(struct VldbListByAttributes));
+ memset(&attributes, 0, sizeof(struct VldbListByAttributes));
if (as->parms[1].items) { /* -prefix */
strncpy(prefix, as->parms[1].items->data, VOLSER_MAXVOLNAME);
fflush(STDOUT);
/* Get all the VLDB entries on a server and/or partition */
- bzero(&arrayEntries, sizeof(arrayEntries));
+ memset(&arrayEntries, 0, sizeof(arrayEntries));
vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
if (vcode) {
fprintf(STDERR,"Could not access the VLDB for attributes\n");
}
for (thisindex = 0; (thisindex != -1); thisindex = nextindex) {
- bzero(&arrayEntries, sizeof(arrayEntries));
+ memset(&arrayEntries, 0, sizeof(arrayEntries));
centries = 0;
nextindex = -1;
tarray = ttarray;
/* Copy them in */
- bcopy((char *)arrayEntries.nbulkentries_val,
- ((char *)tarray)+tarraysize, parraysize);
+ memcpy(((char *)tarray)+tarraysize, (char *)arrayEntries.nbulkentries_val, parraysize);
tarraysize += parraysize;
}
}
char *ccode;
int match;
- bzero(&attributes,sizeof(struct VldbListByAttributes));
+ memset(&attributes, 0, sizeof(struct VldbListByAttributes));
attributes.Mask = 0;
seenprefix = (as->parms[0].items ? 1 : 0);
}
}
- bzero(&arrayEntries, sizeof(arrayEntries)); /* initialize to hint the stub to alloc space */
+ memset(&arrayEntries, 0, sizeof(arrayEntries)); /* initialize to hint the stub to alloc space */
vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
if (vcode) {
fprintf(STDERR,"Could not access the VLDB for attributes\n");
}
attributes.flag = VLOP_ALLOPERS;
attributes.Mask |= VLLIST_FLAG;
- bzero(&arrayEntries, sizeof(arrayEntries)); /*initialize to hint the stub to alloc space */
+ memset(&arrayEntries, 0, sizeof(arrayEntries)); /*initialize to hint the stub to alloc space */
vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);
if(vcode) {
fprintf(STDERR,"Could not access the VLDB for attributes\n");
tid = 0;
aconn = (struct rx_connection *)0;
error = 0;
- bzero (&tstatus, sizeof(struct volintInfo));
+ memset(&tstatus, 0, sizeof(struct volintInfo));
tstatus.dayUse = -1;
tstatus.maxquota = aquota;
int releasecount = 0;
struct volser_status volstatus;
- bzero((char *)remembertime, sizeof(remembertime));
- bzero((char *)&results, sizeof(results));
+ memset((char *)remembertime, 0, sizeof(remembertime));
+ memset((char *)&results, 0, sizeof(results));
vcode = ubik_Call(VL_SetLock, cstruct, 0, afromvol, RWVOL, VLOP_RELEASE);
if (vcode != VL_RERELEASE)
strcpy(vname, entry.name);
strcat(vname, ".readonly");
- bzero(&cookie,sizeof(cookie));
+ memset(&cookie, 0, sizeof(cookie));
strncpy(cookie.name, vname, VOLSER_OLDMAXVOLNAME);
cookie.type = ROVOL;
cookie.parent = entry.volumeId[RWVOL];
if ( !replicas || !times || !! !results.manyResults_val || !toconns )
ONERROR(ENOMEM, 0, "Failed to create transaction on the release clone\n");
- bzero (replicas, (sizeof(struct replica)*nservers+1));
- bzero (times, (sizeof(struct release)*nservers+1));
- bzero (toconns, (sizeof(struct rx_connection *)*nservers+1));
- bzero (results.manyResults_val, (sizeof(afs_int32)*nservers+1));
+ memset(replicas, 0, (sizeof(struct replica)*nservers+1));
+ memset(times, 0, (sizeof(struct release)*nservers+1));
+ memset(toconns, 0, (sizeof(struct rx_connection *)*nservers+1));
+ memset(results.manyResults_val, 0, (sizeof(afs_int32)*nservers+1));
/* Create a transaction on the cloned volume */
code = AFSVolTransCreate(fromconn, cloneVolId, afrompart, ITBusy, &fromtid);
char apartName[10];
- bzero(&cookie,sizeof(cookie));
+ memset(&cookie, 0, sizeof(cookie));
islocked = 0;
success = 0;
error = 0;
ERROR_EXIT(code);
}
- bzero(&entry, sizeof(entry));
+ memset(&entry, 0, sizeof(entry));
vsu_ExtractName(entry.name, volumeinfo->name); /* Store name of RW */
createentry = 1;
/* While we need to collect more VLDB entries */
for (si=0; si != -1; si=nsi) {
- bzero(&arrayEntries, sizeof(arrayEntries));
+ memset(&arrayEntries, 0, sizeof(arrayEntries));
/* Collect set of VLDB entries */
code = VLDB_ListAttributesN2(&attributes, 0, si,
{
register int i;
- bzero(nentryp, sizeof(struct nvldbentry));
+ memset(nentryp, 0, sizeof(struct nvldbentry));
strncpy(nentryp->name, oentryp->name, sizeof(nentryp->name));
for (i=0; i < oentryp->nServers; i++) {
nentryp->serverNumber[i] = oentryp->serverNumber[i];
{
register int i;
- bzero(oentryp, sizeof(struct vldbentry));
+ memset(oentryp, 0, sizeof(struct vldbentry));
strncpy(oentryp->name, nentryp->name, sizeof(oentryp->name));
if (nentryp->nServers > OMAXNSERVERS) {
/*
if (newvlserver == 1) {
tryold:
- bzero(&arrayEntries, sizeof(arrayEntries)); /*initialize to hint the stub to alloc space */
+ memset(&arrayEntries, 0, sizeof(arrayEntries)); /*initialize to hint the stub to alloc space */
code = ubik_Call(VL_ListAttributes, cstruct, 0, attrp, entriesp, &arrayEntries);
if (!code) {
blkentriesp->nbulkentries_val = (nvldbentry *)malloc(*entriesp * sizeof(struct nvldbentry));
return 0;
}
- bzero(&attrs, sizeof(attrs));
+ memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_IPADDR;
attrs.ipaddr = serv1;
- bzero(&addrs, sizeof(addrs));
- bzero(&uuid, sizeof(uuid));
+ memset(&addrs, 0, sizeof(addrs));
+ memset(&uuid, 0, sizeof(uuid));
code = ubik_Call(VL_GetAddrsU, cstruct, 0, &attrs, &uuid, &unique, &nentries, &addrs);
if (vlserverv4 == -1) {
if (code == RXGEN_OPCODE) {
xstat_cm_Results.collectionNumber = *currCollIDP;
xstat_cm_Results.data.AFSCB_CollData_len =
AFSCB_MAX_XSTAT_LONGS;
- bzero(xstat_cm_Results.data.AFSCB_CollData_val,
- AFSCB_MAX_XSTAT_LONGS * 4);
+ memset(xstat_cm_Results.data.AFSCB_CollData_val, 0, AFSCB_MAX_XSTAT_LONGS * 4);
xstat_cm_Results.connP = curr_conn;
xstat_cm_numCollections = a_numCollections;
collIDBytes = xstat_cm_numCollections * sizeof(afs_int32);
xstat_cm_collIDP = (afs_int32 *)(malloc(collIDBytes));
- bcopy(a_collIDP, xstat_cm_collIDP, collIDBytes);
+ memcpy(xstat_cm_collIDP, a_collIDP, collIDBytes);
if (xstat_cm_debug) {
printf("[%s] Asking for %d collection(s): ", rn, xstat_cm_numCollections);
for (curr_srv = 0; curr_srv < xstat_cm_numCollections; curr_srv++)
(a_socketArray + curr_srv)->sin_addr.s_addr,
(a_socketArray + curr_srv)->sin_port);
}
- bcopy(a_socketArray + curr_srv,
- &(curr_conn->skt),
- sizeof(struct sockaddr_in));
+ memcpy(&(curr_conn->skt), a_socketArray + curr_srv, sizeof(struct sockaddr_in));
hostNameFound =
hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
rn, curr_item->data);
exit(-1);
}
- bcopy(he->h_addr, &(CMSktArray[currCM].sin_addr.s_addr), 4);
+ memcpy(&(CMSktArray[currCM].sin_addr.s_addr), he->h_addr, 4);
/*
* Move to the next CM name.
rn, *currCollIDP);
xstat_fs_Results.collectionNumber = *currCollIDP;
xstat_fs_Results.data.AFS_CollData_len = AFS_MAX_XSTAT_LONGS;
- bzero(xstat_fs_Results.data.AFS_CollData_val,
- AFS_MAX_XSTAT_LONGS * 4);
+ memset(xstat_fs_Results.data.AFS_CollData_val, 0, AFS_MAX_XSTAT_LONGS * 4);
xstat_fs_Results.connP = curr_conn;
xstat_fs_numCollections = a_numCollections;
collIDBytes = xstat_fs_numCollections * sizeof(afs_int32);
xstat_fs_collIDP = (afs_int32 *)(malloc(collIDBytes));
- bcopy(a_collIDP, xstat_fs_collIDP, collIDBytes);
+ memcpy(xstat_fs_collIDP, a_collIDP, collIDBytes);
if (xstat_fs_debug) {
printf("[%s] Asking for %d collection(s): ", rn, xstat_fs_numCollections);
for (curr_srv = 0; curr_srv < xstat_fs_numCollections; curr_srv++)
(a_socketArray + curr_srv)->sin_addr.s_addr,
(a_socketArray + curr_srv)->sin_port);
}
- bcopy(a_socketArray + curr_srv,
- &(curr_conn->skt),
- sizeof(struct sockaddr_in));
+ memcpy(&(curr_conn->skt), a_socketArray + curr_srv, sizeof(struct sockaddr_in));
hostNameFound =
hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr);
rn, curr_item->data);
exit(-1);
}
- bcopy(he->h_addr, &(FSSktArray[currFS].sin_addr.s_addr), 4);
+ memcpy(&(FSSktArray[currFS].sin_addr.s_addr), he->h_addr, 4);
/*
* Move to the next File Server name.
projects / packages / o / openafs.git / commitdiff