int code;
vfs_context_t ctx;
char volfspath[64];
+ size_t len = sizeof(volfspath);
*vpp = 0;
*perror = 0;
- sprintf(volfspath, "/.vol/%d/%d", dev, inode);
+ if (snprintf(volfspath, len, "/.vol/%d/%d", dev, inode) >= len) {
+ *perror = BAD_IGET;
+ return ENAMETOOLONG;
+ }
code = vnode_open(volfspath, O_RDWR, 0, 0, &vp, afs_osi_ctxtp);
if (code) {
*perror = BAD_IGET;
memset(mnt_stat->f_mntfromname, 0, MNAMELEN);
if (data == 0) {
- strcpy(mnt_stat->f_mntfromname, "AFS");
+ if (strlcpy(mnt_stat->f_mntfromname, "AFS", MNAMELEN) >= MNAMELEN) {
+ AFS_GUNLOCK();
+ return ENAMETOOLONG;
+ }
/* null terminated string "AFS" will fit, just leave it be. */
vfs_setfsprivate(mp, NULL);
} else {
memset(volName + size, 0, MNAMELEN - size);
if (volName[0] == 0) {
- strcpy(mnt_stat->f_mntfromname, "AFS");
+ if (strlcpy(mnt_stat->f_mntfromname, "AFS", MNAMELEN) >= MNAMELEN) {
+ AFS_GUNLOCK();
+ return ENAMETOOLONG;
+ }
vfs_setfsprivate(mp, &afs_rootFid);
} else {
struct cell *localcell = afs_GetPrimaryCell(READ_LOCK);
#include "afs/afs_stats.h"
#include "afs/afs_prototypes.h"
#include "afs/discon.h"
+#include "roken.h"
static int
afs_getsysname(struct vrequest *areq, struct vcache *adp,
- char *bufp, int *num, char **sysnamelist[])
+ char *bufp, size_t bufsize, int *num, char **sysnamelist[])
{
- struct unixuser *au;
- afs_int32 error;
+ struct unixuser *au = NULL;
+ afs_int32 error, code = -1;
+ size_t rlen;
AFS_STATCNT(getsysname);
*sysnamelist = afs_sysnamelist;
- if (!afs_nfsexporter)
- strcpy(bufp, (*sysnamelist)[0]);
- else {
+ if (!afs_nfsexporter) {
+ rlen = strlcpy(bufp, (*sysnamelist)[0], bufsize);
+ if (rlen >= bufsize)
+ goto done;
+ } else {
au = afs_GetUser(areq->uid, adp->f.fid.Cell, READ_LOCK);
if (au->exporter) {
error = EXP_SYSNAME(au->exporter, (char *)0, sysnamelist, num, 0);
if (error) {
- strcpy(bufp, "@sys");
- afs_PutUser(au, READ_LOCK);
- return -1;
+ strlcpy(bufp, "@sys", bufsize);
+ goto done;
} else {
- strcpy(bufp, (*sysnamelist)[0]);
+ rlen = strlcpy(bufp, (*sysnamelist)[0], bufsize);
+ if (rlen >= bufsize)
+ goto done;
}
- } else
- strcpy(bufp, afs_sysname);
- afs_PutUser(au, READ_LOCK);
+ } else {
+ rlen = strlcpy(bufp, afs_sysname, bufsize);
+ if (rlen >= bufsize)
+ goto done;
+ }
}
- return 0;
+ code = 0;
+ done:
+ if (au != NULL)
+ afs_PutUser(au, READ_LOCK);
+ return code;
}
void
state->name_size = MAXSYSNAME;
state->name = osi_AllocLargeSpace(state->name_size);
state->index =
- afs_getsysname(areq, avc, state->name, &num, sysnamelist);
+ afs_getsysname(areq, avc, state->name, state->name_size, &num,
+ sysnamelist);
} else {
state->offset = -1;
state->name_size = 0;
struct sysname_info *state)
{
int num = afs_sysnamecount;
- char **sysnamelist[MAXNUMSYSNAMES];
+ char **sysnamelist[MAXNUMSYSNAMES], *buf;
+ size_t bsz;
if (state->index == -1)
return 0; /* No list */
/*Move to the end of the string */ ;
if ((tname > state->name + 4) && (AFS_EQ_ATSYS(tname - 4))) {
- state->offset = (tname - 4) - state->name;
- tname = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
- strncpy(tname, state->name, state->offset);
- state->name = tname;
- state->name_size = AFS_LRALLOCSIZ;
+ int idx;
+ size_t len, bufsize = AFS_LRALLOCSIZ;
+
+ len = (tname - 4) - state->name;
+ if (len >= bufsize) {
+ return 0;
+ }
+
+ tname = osi_AllocLargeSpace(bufsize);
+ /* intentionally truncating state->name */
+ strlcpy(tname, state->name, len + 1);
+
+ buf = tname + len;
+ bsz = bufsize - len;
num = 0;
- state->index =
- afs_getsysname(areq, avc, state->name + state->offset, &num,
- sysnamelist);
+ idx = afs_getsysname(areq, avc, buf, bsz, &num, sysnamelist);
+ if (idx == -1) {
+ osi_FreeLargeSpace(tname);
+ return 0;
+ }
+ /*
+ * If we got here, state->name isn't pointing to any dynamically
+ * allocated memory. In other words, state->name_size must be 0.
+ */
+ state->name = tname;
+ state->offset = len;
+ state->name_size = bufsize;
+ state->index = idx;
+
return 1;
} else
return 0; /* .*@sys doesn't match either */
if (++(state->index) >= num || !(*sysnamelist)[(unsigned int)state->index])
return 0; /* end of list */
}
- strcpy(state->name + state->offset, (*sysnamelist)[(unsigned int)state->index]);
+ /*
+ * If we got here, state->name was allocated by the AtSys iterator. In other
+ * words, state->name_size must be greater than 0.
+ */
+ buf = state->name + state->offset;
+ bsz = state->name_size - state->offset;
+ if (strlcpy(buf, (*sysnamelist)[(unsigned int)state->index], bsz) >= bsz) {
+ state->index = -1;
+ return 0;
+ }
return 1;
}
if (!tvc->linkData) {
tvc->linkData = afs_osi_Alloc(alen);
osi_Assert(tvc->linkData != NULL);
- strncpy(tvc->linkData, atargetName, alen - 1);
+ memcpy(tvc->linkData, atargetName, alen - 1);
tvc->linkData[alen - 1] = 0;
}
ReleaseWriteLock(&tvc->lock);
code = 1;
} else if (a_index >= nentries) {
struct cell *tc = afs_GetCellByIndex(a_index-nentries, 0);
- strcpy(a_result->name, tc->cellName);
+ strlcpy(a_result->name, tc->cellName, sizeof(a_result->name));
a_result->lock.waitStates =
((struct afs_lock *)&(tc->lock))->wait_states;
a_result->lock.exclLocked =
* Found it - copy out its contents.
*/
tl = <able[a_index];
- strcpy(a_result->name, tl->name);
+ strlcpy(a_result->name, tl->name, sizeof(a_result->name));
a_result->lock.waitStates =
((struct afs_lock *)(tl->addr))->wait_states;
a_result->lock.exclLocked =
}
/* Return the lookup request to userspace */
- strncpy(acellName, afsdb_req.cellname, acellNameLen);
+ strlcpy(acellName, afsdb_req.cellname, acellNameLen);
ReleaseReadLock(&afsdb_req_lock);
return 0;
}
struct volume *tvp = NULL;
int usingDynroot = afs_GetDynrootEnable();
int localcell;
+ size_t bufsize, len;
AFS_STATCNT(afs_CheckRootVolume);
+ bufsize = sizeof(rootVolName);
if (*afs_rootVolumeName == 0) {
- strcpy(rootVolName, "root.afs");
+ len = strlcpy(rootVolName, "root.afs", bufsize);
} else {
- strcpy(rootVolName, afs_rootVolumeName);
+ len = strlcpy(rootVolName, afs_rootVolumeName, bufsize);
+ }
+ if (len >= bufsize) {
+ return ENAMETOOLONG;
}
if (usingDynroot) {
tvp = afs_GetVolumeByName(rootVolName, localcell, 1, NULL, READ_LOCK);
if (!tvp) {
char buf[128];
- int len = strlen(rootVolName);
if ((len < 9) || strcmp(&rootVolName[len - 9], ".readonly")) {
- strcpy(buf, rootVolName);
- afs_strcat(buf, ".readonly");
+ bufsize = sizeof(buf);
+ len = snprintf(buf, bufsize, "%s.readonly", rootVolName);
+ if (len >= bufsize) {
+ return ENAMETOOLONG;
+ }
tvp = afs_GetVolumeByName(buf, localcell, 1, NULL, READ_LOCK);
}
}
dotLen = strlen(c->cellName) + 2;
dotCell = afs_osi_Alloc(dotLen);
osi_Assert(dotCell != NULL);
- strcpy(dotCell, ".");
- afs_strcat(dotCell, c->cellName);
+ osi_Assert(snprintf(dotCell, dotLen, ".%s", c->cellName) < dotLen);
afs_dynroot_computeDirEnt(c->cellName, &curPage, &curChunk);
afs_dynroot_computeDirEnt(dotCell, &curPage, &curChunk);
dotLen = strlen(ca->alias) + 2;
dotCell = afs_osi_Alloc(dotLen);
osi_Assert(dotCell != NULL);
- strcpy(dotCell, ".");
- afs_strcat(dotCell, ca->alias);
+ osi_Assert(snprintf(dotCell, dotLen, ".%s", ca->alias) < dotLen);
afs_dynroot_computeDirEnt(ca->alias, &curPage, &curChunk);
afs_dynroot_computeDirEnt(dotCell, &curPage, &curChunk);
dotLen = strlen(c->cellName) + 2;
dotCell = afs_osi_Alloc(dotLen);
osi_Assert(dotCell != NULL);
- strcpy(dotCell, ".");
- afs_strcat(dotCell, c->cellName);
+ osi_Assert(snprintf(dotCell, dotLen, ".%s", c->cellName) < dotLen);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, c->cellName,
VNUM_FROM_CIDX_RW(cellidx, 0));
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, dotCell,
dotLen = strlen(ca->alias) + 2;
dotCell = afs_osi_Alloc(dotLen);
osi_Assert(dotCell != NULL);
- strcpy(dotCell, ".");
- afs_strcat(dotCell, ca->alias);
+ osi_Assert(snprintf(dotCell, dotLen, ".%s", ca->alias) < dotLen);
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, ca->alias,
VNUM_FROM_CAIDX_RW(aliasidx, 0));
afs_dynroot_addDirEnt(dirHeader, &curPage, &curChunk, dotCell,
linklen = strlen(ts->target);
avc->linkData = afs_osi_Alloc(linklen + 1);
osi_Assert(avc->linkData != NULL);
- strcpy(avc->linkData, ts->target);
+ osi_Assert(strlcpy(avc->linkData, ts->target, linklen + 1) <
+ linklen + 1);
status->Length = linklen;
status->UnixModeBits = 0755;
linklen = 7;
} else {
int namelen = strlen(realName);
+ char *prefix = rw ? "." : "";
linklen = rw + namelen;
avc->linkData = afs_osi_Alloc(linklen + 1);
osi_Assert(avc->linkData != NULL);
- strcpy(avc->linkData, rw ? "." : "");
- afs_strcat(avc->linkData, realName);
+ osi_Assert(snprintf(avc->linkData, linklen + 1, "%s%s", prefix,
+ realName) < linklen + 1);
}
status->UnixModeBits = 0755;
linklen = 2 + namelen + strlen(bp);
avc->linkData = afs_osi_Alloc(linklen + 1);
osi_Assert(avc->linkData != NULL);
- strcpy(avc->linkData, "%");
- afs_strcat(avc->linkData, c->cellName);
- afs_strcat(avc->linkData, ":");
- afs_strcat(avc->linkData, bp);
+ osi_Assert(snprintf(avc->linkData, linklen + 1, "%%%s:%s",
+ c->cellName, bp) < linklen + 1);
status->UnixModeBits = 0644;
status->ParentVnode = AFS_DYNROOT_MOUNT_VNODE;
afs_PutCell(c, READ_LOCK);
} else {
+ char *prefix = rw ? "%" : "#";
+
c = afs_GetCellByIndex(cellidx, READ_LOCK);
if (!c) {
afs_warn("dynroot vnode inconsistency, can't find cell %d\n",
linklen = 1 + namelen + 10;
avc->linkData = afs_osi_Alloc(linklen + 1);
osi_Assert(avc->linkData != NULL);
- strcpy(avc->linkData, rw ? "%" : "#");
- afs_strcat(avc->linkData, c->cellName);
- afs_strcat(avc->linkData, ":root.cell");
+ osi_Assert(snprintf(avc->linkData, linklen + 1, "%s%s:root.cell",
+ prefix, c->cellName) < linklen + 1);
status->UnixModeBits = 0644;
afs_PutCell(c, READ_LOCK);
char *aname, char *atargetName)
{
struct afs_dynSymlink *tps;
+ size_t len;
if (afs_cr_uid(acred))
return EPERM;
osi_Assert(tps != NULL);
tps->index = afs_dynSymlinkIndex++;
tps->next = afs_dynSymlinkBase;
- tps->name = afs_osi_Alloc(strlen(aname) + 1);
+ len = strlen(aname) + 1;
+ tps->name = afs_osi_Alloc(len);
osi_Assert(tps->name != NULL);
- strcpy(tps->name, aname);
- tps->target = afs_osi_Alloc(strlen(atargetName) + 1);
+ osi_Assert(strlcpy(tps->name, aname, len) < len);
+ len = strlen(atargetName) + 1;
+ tps->target = afs_osi_Alloc(len);
osi_Assert(tps->target != NULL);
- strcpy(tps->target, atargetName);
+ osi_Assert(strlcpy(tps->target, atargetName, len) < len);
afs_dynSymlinkBase = tps;
ReleaseWriteLock(&afs_dynSymlinkLock);
struct afs_icl_log **outLogpp)
{
struct afs_icl_log *logp;
+ size_t namelen;
/* add into global list under lock */
ObtainWriteLock(&afs_icl_lock, 183);
memset((caddr_t) logp, 0, sizeof(*logp));
logp->refCount = 1;
- logp->name = osi_AllocSmallSpace(strlen(name) + 1);
- strcpy(logp->name, name);
+ namelen = strlen(name) + 1;
+ logp->name = osi_AllocSmallSpace(namelen);
+ osi_Assert(strlcpy(logp->name, name, namelen) < namelen);
LOCK_INIT(&logp->lock, "logp lock");
logp->logSize = logSize;
logp->datap = NULL; /* don't allocate it until we need it */
struct afs_icl_set *setp;
int i;
afs_int32 states = ICL_DEFAULT_SET_STATES;
+ size_t namelen;
ObtainWriteLock(&afs_icl_lock, 197);
if (!afs_icl_inited)
* the afs_icl_lock is still held, and thus the obtain can't block.
*/
ObtainWriteLock(&setp->lock, 199);
- setp->name = osi_AllocSmallSpace(strlen(name) + 1);
- strcpy(setp->name, name);
+ namelen = strlen(name) + 1;
+ setp->name = osi_AllocSmallSpace(namelen);
+ osi_Assert(strlcpy(setp->name, name, namelen) < namelen);
setp->nevents = ICL_DEFAULTEVENTS;
setp->eventFlags = afs_osi_Alloc(ICL_DEFAULTEVENTS);
osi_Assert(setp->eventFlags != NULL);
osi_Assert(afs_sysnamelist[i] != NULL);
}
afs_sysname = afs_sysnamelist[0];
- strcpy(afs_sysname, SYS_NAME);
+ osi_Assert(strlcpy(afs_sysname, SYS_NAME, MAXSYSNAME) < MAXSYSNAME);
afs_sysnamecount = 1;
afs_sysnamegen++;
}
marinerPtr = 1;
}
tp = marinerNames[i];
- strncpy(tp, aname, SMAR);
- tp[SMAR - 1] = 0;
+ strlcpy(tp, aname, SMAR);
marinerVCs[i] = avc;
return 0;
}
afs_MarinerLog(char *astring, struct vcache *avc)
{
struct sockaddr_in taddr;
- char *tp, *tp1, *buf;
+ char *buf;
+ size_t bufsize, buflen;
struct iovec dvec;
AFS_STATCNT(afs_MarinerLog);
#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
taddr.sin_len = sizeof(taddr);
#endif
- tp = buf = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
+ bufsize = AFS_SMALLOCSIZ;
+ buf = osi_AllocSmallSpace(bufsize);
+
+ if (strlcpy(buf, astring, bufsize) >= bufsize)
+ goto done;
- strcpy(tp, astring);
- tp += strlen(astring);
if (avc) {
- *tp++ = ' ';
- tp1 = afs_GetMariner(avc);
- strcpy(tp, tp1);
- tp += strlen(tp1);
+ char *tp1 = afs_GetMariner(avc);
+
+ if (strlcat(buf, " ", bufsize) >= bufsize)
+ goto done;
+ if (strlcat(buf, tp1, bufsize) >= bufsize)
+ goto done;
}
- *tp++ = '\n';
+ if (strlcat(buf, "\n", bufsize) >= bufsize)
+ goto done;
+
/* note, console doesn't want a terminating null */
/* I don't care if mariner packets fail to be sent */
+ buflen = strlen(buf);
dvec.iov_base = buf;
- dvec.iov_len = tp - buf;
+ dvec.iov_len = buflen;
AFS_GUNLOCK();
- (void)rxi_NetSend(afs_server->socket, &taddr, &dvec, 1, tp - buf, 0);
+ (void)rxi_NetSend(afs_server->socket, &taddr, &dvec, 1, buflen, 0);
AFS_GLOCK();
+ done:
osi_FreeSmallSpace(buf);
} /*afs_MarinerLog */
osi_Assert(afs_sysnamelist[i] != NULL);
}
afs_sysname = afs_sysnamelist[0];
- strcpy(afs_sysname, SYS_NAME);
+ osi_Assert(strlcpy(afs_sysname, SYS_NAME, MAXSYSNAME) < MAXSYSNAME);
afs_sysnamecount = 1;
afs_sysnamegen++;
tcell = afs_osi_Alloc(sizeof(struct afspag_cell));
if (!tcell)
goto out;
- tcell->cellname = afs_osi_Alloc(strlen(acell) + 1);
+ tcell->cellname = afs_strdup(acell);
if (!tcell->cellname) {
afs_osi_Free(tcell, sizeof(struct afspag_cell));
tcell = 0;
goto out;
}
- strcpy(tcell->cellname, acell);
tcell->cellnum = ++lastcell;
tcell->next = cells;
cells = tcell;
goto out;
for (i = 0; i < afs_sysnamecount; i++) {
- a_sysnames->SysNameList_val[i].sysname =
- afs_osi_Alloc(strlen(afs_sysnamelist[i]) + 1);
+ a_sysnames->SysNameList_val[i].sysname = afs_strdup(afs_sysnamelist[i]);
if (!a_sysnames->SysNameList_val[i].sysname)
goto out;
- strcpy(a_sysnames->SysNameList_val[i].sysname, afs_sysnamelist[i]);
}
ReleaseReadLock(&afs_xpagsys);
int t, count, num = 0, allpags = 0;
char **sysnamelist;
struct afs_pdata validate;
+ size_t len;
AFS_STATCNT(PSetSysName);
if (!afs_globalVFS) {
}
} else {
foundname = num;
- strcpy(outname, sysnamelist[0]);
+ len = sizeof(outname);
+ if (strlcpy(outname, sysnamelist[0], len) >= len) {
+ afs_PutUser(au, READ_LOCK);
+ return E2BIG;
+ }
}
afs_PutUser(au, READ_LOCK);
if (setsysname)
if (!afs_sysname)
osi_Panic("PSetSysName: !afs_sysname\n");
if (!setsysname) { /* user just wants the info */
- strcpy(outname, afs_sysname);
+ len = sizeof(outname);
+ if (strlcpy(outname, afs_sysname, len) >= len)
+ return E2BIG;
foundname = afs_sysnamecount;
sysnamelist = afs_sysnamelist;
} else { /* Local guy; only root can change sysname */
if (strlen(inname) >= MAXSYSNAME-1)
return EINVAL;
- strcpy(afs_sysname, inname);
+ if (strlcpy(afs_sysname, inname, MAXSYSNAME) >= MAXSYSNAME)
+ return E2BIG;
if (setsysname > 1) { /* ... or list */
for (count = 1; count < setsysname; ++count) {
if (vType(tvc) == VLNK) {
ObtainWriteLock(&tvc->lock, 555);
if (afs_HandleLink(tvc, areq) == 0)
- strncpy((char *)&Outputs->chars, tvc->linkData, MAXCMDCHARS);
+ strlcpy((char *)&Outputs->chars, tvc->linkData, MAXCMDCHARS);
ReleaseWriteLock(&tvc->lock);
}
}
LockAndInstallVolumeEntry(tv, ove, tcell->cellNum);
if (agood) {
if (!tv->name) {
- tv->name = afs_osi_Alloc(strlen(aname) + 1);
+ tv->name = afs_strdup(aname);
osi_Assert(tv->name != NULL);
- strcpy(tv->name, aname);
}
}
for (i = 0; i < NMAXNSERVERS; i++) {
struct volume *tv;
struct vldbentry *tve;
char *bp, tbuf[CVBS];
+ size_t len;
tcell = afs_GetCell(fid->Cell, READ_LOCK);
if (!tcell)
bp = afs_cv2string(&tbuf[CVBS], fid->Fid.Volume);
memset(tve, 0, sizeof(*tve));
- strcpy(tve->name, "local-dynroot");
+ len = sizeof(tve->name);
+ osi_Assert(strlcpy(tve->name, "local-dynroot", len) < len);
tve->volumeId[ROVOL] = fid->Fid.Volume;
tve->flags = VLF_ROEXISTS;
rand.c
rand-timer.c
evp-hcrypto.h
-strcasecmp.c
heim_threads.h
+++ /dev/null
-/*
- * Copyright 2000, International Business Machines Corporation and others.
- * All Rights Reserved.
- *
- * This software has been released under the terms of the IBM Public
- * License. For details, see the LICENSE file in the top-level source
- * directory or online at http://www.openafs.org/dl/license10.html
- */
-
-const char hckernel_strcasecmp_placeholder[] =
- "This is not an empty compilation unit.";
-
-#ifndef afs_strcasecmp
-int
-afs_strcasecmp(const char *s1, const char *s2)
-{
- while (*s1 && *s2) {
- char c1, c2;
-
- c1 = *s1++;
- c2 = *s2++;
- if (c1 >= 'A' && c1 <= 'Z')
- c1 += 0x20;
- if (c2 >= 'A' && c2 <= 'Z')
- c2 += 0x20;
- if (c1 != c2)
- return c1 - c2;
- }
-
- return *s1 - *s2;
-}
-#endif
#include <afsconfig.h>
#include <afs/param.h>
+#include <afs/afsint.h>
#ifdef KERNEL
# if !defined(UKERNEL)
# else /* !defined(UKERNEL) */
# include "afs/stds.h"
# include "afs/sysincludes.h"
+# include "afsincludes.h"
# endif /* !defined(UKERNEL) */
/* afs_buffer.c */
struct DirEntry *ep;
struct DirHeader *dhp;
int code;
+ size_t rlen;
/* check name quality */
if (*entry == 0)
ep->flag = FFIRST;
ep->fid.vnode = htonl(vfid[1]);
ep->fid.vunique = htonl(vfid[2]);
- strcpy(ep->name, entry);
+
+ /*
+ * Note, the size of ep->name does not represent the maximum size of the
+ * name. FindBlobs has already ensured that the name can fit.
+ */
+ rlen = strlcpy(ep->name, entry, AFSNAMEMAX + 1);
+ if (rlen >= AFSNAMEMAX + 1) {
+ DRelease(&entrybuf, 1);
+ return ENAMETOOLONG;
+ }
/* Now we just have to thread it on the hash table list. */
if (DRead(dir, 0, &headerbuf) != 0) {
struct DirBuffer entrybuf;
struct DirEntry *entry;
int code = 0;
+ size_t rlen;
code = FindFid(dir, vnode, unique, &entrybuf);
if (code) {
}
entry = (struct DirEntry *)entrybuf.data;
- if (strlen(entry->name) >= length)
+ rlen = strlcpy(name, entry->name, length);
+ if (rlen >= length) {
code = E2BIG;
- else
- strcpy(name, entry->name);
+ }
DRelease(&entrybuf, 0);
return code;
}
$(RM) -f *.o *.a test dtest core
dtest: dtest.o
- $(AFS_LDRULE) dtest.o $(LIBS)
+ $(AFS_LDRULE) dtest.o $(LIBS) $(LIB_roken) $(XLIBS)
rx_pag_packet.o \
rx_multi.o \
rx_stats.o \
- strcasecmp_pag.o \
+ afs_util.o \
opr_rbtree.o \
xdr_rx.o \
xdr_mem.o \
$(CRULE_NOOPT) $(TOP_SRC_RX)/rx_packet.c
rx_pag_knet.o: $(TOP_SRC_RX)/${MKAFS_OSTYPE}/rx_knet.c
$(CRULE_NOOPT) $(TOP_SRC_RX)/${MKAFS_OSTYPE}/rx_knet.c
-strcasecmp_pag.o: $(TOP_SRCDIR)/crypto/hcrypto/kernel/strcasecmp.c
- $(CRULE_NOOPT) $(TOP_SRCDIR)/crypto/hcrypto/kernel/strcasecmp.c
# Crypto
md5.o: $(TOP_SRCDIR)/external/heimdal/hcrypto/md5.c
# define ADDBUF(BUF, STR) \
if (strlen(BUF) + strlen((char *)(STR)) + 1 <= sizeof BUF) { \
- strcat(BUF, (char *)(STR)); \
+ strlcat(BUF, (char *)(STR), sizeof(BUF)); \
}
buf[0] = '\0';
ap->header.flags = ap->header.flags & ~RX_CLIENT_INITIATED;
rxi_EncodePacketHeader(ap);
memset(buf, 0, sizeof(buf));
- strncpy(buf, cml_version_number + 4, sizeof(buf) - 1);
+ strlcpy(buf, cml_version_number + 4, sizeof(buf));
rx_packetwrite(ap, 0, 65, buf);
tl = ap->length;
ap->length = 65;
git://git.openafs.org / openafs.git / commitdiff