Subversion Repositories planix.SVN

#include        "u.h"
#include        "../port/lib.h"
#include        "mem.h"
#include        "dat.h"
#include        "fns.h"
#include        "../port/error.h"


typedef struct Srv Srv;
struct Srv
{
        char    *name;
        char    *owner;
        ulong   perm;
        Chan    *chan;
        Srv     *link;
        ulong   path;
};

static QLock    srvlk;
static Srv      *srv;
static int      qidpath;

static int
srvgen(Chan *c, char*, Dirtab*, int, int s, Dir *dp)
{
        Srv *sp;
        Qid q;

        if(s == DEVDOTDOT){
                devdir(c, c->qid, "#s", 0, eve, 0555, dp);
                return 1;
        }

        qlock(&srvlk);
        for(sp = srv; sp && s; sp = sp->link)
                s--;

        if(sp == 0) {
                qunlock(&srvlk);
                return -1;
        }

        mkqid(&q, sp->path, 0, QTFILE);
        /* make sure name string continues to exist after we release lock */
        kstrcpy(up->genbuf, sp->name, sizeof up->genbuf);
        devdir(c, q, up->genbuf, 0, sp->owner, sp->perm, dp);
        qunlock(&srvlk);
        return 1;
}

static void
srvinit(void)
{
        qidpath = 1;
}

static Chan*
srvattach(char *spec)
{
        return devattach('s', spec);
}

static Walkqid*
srvwalk(Chan *c, Chan *nc, char **name, int nname)
{
        return devwalk(c, nc, name, nname, 0, 0, srvgen);
}

static Srv*
srvlookup(char *name, ulong qidpath)
{
        Srv *sp;
        for(sp = srv; sp; sp = sp->link)
                if(sp->path == qidpath || (name && strcmp(sp->name, name) == 0))
                        return sp;
        return nil;
}

static int
srvstat(Chan *c, uchar *db, int n)
{
        return devstat(c, db, n, 0, 0, srvgen);
}

char*
srvname(Chan *c)
{
        int size;
        Srv *sp;
        char *s;

        for(sp = srv; sp; sp = sp->link)
                if(sp->chan == c){
                        size = 3+strlen(sp->name)+1;
                        s = smalloc(size);
                        snprint(s, size, "#s/%s", sp->name);
                        return s;
                }
        return nil;
}

static Chan*
srvopen(Chan *c, int omode)
{
        Srv *sp;

        if(c->qid.type == QTDIR){
                if(omode & ORCLOSE)
                        error(Eperm);
                if(omode != OREAD)
                        error(Eisdir);
                c->mode = omode;
                c->flag |= COPEN;
                c->offset = 0;
                return c;
        }
        qlock(&srvlk);
        if(waserror()){
                qunlock(&srvlk);
                nexterror();
        }

        sp = srvlookup(nil, c->qid.path);
        if(sp == 0 || sp->chan == 0)
                error(Eshutdown);

        if(omode&OTRUNC)
                error("srv file already exists");
        if(openmode(omode)!=sp->chan->mode && sp->chan->mode!=ORDWR)
                error(Eperm);
        devpermcheck(sp->owner, sp->perm, omode);

        cclose(c);
        incref(sp->chan);
        qunlock(&srvlk);
        poperror();
        return sp->chan;
}

static void
srvcreate(Chan *c, char *name, int omode, ulong perm)
{
        char *sname;
        Srv *sp;

        if(openmode(omode) != OWRITE)
                error(Eperm);

        if(omode & OCEXEC)      /* can't happen */
                panic("someone broke namec");

        sp = smalloc(sizeof *sp);
        sname = smalloc(strlen(name)+1);

        qlock(&srvlk);
        if(waserror()){
                free(sp);
                free(sname);
                qunlock(&srvlk);
                nexterror();
        }
        if(sp == nil || sname == nil)
                error(Enomem);
        if(srvlookup(name, -1))
                error(Eexist);

        sp->path = qidpath++;
        sp->link = srv;
        strcpy(sname, name);
        sp->name = sname;
        c->qid.type = QTFILE;
        c->qid.path = sp->path;
        srv = sp;
        qunlock(&srvlk);
        poperror();

        kstrdup(&sp->owner, up->user);
        sp->perm = perm&0777;

        c->flag |= COPEN;
        c->mode = OWRITE;
}

