/***********************************************************************
* *
* This software is part of the ast package *
* Copyright (c) 1990-2012 AT&T Intellectual Property *
* and is licensed under the *
* Eclipse Public License, Version 1.0 *
* by AT&T Intellectual Property *
* *
* A copy of the License is available at *
* http://www.eclipse.org/org/documents/epl-v10.html *
* (with md5 checksum b35adb5213ca9657e911e9befb180842) *
* *
* Information and Software Systems Research *
* AT&T Research *
* Florham Park NJ *
* *
* Glenn Fowler <gsf@research.att.com> *
* *
***********************************************************************/
#pragma prototyped
/*
* Glenn Fowler
* AT&T Research
*
* connect stream server support
*/
#include "csslib.h"
#include <dirent.h>
#define OPEN_MIN 20
#if !defined(O_NONBLOCK) && defined(FNDELAY)
#define O_NONBLOCK FNDELAY
#endif
static Common_t state;
static int signals[] = /* caught by interrupt() */
{
SIGINT,
SIGQUIT,
SIGALRM,
SIGTERM,
#ifdef SIGCHLD
SIGCHLD,
#endif
};
/*
* catch interrupts
*/
static void
interrupt(int sig)
{
#if defined(SIGCHLD) && !_WINIX
if (sig != SIGCHLD)
#endif
signal(sig, interrupt);
#ifdef SIGCHLD
if (cs.interrupt != SIGCHLD)
#endif
cs.interrupt = sig;
}
/*
* called on exit
*/
static void
done(void)
{
cssclose(NiL);
}
/*
* drop fd ip
*/
static void
drop(Css_t* css, register Cspoll_t* pp)
{
register Cssfd_t* ip;
register int fd;
register int user;
if (!css)
css = state.main;
fd = pp->fd;
ip = &state.fdinfo[fd];
if (ip->css == css)
{
user = (ip->events & CS_POLL_USER) != 0;
ip->events = 0;
if (css->auth)
state.auth[fd].seq = 0;
if (ip->actionf)
{
ip->status = CS_POLL_CLOSE;
if ((*ip->actionf)(css, ip, css->disc) > 0)
fd = -1;
}
if (state.fdpolling > 0)
{
state.fdpolling--;
*pp = state.fdpoll[state.fdpolling];
}
css->fdpolling--;
if (ip->events & CS_POLL_CONNECT)
css->fdlistening--;
if (user)
css->fduser--;
else if (fd >= 0)
close(fd);
}
}
/*
* open the service
*/
Css_t*
cssopen(const char* path, Cssdisc_t* disc)
{
register Css_t* css;
int type;
int n;
char* s;
char* t;
struct stat st;
if (!state.servers)
{
csprotect(&cs);
if ((n = (int)strtol(astconf("OPEN_MAX", NiL, NiL), NiL, 0)) < OPEN_MIN)
n = OPEN_MIN;
if (!(s = newof(0, char, n * (sizeof(Cssfd_t) + sizeof(Cspoll_t) + sizeof(Auth_t)), 0)))
return 0;
state.fdpoll = (Cspoll_t*)(s);
state.fdinfo = (Cssfd_t*)(state.fdpoll + n);
state.auth = (Auth_t*)(state.fdinfo + n);
state.fdmax = n;
state.fdnext = -1;
state.pid = getpid();
if (!(css = newof(0, Css_t, 1, sizeof(Cssdisc_t))))
return 0;
css->id = cs.id;
css->disc = (Cssdisc_t*)(css + 1);
css->disc->version = CSS_VERSION;
state.servers = state.main = css;
atexit(done);
}
if (!path || (n = strlen(path) + 2) < 2 * CS_NAME_MAX)
n = 2 * CS_NAME_MAX;
if (!(css = newof(0, Css_t, 1, n)))
return 0;
n = n / 2 + 1;
css->next = state.servers;
state.servers = css;
if (!(css->state = csalloc(NiL)))
goto bad;
css->service = (char*)(css + 1);
css->path = css->service + n;
css->id = state.main->id;
css->disc = disc;
css->fdmax = state.fdmax;
if (path && strchr(path, '/'))
{
strcpy(css->path, path);
if (tokscan(css->path, NiL, "/dev/%s/%s/%s", &s, NiL, &t) != 3)
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "%s: invalid connect stream path", path);
goto bad;
}
type = *s;
if (s = strchr(t, '/'))
*s = 0;
strncpy(css->service, t, n);
errno = EBADF;
if ((css->fd = csopen(css->state, path, CS_OPEN_CREATE)) < 0)
{
if (css->disc->errorf)
{
if (errno == EEXIST)
(*css->disc->errorf)(css, css->disc, 3, "%s: server already running", path);
else
(*css->disc->errorf)(css, css->disc, ERROR_SYSTEM|3, "%s: cannot create connect stream", path);
}
goto bad;
}
css->disc->flags &= ~CSS_AUTHENTICATE;
}
else
{
sfsprintf(css->service, n, "/dev/fdp/local/%s", path);
path = (char*)cspath(css->state, 0, 0);
type = strmatch(path, "/dev/??p/*/*") ? path[5] : 'f';
css->perm = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;
if ((css->disc->flags & CSS_AUTHENTICATE) && csopen(css->state, css->service, CS_OPEN_CREATE|CS_OPEN_MOUNT))
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, ERROR_SYSTEM|3, "%s: cannot create authentication directory", css->service);
goto bad;
}
}
strcpy(css->path, path);
if ((css->disc->flags & CSS_DAEMON) && csdaemon(css->state, (css->disc->flags & CSS_PRESERVE) ? ~0L : ((1<<css->fd)|(1<<2))))
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "cannot dive into background");
goto bad;
}
if (css->state->control)
{
strcpy(css->mount, css->state->mount);
css->control = strrchr(css->mount, '/') + 1;
strcpy(css->control + 1, CS_MNT_TAIL);
s = css->control - 1;
*s = 0;
if (stat(css->mount, &st))
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "%s: cannot stat service directory", css->mount);
goto bad;
}
if ((css->disc->flags & CSS_DAEMON) && chdir(css->mount))
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "%s: cannot set service directory", css->mount);
goto bad;
}
*s = '/';
/*
* get the fid for the global and local authentication dirs
* authentication files can only be in these dirs and
* must not be symlinks -- symlinks can point to untrusted
* places and other dirs may get untrusted filesystems
* mounted via the automounter
*/
n = 0;
while (s > css->mount)
if (*--s == '/' && ++n >= 3)
break;
if (n != 3)
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "%s: invalid mount directory", css->mount);
goto bad;
}
*s = 0;
if (lstat(css->mount, &st))
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "%s: invalid global authentication directory", css->mount);
goto bad;
}
*s = '/';
css->fid[0].dev = st.st_dev;
css->fid[0].ino = st.st_ino;
s = csvar(css->state, CS_VAR_LOCAL, 0);
if (lstat(s, &st) && (mkdir(s, S_IRWXU|S_IRWXG|S_IRWXO) || chmod(s, S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO) || lstat(s, &st)))
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "%s: invalid local authentication directory", s);
goto bad;
}
css->fid[1].dev = st.st_dev;
css->fid[1].ino = st.st_ino;
css->uid = st.st_uid;
css->gid = st.st_gid;
if (type == 't' && *(css->control - 2) != CS_MNT_OTHER && *(css->control - 2) != '.' && *(css->control - 2) != '*')
{
css->auth = 1;
state.nauth++;
CSTIME();
state.expire = cs.time + KEYEXPIRE;
css->conkey = state.pid + getppid() + css->uid + st.st_ino;
TOSS(css->conkey);
*css->control = CS_MNT_AUTH;
remove(css->mount);
css->newkey = css->conkey & KEYMASK;
if (close(open(css->mount, O_WRONLY|O_CREAT|O_TRUNC, st.st_mode & (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH))) ||
chmod(css->mount, st.st_mode & (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) ||
cschallenge(css->state, css->mount, NiL, &css->newkey))
{
if (css->disc->errorf)
(*css->disc->errorf)(css, css->disc, 3, "%s: cannot create service authentication file", css->mount);
goto bad;
}
chown(css->mount, -1, css->gid);
css->oldkey = css->newkey;
for (n = 0; n < (css->newkey & 0xff); n++)
CSTOSS(css->conkey, n);
css->challenge = (st.st_mode & S_IXOTH) ? 2 : 0;
}
*css->control = CS_MNT_PROCESS;
remove(css->mount);
s = css->buf;
if (type != 'f') s += sfsprintf(s, sizeof(css->buf) - (s - css->buf), "/n/%s", csname(css->state, 0));
sfsprintf(s, sizeof(css->buf) - (s - css->buf), "/proc/%d", getpid());
pathsetlink(css->buf, css->mount);
if (css->disc->flags & CSS_LOG)
{
*css->control = CS_MNT_OLDLOG;
strcpy(css->buf, css->mount);
*css->control = CS_MNT_LOG;
rename(css->mount, css->buf);
close(2);
open(css->mount, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
}
*css->control = CS_MNT_AUTH;
css->perm = st.st_mode & (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
if (css->disc->flags & CSS_DAEMON)
umask(~css->perm & (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH));
}
if ((css->disc->flags & CSS_INTERRUPT) && !(state.flags & CSS_INTERRUPT))
{
state.flags |= CSS_INTERRUPT;
for (n = 0; n < elementsof(signals); n++)
if (signal(signals[n], SIG_IGN) != SIG_IGN)
signal(signals[n], interrupt);
}
cssfd(css, css->fd, type == 'u' ? CS_POLL_READ : (CS_POLL_AUTH|CS_POLL_CONNECT|CS_POLL_READ));
CSTIME();
return css;
bad:
cssclose(css);
return 0;
}
/*
* close the service
*/
int
cssclose(register Css_t* css)
{
register Css_t* pss;
register Css_t* xss;
register Css_t* oss;
register int i;
register int k;
static char mnt[] =
{
CS_MNT_AUTH,
CS_MNT_LOCK,
CS_MNT_PROCESS,
CS_MNT_STREAM
};
pss = 0;
xss = state.servers;
while (xss)
{
if (xss == css || !css)
{
if (xss->disc->exceptf && (xss->disc->flags & CSS_CLOSE))
(*xss->disc->exceptf)(css, CSS_CLOSE, 0, xss->disc);
if (state.fdinfo)
{
for (i = k = 0; i < state.fdpolling;)
{
if (state.fdinfo[state.fdpoll[i].fd].css == xss)
drop(xss, &state.fdpoll[i]);
else
state.fdpoll[k++] = state.fdpoll[i++];
}
state.fdpolling = k;
}
if (state.pid == getpid() && xss->control)
for (i = 0; i < elementsof(mnt); i++)
{
*xss->control = mnt[i];
remove(xss->control);
}
if (xss->auth)
state.nauth--;
oss = xss;
xss = xss->next;
if (pss)
pss->next = oss->next;
else
state.servers = oss->next;
if (oss->state)
csfree(oss->state);
free(oss);
if (css)
return 0;
}
else
{
pss = xss;
xss = xss->next;
}
}
if (css)
return -1;
if (!state.servers && state.fdpoll)
{
free(state.fdpoll);
state.fdpoll = 0;
}
return 0;
}
/*
* file descriptor manipulation
*
* CS_POLL_DUP(n) move fd to n
* CS_POLL_MOVE(n) move fd to n
* CS_POLL_PRI(n) set fd priority (not yet)
* CS_POLL_CLOSE close+delete fd from table
* CS_POLL_AUTH|* authenticate then poll
* CS_POLL_* poll
* CS_POLL_USER| don't close unless CS_POLL_CLOSE
*/
Cssfd_t*
cssfd(register Css_t* css, register int fd, unsigned long op)
{
register Cssfd_t* ip;
register Cspoll_t* pp;
register int n;
register int nfd;
register int cmd;
int flags;
#if DEBUG
int ofd = fd;
unsigned long oop = op;
#endif
if (!css)
css = state.main;
again:
if (fd < 0 || fd >= state.fdmax)
return 0;
ip = state.fdinfo + fd;
if (op == 0)
return ip->events ? ip : (Cssfd_t*)0;
if (op & CS_POLL_ARG)
{
cmd = op & CS_POLL_MASK;
nfd = (op >> CS_POLL_SHIFT) & CS_POLL_MASK;
op = nfd == CS_POLL_MASK ? CS_POLL_CLOSE : 0;
}
else
cmd = 0;
if (op != CS_POLL_CLOSE)
{
if (op & CS_POLL_AUTH)
{
if (!css->auth)
op &= ~CS_POLL_AUTH;
}
if (op & CS_POLL_CONNECT)
{
op &= ~(CS_POLL_CONTROL|CS_POLL_WRITE);
op |= CS_POLL_READ;
}
for (n = 0;; n++)
{
if (n >= state.fdpolling)
{
if (!(op & CS_POLL_AUTH|CS_POLL_CONNECT|CS_POLL_READ|CS_POLL_WRITE))
return 0;
if (fcntl(fd, F_SETFD, FD_CLOEXEC) && errno == EBADF)
return 0;
if ((op & (CS_POLL_AUTH|CS_POLL_CONNECT)) == CS_POLL_AUTH)
{
state.auth[fd].seq = 1;
state.auth[fd].expire = cs.time + EXPIRE;
}
pp = state.fdpoll + state.fdpolling++;
pp->fd = fd;
pp->events = op;
pp->status = 0;
ip->css = css;
ip->fd = fd;
ip->actionf = css->disc->actionf;
ip->data = 0;
ip->events = op;
ip->set = 0;
css->fdpolling++;
if (ip->events & CS_POLL_BEFORE)
state.fdbefore++;
if (ip->events & CS_POLL_CONNECT)
css->fdlistening++;
if (ip->events & CS_POLL_USER)
css->fduser++;
#if DEBUG
goto show;
#else
return ip;
#endif
}
if (state.fdpoll[n].fd == fd)
{
switch (cmd)
{
case 0:
if (ip->css != css)
return 0;
if (css->fd != fd)
{
if (ip->events & CS_POLL_BEFORE)
state.fdbefore--;
if (ip->events & CS_POLL_CONNECT)
css->fdlistening--;
if (ip->events & CS_POLL_USER)
css->fduser--;
state.fdpoll[n].events = ip->events = op;
if (ip->events & CS_POLL_BEFORE)
state.fdbefore++;
if (ip->events & CS_POLL_CONNECT)
css->fdlistening++;
if (ip->events & CS_POLL_USER)
css->fduser++;
if (op & CS_POLL_WRITE)
{
#ifdef O_NONBLOCK
if (!(ip->set & CS_POLL_WRITE))
{
ip->set |= CS_POLL_WRITE;
if ((flags = fcntl(fd, F_GETFL, 0)) >= 0)
{
flags |= O_NONBLOCK;
fcntl(fd, F_SETFL, flags);
messagef((state.main->id, NiL, -4, "cssfd: %d O_NONBLOCK", fd));
}
}
#endif
messagef((state.main->id, NiL, -4, "cssfd: %d CS_POLL_WRITE", fd));
}
}
break;
case CS_POLL_DUP:
/*ip->actionf = 0;*/
css = ip->css;
fd = nfd;
op = state.fdpoll[n].events;
goto again;
case CS_POLL_MOVE:
if (fcntl(nfd, F_SETFD, FD_CLOEXEC) && errno == EBADF)
return 0;
state.fdpoll[n].fd = nfd;
if (fd == css->fd)
css->fd = nfd;
state.fdinfo[nfd] = *ip;
ip = state.fdinfo + nfd;
ip->fd = nfd;
break;
case CS_POLL_PRI:
break;
}
#if DEBUG
show:
if (error_info.trace <= -9)
{
errorf(state.main->id, NiL, -9, "cssfd: pending=%d polling=%d next=%d fd=%d op=0x%08lx", state.fdpending, state.fdpolling, state.fdnext, ofd, oop);
for (n = 0; n < state.fdpolling; n++)
errorf(state.main->id, NiL, -9, "cssfd: index=%d fd=%d events=%06o actionf=%p", n, state.fdpoll[n].fd, state.fdpoll[n].events, state.fdinfo[state.fdpoll[n].fd].actionf);
}
#endif
return ip;
}
}
}
else if (css->fd != fd)
{
for (n = 0; n < state.fdpolling; n++)
if (state.fdpoll[n].fd == fd)
{
drop(state.fdinfo[fd].css, &state.fdpoll[n]);
break;
}
if (n >= state.fdpolling)
close(fd);
#if DEBUG
ip = 0;
goto show;
#endif
}
return 0;
}
/*
* poll for the next fd event
* some events may be pending from the last call
*/
Cssfd_t*
csspoll(unsigned long ms, unsigned long flags)
{
register Css_t* css;
register Cspoll_t* pp;
register Cssfd_t* ip;
register Auth_t* ap;
register int fd;
char* s;
char* t;
int n;
int fdnew;
int status;
int to;
int oerrno;
int err;
int clrerr;
int sig;
int clrsig;
unsigned long key;
unsigned long z;
unsigned long timeout;
Csid_t id;
struct stat st;
char** vp;
char* va[8];
if (state.polling && !(flags & CSS_RECURSIVE))
{
errno = EBUSY;
return 0;
}
state.polling++;
if (ms == CS_NEVER)
timeout = 0;
else
timeout = CSTIME() + ((ms + 999) / 1000);
oerrno = errno;
for (;;)
{
while (state.fdpending <= 0)
{
CSTIME();
if (timeout && timeout >= cs.time)
{
errno = oerrno;
return 0;
}
if (state.nauth && cs.time > state.expire)
{
state.expire = cs.time + KEYEXPIRE;
for (css = state.servers; css; css = css->next)
if (css->auth)
{
css->oldkey = css->newkey;
n = cs.time & 077;
do TOSS(css->newkey); while (n--);
css->newkey &= KEYMASK;
*css->control = CS_MNT_AUTH;
if (cschallenge(css->state, css->mount, NiL, &css->newkey))
css->newkey = css->oldkey;
}
for (pp = state.fdpoll; pp < state.fdpoll + state.fdpolling;)
{
ap = state.auth + pp->fd;
if (ap->seq && cs.time > ap->expire)
drop(state.fdinfo[pp->fd].css, pp);
else
pp++;
}
}
to = ms;
for (css = state.servers; css; css = css->next)
{
css->fdpending = 0;
if (css->disc->timeout)
{
if (css->timeout_last != css->disc->timeout)
css->timeout_last = css->timeout_remain = css->disc->timeout;
if (to > css->timeout_remain)
to = css->timeout_remain;
}
if (css->disc->wakeup)
{
if (css->wakeup_last != css->disc->wakeup)
css->wakeup_last = css->wakeup_remain = css->disc->wakeup;
if (to > css->wakeup_remain)
to = css->wakeup_remain;
}
}
if (state.fdbefore)
for (pp = state.fdpoll; pp < state.fdpoll + state.fdpolling;)
{
if (pp->events & CS_POLL_BEFORE)
{
ip = state.fdinfo + pp->fd;
ip->status = CS_POLL_BEFORE;
if (ip->actionf && (*ip->actionf)(ip->css, ip, ip->css->disc) < 0)
{
drop(ip->css, pp);
continue;
}
}
pp++;
}
z = cs.time;
if ((state.fdpending = cspoll(&cs, state.fdpoll, state.fdpolling, to)) < 0)
{
err = errno;
sig = (err == EINTR) ? cs.interrupt : 0;
clrsig = 0;
clrerr = 0;
}
else
{
err = 0;
sig = 0;
}
state.fdloop = 1;
CSTIME();
if (state.fdpending)
z = (cs.time - z) * 1000;
else
z = to;
if (ms != CS_NEVER)
{
if (ms > z)
ms -= z;
else
timeout = cs.time;
}
if (state.fdpending > 0)
for (pp = state.fdpoll; pp < state.fdpoll + state.fdpolling; pp++)
if (pp->status & (CS_POLL_READ|CS_POLL_WRITE))
state.fdinfo[pp->fd].css->fdpending++;
for (css = state.servers; css; css = css->next)
if (css->disc->exceptf)
{
if (css->disc->timeout)
{
if (css->fdpending)
css->timeout_remain = css->disc->timeout;
else if (css->timeout_remain <= z)
{
if ((css->disc->flags & CSS_DORMANT) && css->fdpolling <= (css->fdlistening + css->fduser))
(*css->disc->exceptf)(css, CSS_DORMANT, 0, css->disc);
else if (css->disc->flags & CSS_TIMEOUT)
(*css->disc->exceptf)(css, CSS_TIMEOUT, 0, css->disc);
css->timeout_last = css->timeout_remain = css->disc->timeout;
}
else
css->timeout_remain -= z;
}
if (css->disc->wakeup)
{
messagef((state.main->id, NiL, -4, "csspoll: pending=%d polling=%d z=%I*d wakeup=%I*d remain=%I*d", state.fdpending, state.fdpolling, sizeof(z), z, sizeof(css->disc->wakeup), css->disc->wakeup, sizeof(css->wakeup_remain), css->wakeup_remain));
if (css->wakeup_remain <= z)
{
(*css->disc->exceptf)(css, CSS_WAKEUP, 0, css->disc);
css->wakeup_last = css->wakeup_remain = css->disc->wakeup;
}
else
css->wakeup_remain -= z;
}
if (err)
{
if ((css->disc->flags & CSS_INTERRUPT) && (sig || err == EINTR))
{
if (!sig)
clrerr = 1;
else if ((*css->disc->exceptf)(css, CSS_INTERRUPT, sig, css->disc) >= 0)
clrsig = 1;
}
else if (css->disc->flags & CSS_ERROR)
{
if ((*css->disc->exceptf)(css, CSS_ERROR, err, css->disc) >= 0)
clrerr = 1;
}
}
}
if (err && (ms != CS_NEVER || (flags & CSS_INTERRUPT) && (sig || err == EINTR) && !clrsig || (flags & CSS_ERROR) && !sig && err != EINTR && !clrerr))
{
errno = err;
state.polling--;
return 0;
}
}
do
{
if (++state.fdnext >= state.fdpolling)
{
if (state.fdloop-- < 0)
break;
state.fdnext = 0;
}
pp = state.fdpoll + state.fdnext;
fd = pp->fd;
messagef((state.main->id, NiL, -9, "csspoll: pending=%d polling=%d next=%d fd=%d status=%06o", state.fdpending, state.fdpolling, state.fdnext, fd, pp->status));
ip = state.fdinfo + fd;
css = ip->css;
status = pp->status & ~(CS_POLL_BEFORE|CS_POLL_USER);
pp->status = 0;
switch (status)
{
case CS_POLL_AUTH|CS_POLL_CONNECT|CS_POLL_READ:
if (css->auth)
{
if (csrecv(css->state, fd, &id, &fdnew, 1) == 1)
{
state.auth[fdnew].id = id;
cssfd(css, fdnew, CS_POLL_AUTH|CS_POLL_READ);
}
break;
}
/*FALLTHROUGH*/
case CS_POLL_CONNECT|CS_POLL_READ:
if (csrecv(css->state, fd, &id, &fdnew, 1) == 1 &&
(ip = cssfd(css, fdnew, CS_POLL_READ)) &&
css->disc->acceptf &&
(fdnew = (*css->disc->acceptf)(css, ip, &id, NiL, css->disc)) != ip->fd)
cssfd(css, ip->fd, fdnew >= 0 ? CS_POLL_CMD(fdnew, CS_POLL_MOVE) : CS_POLL_CLOSE);
break;
case CS_POLL_AUTH|CS_POLL_READ:
switch ((ap = state.auth + fd)->seq)
{
case 1:
if ((n = csread(css->state, fd, css->buf, sizeof(css->buf), CS_LINE)) <= 0)
goto reject;
css->buf[n - 1] = 0;
if (tokscan(css->buf, &t, "%lu", &key) != 1)
goto reject;
switch (key)
{
case CS_KEY_SEND:
n = sfsprintf(css->tmp, sizeof(css->tmp), "%s\n", css->mount);
if (cswrite(css->state, fd, css->tmp, n) != n)
goto reject;
break;
default:
if (key <= CS_KEY_MAX || key != css->newkey && key != css->oldkey || tokscan(t, NiL, "%ld", &ap->id.pid) != 1)
goto reject;
if (!(ap->seq = css->challenge))
{
st.st_uid = css->uid;
st.st_gid = css->gid;
goto ok;
}
css->conkey ^= cs.time ^ ap->id.pid;
n = cs.time & 017;
do TOSS(css->conkey); while (n--);
ap->atime = css->conkey & KEYMASK;
n = cs.time & 07;
do TOSS(css->conkey); while (n--);
ap->mtime = css->conkey & KEYMASK;
n = sfsprintf(css->tmp, sizeof(css->tmp), "%lu %lu\n", (unsigned long)ap->atime, (unsigned long)ap->mtime);
if (cswrite(css->state, fd, css->tmp, n) != n)
goto reject;
ap->expire = cs.time + EXPIRE;
break;
}
break;
case 2:
ap->seq = 0;
if (cs.time > ap->expire || (n = csread(css->state, fd, css->buf, sizeof(css->buf), CS_LINE)) <= 1)
goto reject;
css->buf[n - 1] = 0;
if (t = strchr(css->buf, ' '))
*t++ = 0;
if (!(s = strrchr(css->buf, '/')))
goto reject;
*s = 0;
if (lstat(css->buf, &st))
goto reject;
*s = '/';
for (n = 0; n < elementsof(css->fid); n++)
#if _UWIN
if (css->fid[n].dev == st.st_dev)
#else
if (css->fid[n].dev == st.st_dev && css->fid[n].ino == st.st_ino)
#endif
break;
if (n >= elementsof(css->fid))
goto reject;
if (lstat(css->buf, &st))
{
/*
* kick the NonFS cache
*/
if (!(s = strrchr(css->buf, '.')))
goto reject;
*s = 0;
close(open(css->buf, O_WRONLY|O_CREAT|O_TRUNC, 0));
remove(css->buf);
*s = '.';
if (lstat(css->buf, &st))
goto reject;
}
if ((st.st_mode & CS_AUTH_MODE) != CS_AUTH_MODE ||
ap->atime != st.st_atime ||
ap->mtime != st.st_mtime)
goto reject;
ok:
if (cswrite(css->state, fd, "\n", 1) != 1)
goto reject;
pp->events &= ~CS_POLL_AUTH;
if (css->disc->acceptf)
{
ip = state.fdinfo + pp->fd;
ap->id.uid = st.st_uid;
ap->id.gid = st.st_gid;
vp = va;
while ((vp < &va[elementsof(va) - 1]) &&
(*vp++ = t) && (t = strchr(t, ' ')))
*t++ = 0;
*vp = 0;
if ((fdnew = (*css->disc->acceptf)(css, ip, &ap->id, *va ? va : (char**)0, css->disc)) != ip->fd)
cssfd(css, ip->fd, fdnew >= 0 ? CS_POLL_CMD(fdnew, CS_POLL_MOVE) : CS_POLL_CLOSE);
}
break;
default:
goto reject;
}
break;
case CS_POLL_READ|CS_POLL_WRITE:
case CS_POLL_WRITE:
pp->events &= ~CS_POLL_WRITE;
/*FALLTHROUGH*/
case CS_POLL_READ:
ip->status = status;
messagef((state.main->id, NiL, -9, "csspoll: status=%06o fd=%d actionf=%p", status, fd, ip->actionf));
if (!ip->actionf || (n = (*ip->actionf)(css, ip, css->disc)) == 0)
{
state.fdpending--;
state.polling--;
return ip;
}
if (n < 0)
goto reject;
break;
case CS_POLL_AUTH:
case CS_POLL_AUTH|CS_POLL_CONNECT:
case CS_POLL_CONNECT:
break;
case 0:
continue;
default:
reject:
drop(css, pp);
state.fdnext--;
break;
}
state.fdpending--;
} while (state.fdpending);
}
}