void
f_clone(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
File *f1, *f2;
int fid, fid1;
if(CHAT(cp)) {
print("c_clone %d\n", cp->chan);
print(" old fid = %d\n", in->fid);
print(" new fid = %d\n", in->newfid);
}
fid = in->fid;
fid1 = in->newfid;
f1 = 0;
f2 = 0;
if(fid < fid1) {
f1 = filep(cp, fid, 0);
f2 = filep(cp, fid1, 1);
} else
if(fid1 < fid) {
f2 = filep(cp, fid1, 1);
f1 = filep(cp, fid, 0);
}
if(!f1 || !f2) {
ou->err = Efid;
goto out;
}
f2->fs = f1->fs;
f2->addr = f1->addr;
f2->open = f1->open & ~FREMOV;
f2->uid = f1->uid;
f2->slot = f1->slot;
f2->qid = f1->qid;
freewp(f2->wpath);
f2->wpath = getwp(f1->wpath);
out:
ou->fid = fid;
if(f1)
qunlock(f1);
if(f2)
qunlock(f2);
}
void
f_fstat(Chan *cp, Fcall *in, Fcall *ou)
{
File *f;
Iobuf *p;
Dentry *d;
int i;
if(CHAT(cp)) {
fprint(2, "c_fstat %d\n", cp->chan);
fprint(2, "\tfid = %d\n", in->fid);
}
p = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
p = getbuf(f->fs->dev, f->addr, Brd);
d = getdir(p, f->slot);
if(d == 0)
goto out;
print("name = %.*s\n", NAMELEN, d->name);
print("uid = %d; gid = %d; muid = %d\n", d->uid, d->gid, d->muid);
print("size = %lld; qid = %llux/%lux\n", (Wideoff)d->size,
(Wideoff)d->qid.path, d->qid.version);
print("atime = %ld; mtime = %ld\n", d->atime, d->mtime);
print("dblock =");
for(i=0; i<NDBLOCK; i++)
print(" %lld", (Wideoff)d->dblock[i]);
for (i = 0; i < NIBLOCK; i++)
print("; iblocks[%d] = %lld", i, (Wideoff)d->iblocks[i]);
print("\n\n");
out:
if(p)
putbuf(p);
ou->fid = in->fid;
if(f)
qunlock(f);
}
void
f_stat(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p;
Dentry *d;
File *f;
if(CHAT(cp)) {
print("c_stat %d\n", cp->chan);
print(" fid = %d\n", in->fid);
}
p = 0;
memset(ou->stat, 0, sizeof(ou->stat));
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
p = getbuf(f->fs->dev, f->addr, Bread);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if(ou->err = mkqidcmp(&f->qid, d))
goto out;
if(d->qid.path == QPROOT) /* stat of root gives time */
d->atime = time(0);
if(convD2M9p1(d, ou->stat) != DIRREC)
print("stat convD2M\n");
out:
if(p)
putbuf(p);
if(f)
qunlock(f);
ou->fid = in->fid;
}
void
f_clri(Chan *cp, Fcall *in, Fcall *ou)
{
File *f;
if(CHAT(cp)) {
fprint(2, "c_clri %d\n", cp->chan);
fprint(2, "\tfid = %d\n", in->fid);
}
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
ou->err = doclri(f);
out:
ou->fid = in->fid;
if(f)
qunlock(f);
}
void
f_remove(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
File *f;
if(CHAT(cp)) {
print("c_remove %d\n", cp->chan);
print(" fid = %d\n", in->fid);
}
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
ou->err = doremove(f, cp==cons.chan);
out:
ou->fid = in->fid;
if(f)
qunlock(f);
}
void
f_clunk(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
File *f;
Tlock *t;
int32_t tim;
if(CHAT(cp)) {
print("c_clunk %d\n", cp->chan);
print(" fid = %d\n", in->fid);
}
f = filep(cp, in->fid, 0);
if(!f) {
print("%p\n", f);
ou->err = Efid;
goto out;
}
if(t = f->tlock) {
tim = time(0);
if(t->time < tim || t->file != f)
ou->err = Ebroken;
t->time = 0; /* free the lock */
f->tlock = 0;
}
if(f->open & FREMOV)
ou->err = doremove(f, 0);
f->open = 0;
freewp(f->wpath);
freefp(f);
out:
if(f)
qunlock(f);
ou->fid = in->fid;
}
void
f_walk(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p, *p1;
Dentry *d, *d1;
File *f;
Wpath *w, *ow;
int slot;
int32_t addr;
if(CHAT(cp)) {
print("c_walk %d\n", cp->chan);
print(" fid = %d\n", in->fid);
print(" name = %s\n", in->name);
}
ou->fid = in->fid;
ou->qid = QID9P1(0,0);
p = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
p = getbuf(f->fs->dev, f->addr, Bread);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if(!(d->mode & DDIR)) {
ou->err = Edir1;
goto out;
}
if(ou->err = mkqidcmp(&f->qid, d))
goto out;
if(cp != cons.chan && iaccess(f, d, DEXEC)) {
ou->err = Eaccess;
goto out;
}
accessdir(p, d, FREAD);
if(strcmp(in->name, ".") == 0)
goto setdot;
if(strcmp(in->name, "..") == 0) {
if(f->wpath == 0)
goto setdot;
putbuf(p);
p = 0;
addr = f->wpath->addr;
slot = f->wpath->slot;
p1 = getbuf(f->fs->dev, addr, Bread);
d1 = getdir(p1, slot);
if(!d1 || checktag(p1, Tdir, QPNONE) || !(d1->mode & DALLOC)) {
if(p1)
putbuf(p1);
ou->err = Ephase;
goto out;
}
ow = f->wpath;
f->wpath = ow->up;
putwp(ow);
goto found;
}
for(addr=0;; addr++) {
p1 = dnodebuf(p, d, addr, 0);
if(!p1 || checktag(p1, Tdir, d->qid.path) ) {
if(p1)
putbuf(p1);
ou->err = Eentry;
goto out;
}
for(slot=0; slot<DIRPERBUF; slot++) {
d1 = getdir(p1, slot);
if(!(d1->mode & DALLOC))
continue;
if(strncmp(in->name, d1->name, sizeof(in->name)))
continue;
/*
* update walk path
*/
w = newwp();
if(!w) {
ou->err = Ewalk;
putbuf(p1);
goto out;
}
w->addr = f->addr;
w->slot = f->slot;
w->up = f->wpath;
f->wpath = w;
slot += DIRPERBUF*addr;
goto found;
}
putbuf(p1);
}
found:
f->addr = p1->addr;
mkqid(&f->qid, d1, 1);
putbuf(p1);
f->slot = slot;
setdot:
mkqid9p1(&ou->qid, &f->qid);
f->open = 0;
out:
if(p)
putbuf(p);
if(f)
qunlock(f);
}
void
f_attach(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p;
Dentry *d;
File *f;
int u;
Filsys *fs;
int32_t raddr;
if(CHAT(cp)) {
print("c_attach %d\n", cp->chan);
print(" fid = %d\n", in->fid);
print(" uid = %s\n", in->uname);
print(" arg = %s\n", in->aname);
}
ou->qid = QID9P1(0,0);
ou->fid = in->fid;
if(!in->aname[0]) /* default */
strncpy(in->aname, filesys[0].name, sizeof(in->aname));
p = 0;
f = filep(cp, in->fid, 1);
if(!f) {
ou->err = Efid;
goto out;
}
u = -1;
if(cp != cons.chan){
if(authorize(cp, in, ou) == 0 || strcmp(in->uname, "adm") == 0){
ou->err = Eauth;
goto out;
}
u = strtouid(in->uname);
if(u < 0){
ou->err = Ebadu;
goto out;
}
}
fs = fsstr(in->aname);
if(fs == 0) {
ou->err = Ebadspc;
goto out;
}
raddr = getraddr(fs->dev);
p = getbuf(fs->dev, raddr, Bread);
d = getdir(p, 0);
if(!d || checktag(p, Tdir, QPROOT) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
f->uid = u;
if(iaccess(f, d, DREAD)) {
ou->err = Eaccess;
goto out;
}
accessdir(p, d, FREAD);
mkqid(&f->qid, d, 1);
f->fs = fs;
f->addr = raddr;
f->slot = 0;
f->open = 0;
freewp(f->wpath);
f->wpath = 0;
mkqid9p1(&ou->qid, &f->qid);
out:
if(p)
putbuf(p);
if(f) {
qunlock(f);
if(ou->err)
freefp(f);
}
}
void
f_write(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p, *p1;
Dentry *d;
File *f;
Tlock *t;
int32_t offset, addr, tim;
int count, nwrite, o, n;
if(CHAT(cp)) {
print("c_write %d\n", cp->chan);
print(" fid = %d\n", in->fid);
print(" offset = %ld\n", in->offset);
print(" count = %ld\n", in->count);
}
offset = in->offset;
count = in->count;
nwrite = 0;
p = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
if(!(f->open & FWRITE)) {
ou->err = Eopen;
goto out;
}
if(isro(f->fs->dev) || (cp != cons.chan && writegroup && !ingroup(f->uid, writegroup))) {
ou->err = Eronly;
goto out;
}
if(count < 0 || count > MAXDAT) {
ou->err = Ecount;
goto out;
}
if(offset < 0) {
ou->err = Eoffset;
goto out;
}
p = getbuf(f->fs->dev, f->addr, Bread|Bmod);
d = getdir(p, f->slot);
if(!d || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if(ou->err = mkqidcmp(&f->qid, d))
goto out;
if(t = f->tlock) {
tim = time(0);
if(t->time < tim || t->file != f) {
ou->err = Ebroken;
goto out;
}
/* renew the lock */
t->time = tim + TLOCK;
}
accessdir(p, d, FWRITE);
if(d->mode & DAPND)
offset = d->size;
if(offset+count > d->size)
d->size = offset+count;
while(count > 0) {
addr = offset / BUFSIZE;
o = offset % BUFSIZE;
n = BUFSIZE - o;
if(n > count)
n = count;
p1 = dnodebuf(p, d, addr, Tfile);
if(p1 == 0) {
ou->err = Efull;
goto out;
}
if(checktag(p1, Tfile, d->qid.path)) {
putbuf(p1);
ou->err = Ephase;
goto out;
}
memmove(p1->iobuf+o, in->data+nwrite, n);
p1->flags |= Bmod;
putbuf(p1);
count -= n;
nwrite += n;
offset += n;
}
if(CHAT(cp))
print(" nwrite = %d\n", nwrite);
out:
if(p)
putbuf(p);
if(f)
qunlock(f);
ou->fid = in->fid;
ou->count = nwrite;
}
void
f_read(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p, *p1;
File *f;
Dentry *d, *d1;
Tlock *t;
int32_t addr, offset, tim;
int nread, count, n, o, slot;
if(CHAT(cp)) {
print("c_read %d\n", cp->chan);
print(" fid = %d\n", in->fid);
print(" offset = %ld\n", in->offset);
print(" count = %ld\n", in->count);
}
p = 0;
count = in->count;
offset = in->offset;
nread = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
if(!(f->open & FREAD)) {
ou->err = Eopen;
goto out;
}
if(count < 0 || count > MAXDAT) {
ou->err = Ecount;
goto out;
}
if(offset < 0) {
ou->err = Eoffset;
goto out;
}
p = getbuf(f->fs->dev, f->addr, Bread);
d = getdir(p, f->slot);
if(!d || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if(ou->err = mkqidcmp(&f->qid, d))
goto out;
if(t = f->tlock) {
tim = time(0);
if(t->time < tim || t->file != f) {
ou->err = Ebroken;
goto out;
}
/* renew the lock */
t->time = tim + TLOCK;
}
accessdir(p, d, FREAD);
if(d->mode & DDIR) {
addr = 0;
goto dread;
}
if(offset+count > d->size)
count = d->size - offset;
while(count > 0) {
addr = offset / BUFSIZE;
if(addr == f->lastra+1)
dbufread(p, d, addr+1);
f->lastra = addr;
o = offset % BUFSIZE;
n = BUFSIZE - o;
if(n > count)
n = count;
p1 = dnodebuf(p, d, addr, 0);
if(p1) {
if(checktag(p1, Tfile, QPNONE)) {
ou->err = Ephase;
putbuf(p1);
goto out;
}
memmove(ou->data+nread, p1->iobuf+o, n);
putbuf(p1);
} else
memset(ou->data+nread, 0, n);
count -= n;
nread += n;
offset += n;
}
goto out;
dread:
p1 = dnodebuf(p, d, addr, 0);
if(!p1)
goto out;
if(checktag(p1, Tdir, QPNONE)) {
ou->err = Ephase;
putbuf(p1);
goto out;
}
n = DIRREC;
for(slot=0; slot<DIRPERBUF; slot++) {
d1 = getdir(p1, slot);
if(!(d1->mode & DALLOC))
continue;
if(offset >= n) {
offset -= n;
continue;
}
if(count < n) {
putbuf(p1);
goto out;
}
if(convD2M9p1(d1, ou->data+nread) != n)
print("dirread convD2M\n");
nread += n;
count -= n;
}
putbuf(p1);
addr++;
goto dread;
out:
count = in->count - nread;
if(count > 0)
memset(ou->data+nread, 0, count);
if(p)
putbuf(p);
if(f)
qunlock(f);
ou->fid = in->fid;
ou->count = nread;
if(CHAT(cp))
print(" nread = %d\n", nread);
}
void
f_create(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p, *p1;
Dentry *d, *d1;
File *f;
int slot, slot1, fmod;
int32_t addr, addr1, path;
Qid qid;
Tlock *t;
Wpath *w;
if(CHAT(cp)) {
print("c_create %d\n", cp->chan);
print(" fid = %d\n", in->fid);
print(" name = %s\n", in->name);
print(" perm = %lx+%lo\n", (in->perm>>28)&0xf,
in->perm&0777);
print(" mode = %d\n", in->mode);
}
p = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
if(isro(f->fs->dev) || (cp != cons.chan && writegroup && !ingroup(f->uid, writegroup))) {
ou->err = Eronly;
goto out;
}
p = getbuf(f->fs->dev, f->addr, Bread);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if(ou->err = mkqidcmp(&f->qid, d))
goto out;
if(!(d->mode & DDIR)) {
ou->err = Edir2;
goto out;
}
if(cp != cons.chan && iaccess(f, d, DWRITE) && !writeallow) {
ou->err = Eaccess;
goto out;
}
accessdir(p, d, FREAD);
if(!strncmp(in->name, ".", sizeof(in->name)) ||
!strncmp(in->name, "..", sizeof(in->name))) {
ou->err = Edot;
goto out;
}
if(checkname(in->name)) {
ou->err = Ename;
goto out;
}
addr1 = 0;
slot1 = 0; /* set */
for(addr=0;; addr++) {
p1 = dnodebuf(p, d, addr, 0);
if(!p1) {
if(addr1)
break;
p1 = dnodebuf(p, d, addr, Tdir);
}
if(p1 == 0) {
ou->err = Efull;
goto out;
}
if(checktag(p1, Tdir, d->qid.path)) {
putbuf(p1);
goto phase;
}
for(slot=0; slot<DIRPERBUF; slot++) {
d1 = getdir(p1, slot);
if(!(d1->mode & DALLOC)) {
if(!addr1) {
addr1 = p1->addr;
slot1 = slot + addr*DIRPERBUF;
}
continue;
}
if(!strncmp(in->name, d1->name, sizeof(in->name))) {
putbuf(p1);
ou->err = Eexist;
goto out;
}
}
putbuf(p1);
}
switch(in->mode & 7) {
case MEXEC:
case MREAD: /* seems only useful to make directories */
fmod = FREAD;
break;
case MWRITE:
fmod = FWRITE;
break;
case MBOTH:
fmod = FREAD+FWRITE;
break;
default:
ou->err = Emode;
goto out;
}
if(in->perm & PDIR)
if((in->mode & MTRUNC) || (in->perm & PAPND) || (fmod & FWRITE))
goto badaccess;
/*
* do it
*/
path = qidpathgen(&f->fs->dev);
p1 = getbuf(f->fs->dev, addr1, Bread|Bimm|Bmod);
d1 = getdir(p1, slot1);
if(!d1 || checktag(p1, Tdir, d->qid.path)) {
if(p1)
putbuf(p1);
goto phase;
}
if(d1->mode & DALLOC) {
putbuf(p1);
goto phase;
}
strncpy(d1->name, in->name, sizeof(in->name));
/*
* bogus argument passing -- see console.c
*/
if(cp == cons.chan) {
d1->uid = cons.uid;
d1->gid = cons.gid;
} else {
d1->uid = f->uid;
d1->gid = d->gid;
in->perm &= d->mode | ~0666;
if(in->perm & PDIR)
in->perm &= d->mode | ~0777;
}
d1->qid.path = path;
d1->qid.version = 0;
d1->mode = DALLOC | (in->perm & 0777);
if(in->perm & PDIR) {
d1->mode |= DDIR;
d1->qid.path |= QPDIR;
}
if(in->perm & PAPND)
d1->mode |= DAPND;
t = 0;
if(in->perm & PLOCK) {
d1->mode |= DLOCK;
t = tlocked(p1, d1);
}
accessdir(p1, d1, FWRITE);
mkqid(&qid, d1, 0);
putbuf(p1);
accessdir(p, d, FWRITE);
/*
* do a walk to new directory entry
*/
w = newwp();
if(!w) {
ou->err = Ewalk;
goto out;
}
w->addr = f->addr;
w->slot = f->slot;
w->up = f->wpath;
f->wpath = w;
f->qid = qid;
f->tlock = t;
f->lastra = 0;
if(in->mode & MRCLOSE)
fmod |= FREMOV;
f->open = fmod;
f->addr = addr1;
f->slot = slot1;
if(t)
t->file = f;
mkqid9p1(&ou->qid, &qid);
goto out;
badaccess:
ou->err = Eaccess;
goto out;
phase:
ou->err = Ephase;
out:
if(p)
putbuf(p);
if(f)
qunlock(f);
ou->fid = in->fid;
}
void
f_open(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p;
Dentry *d;
File *f;
Tlock *t;
Qid qid;
int ro, fmod;
if(CHAT(cp)) {
print("c_open %d\n", cp->chan);
print(" fid = %d\n", in->fid);
print(" mode = %o\n", in->mode);
}
p = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
/*
* if remove on close, check access here
*/
ro = isro(f->fs->dev) || (cp != cons.chan && writegroup && !ingroup(f->uid, writegroup));
if(in->mode & MRCLOSE) {
if(ro) {
ou->err = Eronly;
goto out;
}
/*
* check on parent directory of file to be deleted
*/
if(f->wpath == 0 || f->wpath->addr == f->addr) {
ou->err = Ephase;
goto out;
}
p = getbuf(f->fs->dev, f->wpath->addr, Bread);
d = getdir(p, f->wpath->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ephase;
goto out;
}
if(iaccess(f, d, DWRITE)) {
ou->err = Eaccess;
goto out;
}
putbuf(p);
}
p = getbuf(f->fs->dev, f->addr, Bread);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if(ou->err = mkqidcmp(&f->qid, d))
goto out;
mkqid(&qid, d, 1);
switch(in->mode & 7) {
case MREAD:
if(iaccess(f, d, DREAD) && !writeallow)
goto badaccess;
fmod = FREAD;
break;
case MWRITE:
if((d->mode & DDIR) ||
(iaccess(f, d, DWRITE) && !writeallow))
goto badaccess;
if(ro) {
ou->err = Eronly;
goto out;
}
fmod = FWRITE;
break;
case MBOTH:
if((d->mode & DDIR) ||
(iaccess(f, d, DREAD) && !writeallow) ||
(iaccess(f, d, DWRITE) && !writeallow))
goto badaccess;
if(ro) {
ou->err = Eronly;
goto out;
}
fmod = FREAD+FWRITE;
break;
case MEXEC:
if((d->mode & DDIR) ||
iaccess(f, d, DEXEC))
goto badaccess;
fmod = FREAD;
break;
default:
ou->err = Emode;
goto out;
}
if(in->mode & MTRUNC) {
if((d->mode & DDIR) ||
(iaccess(f, d, DWRITE) && !writeallow))
goto badaccess;
if(ro) {
ou->err = Eronly;
goto out;
}
}
t = 0;
if(d->mode & DLOCK) {
t = tlocked(p, d);
if(t == 0) {
ou->err = Elocked;
goto out;
}
t->file = f;
}
if(in->mode & MRCLOSE)
fmod |= FREMOV;
f->open = fmod;
if(in->mode & MTRUNC)
if(!(d->mode & DAPND))
dtrunc(p, d);
f->tlock = t;
f->lastra = 0;
mkqid9p1(&ou->qid, &qid);
goto out;
badaccess:
ou->err = Eaccess;
f->open = 0;
out:
if(p)
putbuf(p);
if(f)
qunlock(f);
ou->fid = in->fid;
}
int cmain ()
{
define_symbol (sym_monitor, "monitor");
int i;
programme_identification = cons (sym_monitor, make_integer (2));
#if defined(have_sys_setsid)
sys_setsid();
#endif
initialise_kyu_script_commands ();
multiplex_add_kyu_callback (on_ipc_read, (void *)0);
global_environment = kyu_sx_default_environment ();
global_environment =
lx_environment_bind
(global_environment, sym_on_event,
lx_foreign_mu (sym_on_event, on_event));
global_environment =
lx_environment_bind
(global_environment, sym_power_on,
lx_foreign_mu (sym_power_on, power_on));
global_environment =
lx_environment_bind
(global_environment, sym_power_down,
lx_foreign_mu (sym_power_down, power_down));
global_environment =
lx_environment_bind
(global_environment, sym_power_reset,
lx_foreign_mu (sym_power_reset, power_reset));
global_environment =
lx_environment_bind
(global_environment, sym_ctrl_alt_del,
lx_foreign_mu (sym_ctrl_alt_del, ctrl_alt_del));
for (i = 1; curie_argv[i] != (char *)0; i++)
{
sexpr n = make_string (curie_argv[i]);
if (truep(filep(n)))
{
open_script_files++;
multiplex_add_sexpr
(sx_open_i (io_open_read (curie_argv[i])),
on_script_read, (void *)0);
}
else
{
native_system = make_symbol (curie_argv[i]);
}
}
kyu_sd_add_listener_stdio ();
while (multiplex() == mx_ok);
return 21;
}
void
f_wstat(Chan *cp, Oldfcall *in, Oldfcall *ou)
{
Iobuf *p, *p1;
Dentry *d, *d1, xd;
File *f;
int slot;
int32_t addr;
if(CHAT(cp)) {
print("c_wstat %d\n", cp->chan);
print(" fid = %d\n", in->fid);
}
p = 0;
p1 = 0;
d1 = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
if(isro(f->fs->dev) || (cp != cons.chan && writegroup && !ingroup(f->uid, writegroup))) {
ou->err = Eronly;
goto out;
}
/*
* first get parent
*/
if(f->wpath) {
p1 = getbuf(f->fs->dev, f->wpath->addr, Bread);
d1 = getdir(p1, f->wpath->slot);
if(!d1 || checktag(p1, Tdir, QPNONE) || !(d1->mode & DALLOC)) {
ou->err = Ephase;
goto out;
}
}
p = getbuf(f->fs->dev, f->addr, Bread);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if(ou->err = mkqidcmp(&f->qid, d))
goto out;
convM2D9p1(in->stat, &xd);
if(CHAT(cp)) {
print(" d.name = %s\n", xd.name);
print(" d.uid = %d\n", xd.uid);
print(" d.gid = %d\n", xd.gid);
print(" d.mode = %.4x\n", xd.mode);
}
/*
* if chown,
* must be god
*/
while(xd.uid != d->uid) {
if(wstatallow) /* set to allow chown during boot */
break;
ou->err = Enotu;
goto out;
}
/*
* if chgroup,
* must be either
* a) owner and in new group
* b) leader of both groups
*/
while(xd.gid != d->gid) {
if(wstatallow || writeallow) /* set to allow chgrp during boot */
break;
if(d->uid == f->uid && ingroup(f->uid, xd.gid))
break;
if(leadgroup(f->uid, xd.gid))
if(leadgroup(f->uid, d->gid))
break;
ou->err = Enotg;
goto out;
}
/*
* if rename,
* must have write permission in parent
*/
if(xd.name[0] == 0)
strncpy(xd.name, d->name, sizeof(xd.name));
while(strncmp(d->name, xd.name, sizeof(d->name)) != 0) {
if(checkname(xd.name)) {
ou->err = Ename;
goto out;
}
if(strcmp(xd.name, ".") == 0 || strcmp(xd.name, "..") == 0) {
ou->err = Ename;
goto out;
}
/*
* drop entry to prevent lock, then
* check that destination name is unique,
*/
putbuf(p);
for(addr=0;; addr++) {
p = dnodebuf(p1, d1, addr, 0);
if(!p)
break;
if(checktag(p, Tdir, d1->qid.path)) {
putbuf(p);
continue;
}
for(slot=0; slot<DIRPERBUF; slot++) {
d = getdir(p, slot);
if(!(d->mode & DALLOC))
continue;
if(!strncmp(xd.name, d->name, sizeof(xd.name))) {
ou->err = Eexist;
goto out;
}
}
putbuf(p);
}
/*
* reacquire entry
*/
p = getbuf(f->fs->dev, f->addr, Bread);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ephase;
goto out;
}
if(wstatallow || writeallow) /* set to allow rename during boot */
break;
if(!d1 || iaccess(f, d1, DWRITE)) {
ou->err = Eaccess;
goto out;
}
break;
}
/*
* if mode/time, either
* a) owner
* b) leader of either group
*/
while(d->mtime != xd.mtime ||
((d->mode^xd.mode) & (DAPND|DLOCK|0777))) {
if(wstatallow) /* set to allow chmod during boot */
break;
if(d->uid == f->uid)
break;
if(leadgroup(f->uid, xd.gid))
break;
if(leadgroup(f->uid, d->gid))
break;
ou->err = Enotu;
goto out;
}
d->mtime = xd.mtime;
d->uid = xd.uid;
d->gid = xd.gid;
d->mode = (xd.mode & (DAPND|DLOCK|0777)) | (d->mode & (DALLOC|DDIR));
strncpy(d->name, xd.name, sizeof(d->name));
if(wstatallow) {
p->flags |= Bmod;
if(xd.atime)
d->atime = xd.atime;
if(xd.mtime)
d->mtime = xd.mtime;
} else
accessdir(p, d, FWSTAT);
out:
if(p)
putbuf(p);
if(p1)
putbuf(p1);
if(f)
qunlock(f);
ou->fid = in->fid;
}
sexpr linkp(sexpr path)
{
return filep(path);
}
static void update_status_from_pid_files ( void )
{
sexpr c, a, n, pl, name, m, flags;
struct sexpr_io *io;
struct kyu_module *mod;
int online;
for (c = lx_environment_alist (mod_metadata); consp (c); c = cdr (c))
{
a = car (c);
name = car (a);
a = cdr (a);
online = 0;
if (consp ((pl = cdr (a))))
{
while (!online && (consp (pl)))
{
a = car (pl);
if (truep (filep (a)))
{
io = sx_open_i (io_open_read (sx_string (a)));
while (!eofp ((n = sx_read (io))))
{
if (integerp (n))
{
online = kyu_test_pid (sx_integer (n));
break;
}
}
sx_close_io (io);
}
pl = cdr (pl);
}
if (!nexp (m = lx_environment_lookup (my_modules, name)))
{
mod = (struct kyu_module *)m;
flags = mod->schedulerflags;
if (truep (sx_set_memberp (flags, sym_enabled))
!= online)
{
my_modules = lx_environment_unbind (my_modules, name);
if (online)
{
flags = sx_set_add (flags, sym_enabled);
}
else
{
flags = sx_set_remove (flags, sym_enabled);
}
m = kyu_make_module
(mod->name, mod->description, mod->provides,
mod->requires, mod->before, mod->after,
mod->conflicts, flags, mod->functions);
my_modules = lx_environment_bind (my_modules, name, m);
kyu_command (cons (sym_update, cons (native_system,
cons (m, sx_end_of_list))));
}
}
}
}
}
sexpr read_directory_w (const char *p, char **map, char *mapd)
{
sexpr r = sx_end_of_list;
unsigned int l = 0, s = 0, c = 0;
map[0] = mapd;
while (p[l])
{
if (p[l] == '/') {
mapd[l] = 0;
map[s] = (mapd + c);
s++;
c = l+1;
} else {
mapd[l] = p[l];
}
l++;
}
mapd[l] = 0;
map[s] = (mapd + c);
s++;
if (map[0][0] == 0)
{
r = cons (str_slashdot, r);
}
else
{
r = cons (str_dot, r);
}
for (c = 0; c < s; c++)
{
char regex = 0;
char *t = map[c];
sexpr nr = sx_end_of_list;
if (map[c][0] == 0) continue;
if (!((t[0] == '.') &&
((t[1] == 0) || ((t[1] == '.') && (t[2] == 0)))))
{
unsigned int cx;
for (cx = 0; (regex == 0) && t[cx]; cx++)
{
switch (t[cx])
{
case '\\':
case '?':
case '*':
case '+':
case '(':
case ')':
case '|':
case '[':
case '.':
regex = 1;
break;
default:
break;
}
}
}
if (regex)
{
sexpr g = rx_compile (map[c]);
sexpr c;
for (c = r; consp(c); c = cdr(c))
{
sexpr ca = car (c);
sexpr n = read_directory_rx (sx_string (ca), g);
sexpr e;
for (e = n; consp (e); e = cdr (e))
{
sexpr b = car (e);
nr = cons (sx_join (ca, str_slash, b), nr);
}
}
}
else
{
sexpr b = make_string (t);
sexpr c;
for (c = r; consp(c); c = cdr(c))
{
sexpr ca = car (c);
sexpr nf = sx_join (ca, str_slash, b);
if (truep(filep (nf)))
{
nr = cons (nf, nr);
}
}
}
r = nr;
}
return r;
}
static sexpr include (sexpr arguments, struct machine_state *st)
{
sexpr env = st->environment;
define_string (str_slash, "/");
sexpr e = env, to = car (arguments), t = sx_join (webroot, str_slash, to),
data = sx_end_of_list, lang, lcodes, te, tf,
type = sx_nonexistent, lcc;
struct sexpr_io *io;
int len = 0, i = 0;
const char *ts = sx_string (to);
char *tmp;
if (nexp (lx_environment_lookup (e, sym_original_name)))
{
e = lx_environment_bind (e, sym_original_name, car (arguments));
}
if (truep (filep (t)))
{
return cons (e, cons (cons (sym_verbatim,
cons (t, sx_end_of_list)), sx_end_of_list));
}
te = sx_join (to, str_dot_ksu, str_nil);
lcodes = (lx_environment_lookup (e, sym_language));
lcodes = sx_reverse (lcodes);
lcodes = cons (str_dot, lcodes);
lcodes = sx_reverse (lcodes);
lcc = lcodes;
while (consp (lcc))
{
lang = car (lcc);
t = sx_join (webroot, str_slash,
sx_join (lang, str_slash, te));
if (truep (filep (t)))
{
sexpr v = lx_environment_lookup (e, sym_Vary);
tf = lx_environment_lookup (e, sym_accept);
e = lx_environment_bind (e, sym_base_name, to);
if (!nexp (v))
{
e = lx_environment_unbind (e, sym_Vary);
e = lx_environment_bind
(e, sym_Vary,
sx_join (v, str_cAccept, sx_end_of_list));
}
else
{
e = lx_environment_bind
(e, sym_Vary, str_Accept);
}
if (!nexp (tf))
{
tf = get_acceptable_type (tf);
}
else
{
tf = default_type;
}
goto include;
}
lcc = cdr (lcc);
}
while (ts[len] != (char)0)
{
if (ts[len] == '.') i = len;
len++;
}
if (i > 0)
{
len = i;
tmp = aalloc (len + 1);
for (i = 0; i < len; i++)
{
tmp[i] = ts[i];
}
tmp[i] = 0;
i++;
te = make_string (tmp);
type = make_string (ts + i);
afree (i, tmp);
e = lx_environment_bind (e, sym_base_name, te);
e = lx_environment_bind (e, sym_extension, type);
te = sx_join (te, str_dot_ksu, str_nil);
while (consp (lcodes))
{
lang = car (lcodes);
t = sx_join (webroot, str_slash,
sx_join (lang, str_slash, te));
if (truep (filep (t)))
{
tf = lx_environment_lookup(mime_map, type);
include:
if (!nexp (tf))
{
struct transdata td =
{ lx_environment_join (lx_environment_join
(kho_environment, env), e), &data, 0 };
e = lx_environment_bind (e, sym_format, tf);
io = sx_open_i (io_open_read (sx_string (t)));
multiplex_add_sexpr (io, include_on_read, &td);
do
{
multiplex ();
}
while (td.done == 0);
return cons (e, sx_reverse (data));
}
else
{
return cons (e, cons (cons (sym_object,
cons (sym_verbatim, cons (t,
sx_end_of_list))), sx_end_of_list));
}
}
lcodes = cdr (lcodes);
}
}
if (!nexp (lx_environment_lookup (e, sym_error)))
{
return cons (sym_object,
cons (cons (sym_error, cons (sym_file_not_found,
sx_end_of_list)), sx_end_of_list));
}
else
{
return sx_nonexistent;
}
}
static int
lua_filep(lua_State *L)
{
lua_pushboolean(L, filep(L, 1));
return 1;
}
