#include "all.h"
#include "9p1.h"
extern Nvrsafe nvr;
typedef struct {
uchar chal[CHALLEN]; /* locally generated challenge */
uchar rchal[CHALLEN]; /* remotely generated challenge */
Lock idlock;
ulong idoffset; /* offset of id vector */
ulong idvec; /* vector of acceptable id's */
} Authinfo;
static void
f_nop(Chan *cp, Fcall*, Fcall*)
{
if(CHAT(cp))
print("c_nop %d\n", cp->chan);
}
static void
f_flush(Chan *cp, Fcall*, Fcall*)
{
if(CHAT(cp))
print("c_flush %d\n", cp->chan);
runlock(&cp->reflock);
wlock(&cp->reflock);
wunlock(&cp->reflock);
rlock(&cp->reflock);
}
/*
* create a challenge for a fid space
*/
static void
mkchallenge(Authinfo *aip)
{
int i;
srand((uintptr)aip + time(nil));
for(i = 0; i < CHALLEN; i++)
aip->chal[i] = nrand(256);
aip->idoffset = 0;
aip->idvec = 0;
}
static void
f_session(Chan *cp, Fcall *in, Fcall *ou)
{
Authinfo *aip;
aip = (Authinfo*)cp->authinfo;
if(CHAT(cp))
print("c_session %d\n", cp->chan);
memmove(aip->rchal, in->chal, sizeof(aip->rchal));
mkchallenge(aip);
memmove(ou->chal, aip->chal, sizeof(ou->chal));
if(noauth || wstatallow)
memset(ou->authid, 0, sizeof(ou->authid));
else
memmove(ou->authid, nvr.authid, sizeof(ou->authid));
sprint(ou->authdom, "%s.%s", service, nvr.authdom);
fileinit(cp);
}
/*
* match a challenge from an attach
*/
static int
authorize(Chan *cp, Fcall *in, Fcall *ou)
{
Ticket t;
Authenticator a;
int x;
ulong bit;
Authinfo *aip;
if(noauth || wstatallow) /* set to allow entry during boot */
return 1;
if(strcmp(in->uname, "none") == 0)
return 1;
if(in->type == Toattach)
return 0;
/* decrypt and unpack ticket */
convM2T9p1(in->ticket, &t, nvr.machkey);
if(t.num != AuthTs){
print("9p1: bad AuthTs num\n");
return 0;
}
/* decrypt and unpack authenticator */
convM2A9p1(in->auth, &a, t.key);
if(a.num != AuthAc){
print("9p1: bad AuthAc num\n");
return 0;
}
/* challenges must match */
aip = (Authinfo*)cp->authinfo;
if(memcmp(a.chal, aip->chal, sizeof(a.chal)) != 0){
print("9p1: bad challenge\n");
return 0;
}
/*
* the id must be in a valid range. the range is specified by a
* lower bound (idoffset) and a bit vector (idvec) where a
* bit set to 1 means unusable
*/
lock(&aip->idlock);
x = a.id - aip->idoffset;
bit = 1<<x;
if(x < 0 || x > 31 || (bit&aip->idvec)){
unlock(&aip->idlock);
print("9p1: id out of range: idoff %ld idvec %lux id %ld\n",
aip->idoffset, aip->idvec, a.id);
return 0;
}
aip->idvec |= bit;
/* normalize the vector */
while(aip->idvec&0xffff0001){
aip->idvec >>= 1;
aip->idoffset++;
}
unlock(&aip->idlock);
/* ticket name and attach name must match */
if(memcmp(in->uname, t.cuid, sizeof(in->uname)) != 0){
print("9p1: names don't match\n");
return 0;
}
/* copy translated name into input record */
memmove(in->uname, t.suid, sizeof(in->uname));
/* craft a reply */
a.num = AuthAs;
memmove(a.chal, aip->rchal, CHALLEN);
convA2M9p1(&a, ou->rauth, t.key);
return 1;
}
/*
* buggery to give false qid for
* the top 2 levels of the dump fs
*/
void
mkqid(Qid* qid, Dentry *d, int buggery)
{
int c;
if(buggery && d->qid.path == (QPDIR|QPROOT)){
c = d->name[0];
if(isascii(c) && isdigit(c)){
qid->path = 3;
qid->vers = d->qid.version;
qid->type = QTDIR;
c = (c-'0')*10 + (d->name[1]-'0');
if(c >= 1 && c <= 12)
qid->path = 4;
return;
}
}
mkqid9p2(qid, &d->qid, d->mode);
}
int
mkqidcmp(Qid* qid, Dentry *d)
{
Qid tmp;
mkqid(&tmp, d, 1);
if(qid->path == tmp.path && qid->type == tmp.type)
return 0;
return Eqid;
}
static void
f_attach(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p;
Dentry *d;
File *f;
int u;
Filsys *fs;
Off raddr;
if(CHAT(cp)) {
print("c_attach %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
print("\tuid = %s\n", in->uname);
print("\targ = %s\n", in->aname);
}
ou->qid = QID9P1(0,0);
ou->fid = in->fid;
if(!in->aname[0]) /* default */
strncpy(in->aname, "main", 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(noattach && strcmp(in->uname, "none")) {
ou->err = Enoattach;
goto out;
}
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;
}
}
f->uid = u;
fs = fsstr(in->aname);
if(fs == 0) {
ou->err = Ebadspc;
goto out;
}
raddr = getraddr(fs->dev);
p = getbuf(fs->dev, raddr, Brd);
d = getdir(p, 0);
if(!d || checktag(p, Tdir, QPROOT) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
if (iaccess(f, d, DEXEC) ||
f->uid == 0 && fs->dev->type == Devro) {
/*
* 'none' not allowed on dump
*/
ou->err = Eaccess;
goto out;
}
accessdir(p, d, FREAD, f->uid);
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);
strncpy(cp->whoname, in->uname, sizeof(cp->whoname));
cp->whotime = time(nil);
if(cons.flags & attachflag)
print("9p1: attach %s %T to \"%s\" C%d\n",
cp->whoname, cp->whotime, fs->name, cp->chan);
out:
if((cons.flags & attachflag) && ou->err)
print("9p1: attach %s %T SUCK EGGS --- %s\n",
in->uname, time(nil), errstr9p[ou->err]);
if(p)
putbuf(p);
if(f) {
qunlock(f);
if(ou->err)
freefp(f);
}
}
static void
f_clone(Chan *cp, Fcall *in, Fcall *ou)
{
File *f1, *f2;
Wpath *p;
int fid, fid1;
if(CHAT(cp)) {
print("c_clone %d\n", cp->chan);
print("\told fid = %d\n", in->fid);
print("\tnew 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);
lock(&wpathlock);
f2->wpath = f1->wpath;
for(p = f2->wpath; p; p = p->up)
p->refs++;
unlock(&wpathlock);
out:
ou->fid = fid;
if(f1)
qunlock(f1);
if(f2) {
qunlock(f2);
if(ou->err)
freefp(f2);
}
}
static void
f_walk(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p, *p1;
Dentry *d, *d1;
File *f;
Wpath *w;
int slot;
Off addr, qpath;
if(CHAT(cp)) {
print("c_walk %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
print("\tname = %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, Brd);
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, f->uid);
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, Brd);
d1 = getdir(p1, slot);
if(!d1 || checktag(p1, Tdir, QPNONE) || !(d1->mode & DALLOC)) {
if(p1)
putbuf(p1);
ou->err = Ephase;
goto out;
}
lock(&wpathlock);
f->wpath->refs--;
f->wpath = f->wpath->up;
unlock(&wpathlock);
goto found;
}
for(addr=0;; addr++) {
if(p == 0) {
p = getbuf(f->fs->dev, f->addr, Brd);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
}
qpath = d->qid.path;
p1 = dnodebuf1(p, d, addr, 0, f->uid);
p = 0;
if(!p1 || checktag(p1, Tdir, qpath) ) {
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)) != 0)
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);
}
static void
f_open(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p;
Dentry *d;
File *f;
Tlock *t;
Qid qid;
int ro, fmod, wok;
if(CHAT(cp)) {
print("c_open %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
print("\tmode = %o\n", in->mode);
}
wok = 0;
if(cp == cons.chan || writeallow)
wok = 1;
p = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
/*
* if remove on close, check access here
*/
ro = f->fs->dev->type == Devro;
if(in->mode & ORCLOSE) {
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, Brd);
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, Brd);
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 OREAD:
if(iaccess(f, d, DREAD) && !wok)
goto badaccess;
fmod = FREAD;
break;
case OWRITE:
if((d->mode & DDIR) ||
(iaccess(f, d, DWRITE) && !wok))
goto badaccess;
if(ro) {
ou->err = Eronly;
goto out;
}
fmod = FWRITE;
break;
case ORDWR:
if((d->mode & DDIR) ||
(iaccess(f, d, DREAD) && !wok) ||
(iaccess(f, d, DWRITE) && !wok))
goto badaccess;
if(ro) {
ou->err = Eronly;
goto out;
}
fmod = FREAD+FWRITE;
break;
case OEXEC:
if((d->mode & DDIR) ||
(iaccess(f, d, DEXEC) && !wok))
goto badaccess;
fmod = FREAD;
break;
default:
ou->err = Emode;
goto out;
}
if(in->mode & OTRUNC) {
if((d->mode & DDIR) ||
(iaccess(f, d, DWRITE) && !wok))
goto badaccess;
if(ro) {
ou->err = Eronly;
goto out;
}
}
t = 0;
if(d->mode & DLOCK) {
t = tlocked(p, d);
if(t == nil) {
ou->err = Elocked;
goto out;
}
}
if(in->mode & ORCLOSE)
fmod |= FREMOV;
f->open = fmod;
if(in->mode & OTRUNC)
if(!(d->mode & DAPND)) {
dtrunc(p, d, f->uid);
qid.vers = d->qid.version;
}
f->tlock = t;
if(t)
t->file = f;
f->lastra = 1;
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;
}
static void
f_create(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p, *p1;
Dentry *d, *d1;
File *f;
int slot, slot1, fmod, wok;
Off addr, addr1, path;
Qid qid;
Tlock *t;
Wpath *w;
if(CHAT(cp)) {
print("c_create %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
print("\tname = %s\n", in->name);
print("\tperm = %lx+%lo\n", (in->perm>>28)&0xf,
in->perm&0777);
print("\tmode = %o\n", in->mode);
}
wok = 0;
if(cp == cons.chan || writeallow)
wok = 1;
p = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
if(f->fs->dev->type == Devro) {
ou->err = Eronly;
goto out;
}
p = getbuf(f->fs->dev, f->addr, Brd);
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(iaccess(f, d, DWRITE) && !wok) {
ou->err = Eaccess;
goto out;
}
accessdir(p, d, FREAD, f->uid);
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, f->uid);
if(!p1) {
if(addr1)
break;
p1 = dnodebuf(p, d, addr, Tdir, f->uid);
}
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 OEXEC:
case OREAD: /* seems only useful to make directories */
fmod = FREAD;
break;
case OWRITE:
fmod = FWRITE;
break;
case ORDWR:
fmod = FREAD+FWRITE;
break;
default:
ou->err = Emode;
goto out;
}
if(in->perm & PDIR)
if((in->mode & OTRUNC) || (in->perm & PAPND) || (fmod & FWRITE))
goto badaccess;
/*
* do it
*/
path = qidpathgen(f->fs->dev);
p1 = getbuf(f->fs->dev, addr1, Brd|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));
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);
/* if nil, out of tlock structures */
}
accessdir(p1, d1, FWRITE, f->uid);
mkqid(&qid, d1, 0);
putbuf(p1);
accessdir(p, d, FWRITE, f->uid);
/*
* 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;
if(t)
t->file = f;
f->lastra = 1;
if(in->mode & ORCLOSE)
fmod |= FREMOV;
f->open = fmod;
f->addr = addr1;
f->slot = slot1;
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;
}
static void
f_read(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p, *p1;
File *f;
Dentry *d, *d1;
Tlock *t;
Off addr, offset;
Timet tim;
int nread, count, n, o, slot;
if(CHAT(cp)) {
print("c_read %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
print("\toffset = %lld\n", (Wideoff)in->offset);
print("\tcount = %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, Brd);
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 = toytime();
if(t->time < tim || t->file != f) {
ou->err = Ebroken;
goto out;
}
/* renew the lock */
t->time = tim + TLOCK;
}
accessdir(p, d, FREAD, f->uid);
if(d->mode & DDIR) {
addr = 0;
goto dread;
}
/* XXXX terrible hack to get at raw data XXXX */
if(rawreadok && strncmp(d->name, "--raw--", 7) == 0) {
Device *dev;
Devsize boff, bsize;
dev = p->dev;
putbuf(p);
p = 0;
boff = number(d->name + 7, 0, 10) * 100000;
if(boff < 0)
boff = 0;
if(boff > devsize(dev))
boff = devsize(dev);
bsize = devsize(dev) - boff;
if(offset+count >= 100000*RBUFSIZE)
count = 100000*RBUFSIZE - offset;
if((offset+count)/RBUFSIZE >= bsize)
/* will not overflow */
count = bsize*RBUFSIZE - offset;
while(count > 0) {
addr = offset / RBUFSIZE;
addr += boff;
o = offset % RBUFSIZE;
n = RBUFSIZE - o;
if(n > count)
n = count;
p1 = getbuf(dev, addr, Brd);
if(p1) {
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;
}
if(offset+count > d->size)
count = d->size - offset;
while(count > 0) {
if(p == 0) {
p = getbuf(f->fs->dev, f->addr, Brd);
d = getdir(p, f->slot);
if(!d || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
}
addr = offset / BUFSIZE;
f->lastra = dbufread(p, d, addr, f->lastra, f->uid);
o = offset % BUFSIZE;
n = BUFSIZE - o;
if(n > count)
n = count;
p1 = dnodebuf1(p, d, addr, 0, f->uid);
p = 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:
for (;;) {
if(p == 0) {
p = getbuf(f->fs->dev, f->addr, Brd);
d = getdir(p, f->slot);
if(!d || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
}
p1 = dnodebuf1(p, d, addr, 0, f->uid);
p = 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("9p1: dirread convD2M1990\n");
nread += n;
count -= n;
}
putbuf(p1);
addr++;
}
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("\tnread = %d\n", nread);
}
static void
f_write(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p, *p1;
Dentry *d;
File *f;
Tlock *t;
Off offset, addr, qpath;
Timet tim;
int count, nwrite, o, n;
if(CHAT(cp)) {
print("c_write %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
print("\toffset = %lld\n", (Wideoff)in->offset);
print("\tcount = %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(f->fs->dev->type == Devro) {
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, Brd|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 = toytime();
if(t->time < tim || t->file != f) {
ou->err = Ebroken;
goto out;
}
/* renew the lock */
t->time = tim + TLOCK;
}
accessdir(p, d, FWRITE, f->uid);
if(d->mode & DAPND)
offset = d->size;
if(offset+count > d->size)
d->size = offset+count;
while(count > 0) {
if(p == 0) {
p = getbuf(f->fs->dev, f->addr, Brd|Bmod);
d = getdir(p, f->slot);
if(!d || !(d->mode & DALLOC)) {
ou->err = Ealloc;
goto out;
}
}
addr = offset / BUFSIZE;
o = offset % BUFSIZE;
n = BUFSIZE - o;
if(n > count)
n = count;
qpath = d->qid.path;
p1 = dnodebuf1(p, d, addr, Tfile, f->uid);
p = 0;
if(p1 == 0) {
ou->err = Efull;
goto out;
}
if(checktag(p1, Tfile, qpath)) {
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("\tnwrite = %d\n", nwrite);
out:
if(p)
putbuf(p);
if(f)
qunlock(f);
ou->fid = in->fid;
ou->count = nwrite;
}
int
doremove(File *f, int wok)
{
Iobuf *p, *p1;
Dentry *d, *d1;
Off addr;
int slot, err;
p = 0;
p1 = 0;
if(f->fs->dev->type == Devro) {
err = Eronly;
goto out;
}
/*
* check on parent directory of file to be deleted
*/
if(f->wpath == 0 || f->wpath->addr == f->addr) {
err = Ephase;
goto out;
}
p1 = getbuf(f->fs->dev, f->wpath->addr, Brd);
d1 = getdir(p1, f->wpath->slot);
if(!d1 || checktag(p1, Tdir, QPNONE) || !(d1->mode & DALLOC)) {
err = Ephase;
goto out;
}
if(iaccess(f, d1, DWRITE) && !wok) {
err = Eaccess;
goto out;
}
accessdir(p1, d1, FWRITE, f->uid);
putbuf(p1);
p1 = 0;
/*
* check on file to be deleted
*/
p = getbuf(f->fs->dev, f->addr, Brd);
d = getdir(p, f->slot);
if(!d || checktag(p, Tdir, QPNONE) || !(d->mode & DALLOC)) {
err = Ealloc;
goto out;
}
if(err = mkqidcmp(&f->qid, d))
goto out;
/*
* if deleting a directory, make sure it is empty
*/
if((d->mode & DDIR))
for(addr=0;; addr++) {
p1 = dnodebuf(p, d, addr, 0, f->uid);
if(!p1)
break;
if(checktag(p1, Tdir, d->qid.path)) {
err = Ephase;
goto out;
}
for(slot=0; slot<DIRPERBUF; slot++) {
d1 = getdir(p1, slot);
if(!(d1->mode & DALLOC))
continue;
err = Eempty;
goto out;
}
putbuf(p1);
}
/*
* do it
*/
dtrunc(p, d, f->uid);
memset(d, 0, sizeof(Dentry));
settag(p, Tdir, QPNONE);
out:
if(p1)
putbuf(p1);
if(p)
putbuf(p);
return err;
}
static int
doclunk(File* f, int remove, int wok)
{
Tlock *t;
int err;
err = 0;
if(t = f->tlock) {
if(t->file == f)
t->time = 0; /* free the lock */
f->tlock = 0;
}
if(remove)
err = doremove(f, wok);
f->open = 0;
freewp(f->wpath);
freefp(f);
return err;
}
static void
f_clunk(Chan *cp, Fcall *in, Fcall *ou)
{
File *f;
if(CHAT(cp)) {
print("c_clunk %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
}
f = filep(cp, in->fid, 0);
if(!f)
ou->err = Efid;
else {
doclunk(f, f->open & FREMOV, 0);
qunlock(f);
}
ou->fid = in->fid;
}
static void
f_remove(Chan *cp, Fcall *in, Fcall *ou)
{
File *f;
if(CHAT(cp)) {
print("c_remove %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
}
f = filep(cp, in->fid, 0);
if(!f)
ou->err = Efid;
else {
ou->err = doclunk(f, 1, cp==cons.chan);
qunlock(f);
}
ou->fid = in->fid;
}
static void
f_stat(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p;
Dentry *d;
File *f;
if(CHAT(cp)) {
print("c_stat %d\n", cp->chan);
print("\tfid = %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, Brd);
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(nil);
if(convD2M9p1(d, ou->stat) != DIRREC)
print("9p1: stat convD2M\n");
out:
if(p)
putbuf(p);
if(f)
qunlock(f);
ou->fid = in->fid;
}
static void
f_wstat(Chan *cp, Fcall *in, Fcall *ou)
{
Iobuf *p, *p1;
Dentry *d, *d1, xd;
File *f;
int slot;
Off addr;
if(CHAT(cp)) {
print("c_wstat %d\n", cp->chan);
print("\tfid = %d\n", in->fid);
}
p = 0;
p1 = 0;
d1 = 0;
f = filep(cp, in->fid, 0);
if(!f) {
ou->err = Efid;
goto out;
}
if(f->fs->dev->type == Devro) {
ou->err = Eronly;
goto out;
}
/*
* first get parent
*/
if(f->wpath) {
p1 = getbuf(f->fs->dev, f->wpath->addr, Brd);
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, Brd);
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("\td.name = %s\n", xd.name);
print("\td.uid = %d\n", xd.uid);
print("\td.gid = %d\n", xd.gid);
print("\td.mode = %o\n", xd.mode);
}
/*
* if user none,
* cant do anything
*/
if(f->uid == 0) {
ou->err = Eaccess;
goto out;
}
/*
* if chown,
* must be god
*/
if(xd.uid != d->uid && !wstatallow) { /* set to allow chown during boot */
ou->err = Ewstatu;
goto out;
}
/*
* if chgroup,
* must be either
* a) owner and in new group
* b) leader of both groups
*/
if (xd.gid != d->gid &&
(!wstatallow && !writeallow && /* set to allow chgrp during boot */
(d->uid != f->uid || !ingroup(f->uid, xd.gid)) &&
(!leadgroup(f->uid, xd.gid) || !leadgroup(f->uid, d->gid)))) {
ou->err = Ewstatg;
goto out;
}
/*
* if rename,
* must have write permission in parent
*/
if (strncmp(d->name, xd.name, sizeof(d->name)) != 0) {
if (checkname(xd.name) || !d1 ||
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, f->uid);
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, Brd);
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 */
(!d1 || iaccess(f, d1, DWRITE))) {
ou->err = Eaccess;
goto out;
}
}
/*
* if mode/time, either
* a) owner
* b) leader of either group
*/
if (d->mtime != xd.mtime ||
((d->mode^xd.mode) & (DAPND|DLOCK|0777)))
if (!wstatallow && /* set to allow chmod during boot */
d->uid != f->uid &&
!leadgroup(f->uid, xd.gid) &&
!leadgroup(f->uid, d->gid)) {
ou->err = Ewstatu;
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));
accessdir(p, d, FREAD, f->uid);
out:
if(p)
putbuf(p);
if(p1)
putbuf(p1);
if(f)
qunlock(f);
ou->fid = in->fid;
}
static void
f_clwalk(Chan *cp, Fcall *in, Fcall *ou)
{
int er, fid;
if(CHAT(cp))
print("c_clwalk macro\n");
f_clone(cp, in, ou); /* sets tag, fid */
if(ou->err)
return;
fid = in->fid;
in->fid = in->newfid;
f_walk(cp, in, ou); /* sets tag, fid, qid */
er = ou->err;
if(er == Eentry) {
/*
* if error is "no entry"
* return non error and fid
*/
ou->err = 0;
f_clunk(cp, in, ou); /* sets tag, fid */
ou->err = 0;
ou->fid = fid;
if(CHAT(cp))
print("\terror: %s\n", errstr9p[er]);
} else if(er) {
/*
* if any other error
* return an error
*/
ou->err = 0;
f_clunk(cp, in, ou); /* sets tag, fid */
ou->err = er;
}
/*
* non error
* return newfid
*/
}
void (*call9p1[MAXSYSCALL])(Chan*, Fcall*, Fcall*) =
{
[Tnop] f_nop,
[Tosession] f_session,
[Tsession] f_session,
[Tflush] f_flush,
[Toattach] f_attach,
[Tattach] f_attach,
[Tclone] f_clone,
[Twalk] f_walk,
[Topen] f_open,
[Tcreate] f_create,
[Tread] f_read,
[Twrite] f_write,
[Tclunk] f_clunk,
[Tremove] f_remove,
[Tstat] f_stat,
[Twstat] f_wstat,
[Tclwalk] f_clwalk,
};
int
error9p1(Chan* cp, Msgbuf* mb)
{
Msgbuf *mb1;
print("type=%d count=%d\n", mb->data[0], mb->count);
print(" %.2x %.2x %.2x %.2x\n",
mb->data[1]&0xff, mb->data[2]&0xff,
mb->data[3]&0xff, mb->data[4]&0xff);
print(" %.2x %.2x %.2x %.2x\n",
mb->data[5]&0xff, mb->data[6]&0xff,
mb->data[7]&0xff, mb->data[8]&0xff);
print(" %.2x %.2x %.2x %.2x\n",
mb->data[9]&0xff, mb->data[10]&0xff,
mb->data[11]&0xff, mb->data[12]&0xff);
mb1 = mballoc(3, cp, Mbreply4);
mb1->data[0] = Rnop; /* your nop was ok */
mb1->data[1] = ~0;
mb1->data[2] = ~0;
mb1->count = 3;
mb1->param = mb->param;
fs_send(cp->reply, mb1);
return 1;
}
int
serve9p1(Msgbuf* mb)
{
int t, n;
Chan *cp;
Msgbuf *mb1;
Fcall fi, fo;
assert(mb != nil);
cp = mb->chan;
assert(mb->data != nil);
if(convM2S9p1(mb->data, &fi, mb->count) == 0){
assert(cp != nil);
if(cp->protocol == nil)
return 0;
print("9p1: bad M2S conversion\n");
return error9p1(cp, mb);
}
t = fi.type;
if(t < 0 || t >= MAXSYSCALL || (t&1) || !call9p1[t]) {
print("9p1: bad message type\n");
return error9p1(cp, mb);
}
/*
* allocate reply message
*/
if(t == Tread) {
mb1 = mballoc(MAXMSG+MAXDAT, cp, Mbreply2);
fo.data = (char*)(mb1->data + 8);
} else
mb1 = mballoc(MAXMSG, cp, Mbreply3);
/*
* call the file system
*/
assert(cp != nil);
fo.err = 0;
(*call9p1[t])(cp, &fi, &fo);
fo.type = t+1;
fo.tag = fi.tag;
if(fo.err) {
if(cons.flags&errorflag)
print("\ttype %d: error: %s\n", t, errstr9p[fo.err]);
if(CHAT(cp))
print("\terror: %s\n", errstr9p[fo.err]);
fo.type = Rerror;
strncpy(fo.ename, errstr9p[fo.err], sizeof(fo.ename));
}
n = convS2M9p1(&fo, mb1->data);
if(n == 0) {
print("9p1: bad S2M conversion\n");
mbfree(mb1);
return error9p1(cp, mb);
}
mb1->count = n;
mb1->param = mb->param;
fs_send(cp->reply, mb1);
return 1;
}
|
