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);
git://git.openafs.org / openafs.git / commitdiff