Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
#include <mp.h>
#include <libsec.h>

static void
usage(void)
{
        fprint(2, "mntgen [-s srvname] [mtpt]\n");
        exits("usage");
}

ulong time0;

typedef struct Tab Tab;
struct Tab
{
        char *name;
        vlong qid;
        ulong time;
        int ref;
};

Tab *tab;
int ntab;
int mtab;

static Tab*
findtab(vlong path)
{
        int i;

        for(i=0; i<ntab; i++)
                if(tab[i].qid == path)
                        return &tab[i];
        return nil;
}

static vlong
hash(char *name)
{
        vlong digest[MD5dlen / sizeof(vlong) + 1];
        md5((uchar *)name, strlen(name), (uchar *)digest, nil);
        return digest[0] & ((1ULL<<48)-1);
}

static void
fsopen(Req *r)
{
        if(r->ifcall.mode != OREAD)
                respond(r, "permission denied");
        else
                respond(r, nil);
}

static int
dirgen(int i, Dir *d, void*)
{
        if(i >= ntab)
                return -1;
        memset(d, 0, sizeof *d);
        d->qid.type = QTDIR;
        d->uid = estrdup9p("sys");
        d->gid = estrdup9p("sys");
        d->mode = DMDIR|0555;
        d->length = 0;
        if(i == -1){
                d->name = estrdup9p("/");
                d->atime = d->mtime = time0;
        }else{
                d->qid.path = tab[i].qid;
                d->name = estrdup9p(tab[i].name);
                d->atime = d->mtime = tab[i].time;
        }
        return 0;
}

static void
fsread(Req *r)
{
        if(r->fid->qid.path == 0)
                dirread9p(r, dirgen, nil);
        else
                r->ofcall.count = 0;
        respond(r, nil);
}

static void
fsstat(Req *r)
{
        Tab *t;
        vlong qid;

        qid = r->fid->qid.path;
        if(qid == 0)
                dirgen(-1, &r->d, nil);
        else{
                if((t = findtab(qid)) == nil){
                        respond(r, "path not found (???)");
                        return;
                }
                dirgen(t-tab, &r->d, nil);
        }
        respond(r, nil);
}

static char*
fswalk1(Fid *fid, char *name, void*)
{
        int i;
        Tab *t;
        vlong h;

        if(fid->qid.path != 0){
                /* nothing in child directory */
                if(strcmp(name, "..") == 0){
                        if((t = findtab(fid->qid.path)) != nil)
                                t->ref--;
                        fid->qid.path = 0;
                        return nil;
                }
                return "path not found";
        }
        /* root */
        if(strcmp(name, "..") == 0)
                return nil;
        for(i=0; i<ntab; i++)
                if(strcmp(tab[i].name, name) == 0){
                        tab[i].ref++;
                        fid->qid.path = tab[i].qid;
                        return nil;
                }
        h = hash(name);
        if(findtab(h) != nil)
                return "hash collision";

        /* create it */
        if(ntab == mtab){
                if(mtab == 0)
                        mtab = 16;
                else
                        mtab *= 2;
                tab = erealloc9p(tab, sizeof(tab[0])*mtab);
        }
        tab[ntab].qid = h;
        fid->qid.path = tab[ntab].qid;
        tab[ntab].name = estrdup9p(name);
        tab[ntab].time = time(0);
        tab[ntab].ref = 1;
        ntab++;

        return nil;
}

static char*
fsclone(Fid *fid, Fid*, void*)
{
        Tab *t;

        if((t = findtab(fid->qid.path)) != nil)
                t->ref++;
        return nil;
}

static void
fswalk(Req *r)
{
        walkandclone(r, fswalk1, fsclone, nil);
}

static void
fsclunk(Fid *fid)
{
        Tab *t;
        vlong qid;

        qid = fid->qid.path;
        if(qid == 0)
                return;
        if((t = findtab(qid)) == nil){
                fprint(2, "warning: cannot find %llux\n", qid);
                return;
        }
        if(--t->ref == 0){
                free(t->name);
                tab[t-tab] = tab[--ntab];
        }else if(t->ref < 0)
                fprint(2, "warning: negative ref count for %s\n", t->name);
}

static void
fsattach(Req *r)
{
        char *spec;

        spec = r->ifcall.aname;
        if(spec && spec[0]){
                respond(r, "invalid attach specifier");
                return;
        }
        
        r->ofcall.qid = (Qid){0, 0, QTDIR};
        r->fid->qid = r->ofcall.qid;
        respond(r, nil);
}

Srv fs=
{
.attach=        fsattach,
.open=  fsopen,
.read=  fsread,
.stat=  fsstat,
.walk=  fswalk,
.destroyfid=    fsclunk
};

void
main(int argc, char **argv)
{
        char *service;

        time0 = time(0);
        service = nil;
        ARGBEGIN{
        case 'D':
                chatty9p++;
                break;
        case 's':
                service = EARGF(usage());
                break;
        default:
                usage();
        }ARGEND

        if(argc > 1)
                usage();
        postmountsrv(&fs, service, argc ? argv[0] : "/n", MAFTER);
        exits(nil);
}