static void
srvremove(Chan *c)
{
        Srv *sp, **l;

        if(c->qid.type == QTDIR)
                error(Eperm);

        qlock(&srvlk);
        if(waserror()){
                qunlock(&srvlk);
                nexterror();
        }
        l = &srv;
        for(sp = *l; sp; sp = sp->link) {
                if(sp->path == c->qid.path)
                        break;

                l = &sp->link;
        }
        if(sp == 0)
                error(Enonexist);

        /*
         * Only eve can remove system services.
         * No one can remove #s/boot.
         */
        if(strcmp(sp->owner, eve) == 0 && !iseve())
                error(Eperm);
        if(strcmp(sp->name, "boot") == 0)
                error(Eperm);

        /*
         * No removing personal services.
         */
        if((sp->perm&7) != 7 && strcmp(sp->owner, up->user) && !iseve())
                error(Eperm);

        *l = sp->link;
        qunlock(&srvlk);
        poperror();

        if(sp->chan)
                cclose(sp->chan);
        free(sp->owner);
        free(sp->name);
        free(sp);
}

static int
srvwstat(Chan *c, uchar *dp, int n)
{
        char *strs;
        Dir d;
        Srv *sp;

        if(c->qid.type & QTDIR)
                error(Eperm);

        strs = nil;
        qlock(&srvlk);
        if(waserror()){
                qunlock(&srvlk);
                free(strs);
                nexterror();
        }

        sp = srvlookup(nil, c->qid.path);
        if(sp == 0)
                error(Enonexist);

        if(strcmp(sp->owner, up->user) != 0 && !iseve())
                error(Eperm);

        strs = smalloc(n);
        n = convM2D(dp, n, &d, strs);
        if(n == 0)
                error(Eshortstat);
        if(d.mode != ~0UL)
                sp->perm = d.mode & 0777;
        if(d.uid && *d.uid)
                kstrdup(&sp->owner, d.uid);
        if(d.name && *d.name && strcmp(sp->name, d.name) != 0) {
                if(strchr(d.name, '/') != nil)
                        error(Ebadchar);
                kstrdup(&sp->name, d.name);
        }
        qunlock(&srvlk);
        free(strs);
        poperror();
        return n;
}

static void
srvclose(Chan *c)
{
        /*
         * in theory we need to override any changes in removability
         * since open, but since all that's checked is the owner,
         * which is immutable, all is well.
         */
        if(c->flag & CRCLOSE){
                if(waserror())
                        return;
                srvremove(c);
                poperror();
        }
}

static long
srvread(Chan *c, void *va, long n, vlong)
{
        isdir(c);
        return devdirread(c, va, n, 0, 0, srvgen);
}

static long
srvwrite(Chan *c, void *va, long n, vlong)
{
        Srv *sp;
        Chan *c1;
        int fd;
        char buf[32];

        if(n >= sizeof buf)
                error(Egreg);
        memmove(buf, va, n);    /* so we can NUL-terminate */
        buf[n] = 0;
        fd = strtoul(buf, 0, 0);

        c1 = fdtochan(fd, -1, 0, 1);    /* error check and inc ref */

        qlock(&srvlk);
        if(waserror()) {
                qunlock(&srvlk);
                cclose(c1);
                nexterror();
        }
        if(c1->flag & (CCEXEC|CRCLOSE))
                error("posted fd has remove-on-close or close-on-exec");
        if(c1->qid.type & QTAUTH)
                error("cannot post auth file in srv");
        sp = srvlookup(nil, c->qid.path);
        if(sp == 0)
                error(Enonexist);

        if(sp->chan)
                error(Ebadusefd);

        sp->chan = c1;
        qunlock(&srvlk);
        poperror();
        return n;
}

Dev srvdevtab = {
        's',
        "srv",

        devreset,
        srvinit,        
        devshutdown,
        srvattach,
        srvwalk,
        srvstat,
        srvopen,
        srvcreate,
        srvclose,
        srvread,
        devbread,
        srvwrite,
        devbwrite,
        srvremove,
        srvwstat,
};