/* Set the cred info into the current task */
void
crset(cred_t * cr)
{
#if defined(STRUCT_TASK_STRUCT_HAS_CRED)
struct cred *new_creds;
/* If our current task doesn't have identical real and effective
* credentials, commit_cred won't let us change them, so we just
* bail here.
*/
if (current->cred != current->real_cred)
return;
new_creds = prepare_creds();
/* Drop the reference to group_info - we'll overwrite it in afs_copy_creds */
put_group_info(new_creds->group_info);
afs_copy_creds(new_creds, current_cred());
commit_creds(new_creds);
#else
struct group_info *old_info;
current->fsuid = afs_cr_uid(cr);
current->uid = afs_cr_ruid(cr);
current->fsgid = afs_cr_gid(cr);
current->gid = afs_cr_rgid(cr);
get_group_info(afs_cr_group_info(cr));
task_lock(current);
old_info = current->group_info;
current->group_info = afs_cr_group_info(cr);
task_unlock(current);
put_group_info(old_info);
#endif
}
int afspag_PUnlog(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
{
register afs_int32 i;
register struct unixuser *tu;
afs_int32 pag, uid;
AFS_STATCNT(PUnlog);
if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
return EIO; /* Inappropriate ioctl for device */
pag = PagInCred(*acred);
uid = (pag == NOPAG) ? afs_cr_uid(*acred) : pag;
i = UHash(uid);
ObtainWriteLock(&afs_xuser, 823);
for (tu = afs_users[i]; tu; tu = tu->next) {
if (tu->uid == uid) {
tu->vid = UNDEFVID;
tu->states &= ~UHasTokens;
/* security is not having to say you're sorry */
memset(&tu->ct, 0, sizeof(struct ClearToken));
#ifdef UKERNEL
/* set the expire times to 0, causes
* afs_GCUserData to remove this entry
*/
tu->ct.EndTimestamp = 0;
tu->tokenTime = 0;
#endif /* UKERNEL */
}
}
ReleaseWriteLock(&afs_xuser);
return 0;
}
/* Copy one credential structure to another, being careful about references */
static inline void
afs_copy_creds(cred_t *to_cred, const cred_t *from_cred) {
afs_set_cr_uid(to_cred, afs_cr_uid(from_cred));
afs_set_cr_gid(to_cred, afs_cr_gid(from_cred));
afs_set_cr_ruid(to_cred, afs_cr_ruid(from_cred));
afs_set_cr_rgid(to_cred, afs_cr_rgid(from_cred));
get_group_info(afs_cr_group_info(from_cred));
afs_set_cr_group_info(to_cred, afs_cr_group_info(from_cred));
}
/* Return a duplicate of the cred. */
cred_t *
crdup(cred_t * cr)
{
cred_t *tmp = crget();
#if defined(STRUCT_TASK_STRUCT_HAS_CRED)
afs_copy_creds(tmp, cr);
#else
afs_set_cr_uid(tmp, afs_cr_uid(cr));
afs_set_cr_ruid(tmp, afs_cr_ruid(cr));
afs_set_cr_gid(tmp, afs_cr_gid(cr));
afs_set_cr_rgid(tmp, afs_cr_rgid(cr));
get_group_info(afs_cr_group_info(cr));
afs_set_cr_group_info(tmp, afs_cr_group_info(cr));
#endif
return tmp;
}
/*
* Remove a temporary symlink entry from /afs.
*/
int
afs_DynrootVOPRemove(struct vcache *avc, afs_ucred_t *acred, char *aname)
{
struct afs_dynSymlink **tpps;
struct afs_dynSymlink *tps;
int found = 0;
#if defined(AFS_SUN510_ENV)
if (crgetruid(acred))
#else
if (afs_cr_uid(acred))
#endif
return EPERM;
ObtainWriteLock(&afs_dynSymlinkLock, 97);
tpps = &afs_dynSymlinkBase;
while (*tpps) {
tps = *tpps;
if (afs_strcasecmp(aname, tps->name) == 0) {
afs_osi_Free(tps->name, strlen(tps->name) + 1);
afs_osi_Free(tps->target, strlen(tps->target) + 1);
*tpps = tps->next;
afs_osi_Free(tps, sizeof(*tps));
afs_dynSymlinkIndex++;
found = 1;
break;
}
tpps = &(tps->next);
}
ReleaseWriteLock(&afs_dynSymlinkLock);
if (found) {
afs_DynrootInvalidate();
return 0;
}
if (afs_CellOrAliasExists(aname))
return EROFS;
else
return ENOENT;
}
/*
* Create a temporary symlink entry in /afs.
*/
int
afs_DynrootVOPSymlink(struct vcache *avc, afs_ucred_t *acred,
char *aname, char *atargetName)
{
struct afs_dynSymlink *tps;
if (afs_cr_uid(acred))
return EPERM;
if (afs_CellOrAliasExists(aname))
return EEXIST;
/* Check if it's already a symlink */
ObtainWriteLock(&afs_dynSymlinkLock, 91);
tps = afs_dynSymlinkBase;
while (tps) {
if (afs_strcasecmp(aname, tps->name) == 0) {
ReleaseWriteLock(&afs_dynSymlinkLock);
return EEXIST;
}
tps = tps->next;
}
/* Doesn't already exist -- go ahead and create it */
tps = afs_osi_Alloc(sizeof(*tps));
tps->index = afs_dynSymlinkIndex++;
tps->next = afs_dynSymlinkBase;
tps->name = afs_osi_Alloc(strlen(aname) + 1);
strcpy(tps->name, aname);
tps->target = afs_osi_Alloc(strlen(atargetName) + 1);
strcpy(tps->target, atargetName);
afs_dynSymlinkBase = tps;
ReleaseWriteLock(&afs_dynSymlinkLock);
afs_DynrootInvalidate();
return 0;
}
/* clid - nonzero on sgi sunos osf1 only */
int
HandleFlock(struct vcache *avc, int acom, struct vrequest *areq,
pid_t clid, int onlymine)
{
struct afs_conn *tc;
struct SimpleLocks *slp, *tlp, **slpp;
afs_int32 code;
struct AFSVolSync tsync;
afs_int32 lockType;
struct AFS_FLOCK flock;
XSTATS_DECLS;
AFS_STATCNT(HandleFlock);
code = 0; /* default when we don't make any network calls */
lockIdSet(&flock, NULL, clid);
#if defined(AFS_SGI_ENV)
osi_Assert(valusema(&avc->vc_rwlock) <= 0);
osi_Assert(OSI_GET_LOCKID() == avc->vc_rwlockid);
#endif
ObtainWriteLock(&avc->lock, 118);
if (acom & LOCK_UN) {
int stored_segments = 0;
retry_unlock:
/* defect 3083 */
#ifdef AFS_AIX_ENV
/* If the lock is held exclusive, then only the owning process
* or a child can unlock it. Use pid and ppid because they are
* unique identifiers.
*/
if ((avc->flockCount < 0) && (getpid() != avc->ownslock)) {
#ifdef AFS_AIX41_ENV
if (onlymine || (getppid() != avc->ownslock)) {
#else
if (onlymine || (u.u_procp->p_ppid != avc->ownslock)) {
#endif
ReleaseWriteLock(&avc->lock);
return 0;
}
}
#endif
if (lockIdcmp2(&flock, avc, NULL, onlymine, clid)) {
ReleaseWriteLock(&avc->lock);
return 0;
}
#ifdef AFS_AIX_ENV
avc->ownslock = 0;
#endif
if (avc->flockCount == 0) {
ReleaseWriteLock(&avc->lock);
return 0 /*ENOTTY*/;
/* no lock held */
}
/* unlock the lock */
if (avc->flockCount > 0) {
slpp = &avc->slocks;
for (slp = *slpp; slp;) {
if (!lockIdcmp2(&flock, avc, slp, onlymine, clid)) {
avc->flockCount--;
tlp = *slpp = slp->next;
osi_FreeSmallSpace(slp);
slp = tlp;
} else {
slpp = &slp->next;
slp = *slpp;
}
}
} else if (avc->flockCount == -1) {
if (!stored_segments) {
afs_StoreAllSegments(avc, areq, AFS_SYNC | AFS_VMSYNC); /* fsync file early */
/* afs_StoreAllSegments can drop and reacquire the write lock
* on avc and GLOCK, so the flocks may be completely different
* now. Go back and perform all checks again. */
stored_segments = 1;
goto retry_unlock;
}
avc->flockCount = 0;
/* And remove the (only) exclusive lock entry from the list... */
osi_FreeSmallSpace(avc->slocks);
avc->slocks = 0;
}
if (avc->flockCount == 0) {
if (!AFS_IS_DISCONNECTED) {
struct rx_connection *rxconn;
do {
tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_RELEASELOCK);
RX_AFS_GUNLOCK();
code = RXAFS_ReleaseLock(rxconn, (struct AFSFid *)
&avc->f.fid.Fid, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
(tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_RELEASELOCK, SHARED_LOCK, NULL));
} else {
/*printf("Network is dooooooowwwwwwwnnnnnnn\n");*/
code = ENETDOWN;
}
}
} else {
while (1) { /* set a new lock */
/*
* Upgrading from shared locks to Exclusive and vice versa
* is a bit tricky and we don't really support it yet. But
* we try to support the common used one which is upgrade
* a shared lock to an exclusive for the same process...
*/
if ((avc->flockCount > 0 && (acom & LOCK_EX))
|| (avc->flockCount == -1 && (acom & LOCK_SH))) {
/*
* Upgrading from shared locks to an exclusive one:
* For now if all the shared locks belong to the
* same process then we unlock them on the server
* and proceed with the upgrade. Unless we change the
* server's locking interface impl we prohibit from
* unlocking other processes's shared locks...
* Upgrading from an exclusive lock to a shared one:
* Again only allowed to be done by the same process.
*/
slpp = &avc->slocks;
for (slp = *slpp; slp;) {
if (!lockIdcmp2
(&flock, avc, slp, 1 /*!onlymine */ , clid)) {
if (acom & LOCK_EX)
avc->flockCount--;
else
avc->flockCount = 0;
tlp = *slpp = slp->next;
osi_FreeSmallSpace(slp);
slp = tlp;
} else {
code = EWOULDBLOCK;
slpp = &slp->next;
slp = *slpp;
}
}
if (!code && avc->flockCount == 0) {
if (!AFS_IS_DISCONNECTED) {
struct rx_connection *rxconn;
do {
tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME
(AFS_STATS_FS_RPCIDX_RELEASELOCK);
RX_AFS_GUNLOCK();
code =
RXAFS_ReleaseLock(rxconn,
(struct AFSFid *)&avc->
f.fid.Fid, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
(tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_RELEASELOCK, SHARED_LOCK,
NULL));
}
}
} else if (avc->flockCount == -1 && (acom & LOCK_EX)) {
if (lockIdcmp2(&flock, avc, NULL, 1, clid)) {
code = EWOULDBLOCK;
} else {
code = 0;
/* We've just re-grabbed an exclusive lock, so we don't
* need to contact the fileserver, and we don't need to
* add the lock to avc->slocks (since we already have a
* lock there). So, we are done. */
break;
}
}
if (code == 0) {
/* compatible here, decide if needs to go to file server. If
* we've already got the file locked (and thus read-locked, since
* we've already checked for compatibility), we shouldn't send
* the call through to the server again */
if (avc->flockCount == 0) {
struct rx_connection *rxconn;
/* we're the first on our block, send the call through */
lockType = ((acom & LOCK_EX) ? LockWrite : LockRead);
if (!AFS_IS_DISCONNECTED) {
do {
tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_SETLOCK);
RX_AFS_GUNLOCK();
code = RXAFS_SetLock(rxconn, (struct AFSFid *)
&avc->f.fid.Fid, lockType,
&tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
(tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_SETLOCK, SHARED_LOCK,
NULL));
if ((lockType == LockWrite) && (code == VREADONLY))
code = EBADF; /* per POSIX; VREADONLY == EROFS */
} else
/* XXX - Should probably try and log this when we're
* XXX - running with logging enabled. But it's horrid
*/
code = 0; /* pretend we worked - ick!!! */
} else
code = 0; /* otherwise, pretend things worked */
}
if (code == 0) {
slp = (struct SimpleLocks *)
osi_AllocSmallSpace(sizeof(struct SimpleLocks));
if (acom & LOCK_EX) {
/* defect 3083 */
#ifdef AFS_AIX_ENV
/* Record unique id of process owning exclusive lock. */
avc->ownslock = getpid();
#endif
slp->type = LockWrite;
slp->next = NULL;
avc->slocks = slp;
avc->flockCount = -1;
} else {
slp->type = LockRead;
slp->next = avc->slocks;
avc->slocks = slp;
avc->flockCount++;
}
lockIdSet(&flock, slp, clid);
break;
}
/* now, if we got EWOULDBLOCK, and we're supposed to wait, we do */
if (((code == EWOULDBLOCK) || (code == EAGAIN) ||
(code == UAEWOULDBLOCK) || (code == UAEAGAIN))
&& !(acom & LOCK_NB)) {
/* sleep for a second, allowing interrupts */
ReleaseWriteLock(&avc->lock);
#if defined(AFS_SGI_ENV)
AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
#endif
code = afs_osi_Wait(1000, NULL, 1);
#if defined(AFS_SGI_ENV)
AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
#endif
ObtainWriteLock(&avc->lock, 120);
if (code) {
code = EINTR; /* return this if ^C typed */
break;
}
} else
break;
} /* while loop */
}
ReleaseWriteLock(&avc->lock);
code = afs_CheckCode(code, areq, 1); /* defeat a buggy AIX optimization */
return code;
}
/* warn a user that a lock has been ignored */
afs_int32 lastWarnTime = 0; /* this is used elsewhere */
static afs_int32 lastWarnPid = 0;
static void
DoLockWarning(afs_ucred_t * acred)
{
afs_int32 now;
pid_t pid = MyPidxx2Pid(MyPidxx);
char *procname;
now = osi_Time();
AFS_STATCNT(DoLockWarning);
/* check if we've already warned this user recently */
if (!((now < lastWarnTime + 120) && (lastWarnPid == pid))) {
procname = afs_osi_Alloc(256);
if (!procname)
return;
/* Copies process name to allocated procname, see osi_machdeps for details of macro */
osi_procname(procname, 256);
procname[255] = '\0';
/* otherwise, it is time to nag the user */
lastWarnTime = now;
lastWarnPid = pid;
#ifdef AFS_LINUX26_ENV
afs_warnuser
("afs: byte-range locks only enforced for processes on this machine (pid %d (%s), user %ld).\n", pid, procname, (long)afs_cr_uid(acred));
#else
afs_warnuser
("afs: byte-range lock/unlock ignored; make sure no one else is running this program (pid %d (%s), user %ld).\n", pid, procname, (long)afs_cr_uid(acred));
#endif
afs_osi_Free(procname, 256);
}
return;
}
int afspag_PSetTokens(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
{
afs_int32 i;
register struct unixuser *tu;
struct afspag_cell *tcell;
struct ClearToken clear;
char *stp;
int stLen;
afs_int32 flag, set_parent_pag = 0;
afs_int32 pag, uid;
AFS_STATCNT(PSetTokens);
if (!afs_resourceinit_flag) {
return EIO;
}
memcpy((char *)&i, ain, sizeof(afs_int32));
ain += sizeof(afs_int32);
stp = ain; /* remember where the ticket is */
if (i < 0 || i > MAXKTCTICKETLEN)
return EINVAL; /* malloc may fail */
stLen = i;
ain += i; /* skip over ticket */
memcpy((char *)&i, ain, sizeof(afs_int32));
ain += sizeof(afs_int32);
if (i != sizeof(struct ClearToken)) {
return EINVAL;
}
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 */
memcpy((char *)&flag, ain, sizeof(afs_int32)); /* primary id flag */
ain += sizeof(afs_int32); /* skip id field */
/* rest is cell name, look it up */
/* some versions of gcc appear to need != 0 in order to get this right */
if ((flag & 0x8000) != 0) { /* XXX Use Constant XXX */
flag &= ~0x8000;
set_parent_pag = 1;
}
tcell = afspag_GetCell(ain);
} else {
/* default to primary cell, primary id */
flag = 1; /* primary id */
tcell = afspag_GetPrimaryCell();
}
if (!tcell) return ESRCH;
if (set_parent_pag) {
#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
# if defined(AFS_DARWIN_ENV)
afs_proc_t *p = current_proc(); /* XXX */
# else
afs_proc_t *p = curproc; /* XXX */
# endif
# ifndef AFS_DARWIN80_ENV
uprintf("Process %d (%s) tried to change pags in PSetTokens\n",
p->p_pid, p->p_comm);
# endif
setpag(p, acred, -1, &pag, 1);
#else
setpag(acred, -1, &pag, 1);
#endif
}
pag = PagInCred(*acred);
uid = (pag == NOPAG) ? afs_cr_uid(*acred) : pag;
/* now we just set the tokens */
tu = afs_GetUser(uid, tcell->cellnum, WRITE_LOCK);
if (!tu->cellinfo)
tu->cellinfo = (void *)tcell;
tu->vid = clear.ViceId;
if (tu->stp != NULL) {
afs_osi_Free(tu->stp, tu->stLen);
}
tu->stp = (char *)afs_osi_Alloc(stLen);
tu->stLen = stLen;
memcpy(tu->stp, stp, stLen);
tu->ct = clear;
#ifndef AFS_NOSTATS
afs_stats_cmfullperf.authent.TicketUpdates++;
afs_ComputePAGStats();
#endif /* AFS_NOSTATS */
tu->states |= UHasTokens;
tu->states &= ~UTokensBad;
afs_SetPrimary(tu, flag);
tu->tokenTime = osi_Time();
afs_PutUser(tu, WRITE_LOCK);
return 0;
}
/* called with the GLOCK held */
int
afs_syscall_pioctl(char *path, unsigned int com, caddr_t cmarg, int follow)
{
cred_t *credp = crref(); /* don't free until done! */
struct afs_ioctl data;
struct clientcred ccred;
struct rmtbulk idata, odata;
short in_size, out_size;
afs_int32 code = 0, pag, err;
gid_t g0, g1;
char *abspath, *pathbuf = 0;
AFS_STATCNT(afs_syscall_pioctl);
if (follow)
follow = 1; /* compat. with old venus */
code = copyin_afs_ioctl(cmarg, &data);
if (code) goto out;
if ((com & 0xff) == 90) {
/* PSetClientContext, in any space */
code = EINVAL;
goto out;
}
/* Special handling for a few pioctls */
switch (com & 0xffff) {
case (0x5600 | 3): /* VIOCSETTOK */
code = afspag_PSetTokens(data.in, data.in_size, &credp);
if (code) goto out;
break;
case (0x5600 | 9): /* VIOCUNLOG */
case (0x5600 | 21): /* VIOCUNPAG */
code = afspag_PUnlog(data.in, data.in_size, &credp);
if (code) goto out;
break;
case (0x5600 | 38): /* VIOC_AFS_SYSNAME */
code = afspag_PSetSysName(data.in, data.in_size, &credp);
if (code) goto out;
break;
}
/* Set up credentials */
memset(&ccred, 0, sizeof(ccred));
pag = PagInCred(credp);
ccred.uid = afs_cr_uid(credp);
if (pag != NOPAG) {
afs_get_groups_from_pag(pag, &g0, &g1);
ccred.group0 = g0;
ccred.group1 = g1;
}
/*
* Copy the path and convert to absolute, if one was given.
* NB: We can only use osI_AllocLargeSpace here as long as
* RMTSYS_MAXPATHLEN is less than AFS_LRALLOCSIZ.
*/
if (path) {
pathbuf = osi_AllocLargeSpace(RMTSYS_MAXPATHLEN);
if (!pathbuf) {
code = ENOMEM;
goto out;
}
code = osi_abspath(path, pathbuf, RMTSYS_MAXPATHLEN, 0, &abspath);
if (code)
goto out_path;
} else {
abspath = NIL_PATHP;
}
/* Allocate, copy, and convert incoming data */
idata.rmtbulk_len = in_size = data.in_size;
if (in_size < 0 || in_size > MAXBUFFERLEN) {
code = EINVAL;
goto out_path;
}
if (in_size > AFS_LRALLOCSIZ)
idata.rmtbulk_val = osi_Alloc(in_size);
else
idata.rmtbulk_val = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
if (!idata.rmtbulk_val) {
code = ENOMEM;
goto out_path;
}
if (in_size) {
AFS_COPYIN(data.in, idata.rmtbulk_val, in_size, code);
if (code)
goto out_idata;
inparam_conversion(com, idata.rmtbulk_val, in_size, 0);
}
/* Allocate space for outgoing data */
odata.rmtbulk_len = out_size = data.out_size;
if (out_size < 0 || out_size > MAXBUFFERLEN) {
code = EINVAL;
goto out_idata;
}
if (out_size > AFS_LRALLOCSIZ)
odata.rmtbulk_val = osi_Alloc(out_size);
else
odata.rmtbulk_val = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
if (!odata.rmtbulk_val) {
code = ENOMEM;
goto out_idata;
}
AFS_GUNLOCK();
code = RMTSYS_Pioctl(rmtsys_conn, &ccred, abspath, com, follow,
&idata, &odata, &err);
AFS_GLOCK();
if (code)
goto out_odata;
/* Convert and copy out the result */
if (odata.rmtbulk_len > out_size) {
code = E2BIG;
goto out_odata;
}
if (odata.rmtbulk_len) {
outparam_conversion(com, odata.rmtbulk_val, odata.rmtbulk_len, 1);
AFS_COPYOUT(odata.rmtbulk_val, data.out, odata.rmtbulk_len, code);
}
if (!code)
code = err;
out_odata:
if (out_size > AFS_LRALLOCSIZ)
osi_Free(odata.rmtbulk_val, out_size);
else
osi_FreeLargeSpace(odata.rmtbulk_val);
out_idata:
if (in_size > AFS_LRALLOCSIZ)
osi_Free(idata.rmtbulk_val, in_size);
else
osi_FreeLargeSpace(idata.rmtbulk_val);
out_path:
if (path)
osi_FreeLargeSpace(pathbuf);
out:
crfree(credp);
#if defined(KERNEL_HAVE_UERROR)
if (!getuerror())
setuerror(code);
return (getuerror());
#else
return (code);
#endif
}
