int afspag_PUnlog(char *ain, afs_int32 ainSize, struct AFS_UCRED **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) ? (*acred)->cr_uid : 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((char *)&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;
}
int afspag_PSetTokens(char *ain, afs_int32 ainSize, struct AFS_UCRED **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)
struct proc *p = current_proc(); /* XXX */
#else
struct proc *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
#ifdef AFS_OSF_ENV
setpag(u.u_procp, acred, -1, &pag, 1); /* XXX u.u_procp is a no-op XXX */
#else
setpag(acred, -1, &pag, 1);
#endif
#endif
}
pag = PagInCred(*acred);
uid = (pag == NOPAG) ? (*acred)->cr_uid : 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
}
