Subversion Repositories planix.SVN

/*
 * archfs - mount mkfs style archives
 */

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>

Tree *archtree;
Biobuf *b;
int verbose;

typedef struct Ahdr Ahdr;
struct Ahdr {
        char *name;
        Dir;
};

typedef struct Arch Arch;
struct Arch {
        vlong off;
        vlong length;
};

static void*
emalloc(long sz)
{
        void *v;

        v = malloc(sz);
        if(v == nil)
                sysfatal("malloc %lud fails", sz);
        memset(v, 0, sz);
        return v;
}

static char*
estrdup(char *s)
{
        s = strdup(s);
        if(s == nil)
                sysfatal("strdup (%.10s) fails", s);
        return s;
}

static char*
Bgetline(Biobuf *b)
{
        char *p;

        if(p = Brdline(b, '\n'))
                p[Blinelen(b)-1] = '\0';
        return p;
}

Ahdr*
gethdr(Biobuf *b)
{
        Ahdr *a;
        char *p, *f[10];

        if((p = Bgetline(b)) == nil)
                return nil;

        if(strcmp(p, "end of archive") == 0) {
                werrstr("");
                return nil;
        }

        if(tokenize(p, f, nelem(f)) != 6) {
                werrstr("bad format");
                return nil;
        }

        a = emalloc(sizeof(*a));
        a->name = estrdup(f[0]);
        a->mode = strtoul(f[1], 0, 8);
        a->uid = estrdup(f[2]);
        a->gid = estrdup(f[3]);
        a->mtime = strtoll(f[4], 0, 10);
        a->length = strtoll(f[5], 0, 10);
        return a;
}

static Arch*
newarch(vlong off, vlong length)
{
        static Arch *abuf;
        static int nabuf;

        if(nabuf == 0) {
                nabuf = 256;
                abuf = emalloc(sizeof(Arch)*nabuf);
        }

        nabuf--;
        abuf->off = off;
        abuf->length = length;
        return abuf++;
}

static File*
createpath(File *f, char *name, char *u, ulong m)
{
        char *p;
        File *nf;

        if(verbose)
                fprint(2, "createpath %s\n", name);
        incref(f);
        while(f && (p = strchr(name, '/'))) {
                *p = '\0';
                if(strcmp(name, "") != 0 && strcmp(name, ".") != 0){
                        /* this would be a race if we were multithreaded */
                        incref(f);      /* so walk doesn't kill it immediately on failure */
                        if((nf = walkfile(f, name)) == nil)
                                nf = createfile(f, name, u, DMDIR|0777, nil);
                        decref(f);
                        f = nf;
                }
                *p = '/';
                name = p+1;
        }
        if(f == nil)
                return nil;

        incref(f);
        if((nf = walkfile(f, name)) == nil)
                nf = createfile(f, name, u, m, nil);
        decref(f);
        return nf;
}

static void
archcreatefile(char *name, Arch *arch, Dir *d)
{
        File *f;
        f = createpath(archtree->root, name, d->uid, d->mode);
        if(f == nil)
                sysfatal("creating %s: %r", name);
        free(f->gid);
        f->gid = estrdup9p(d->gid);
        f->aux = arch;
        f->mtime = d->mtime;
        f->length = d->length;
        decref(f);
}

static void
fsread(Req *r)
{
        Arch *a;
        char err[ERRMAX];
        int n;

        a = r->fid->file->aux;
        if(a->length <= r->ifcall.offset) 
                r->ifcall.count = 0;
        else if(a->length <= r->ifcall.offset+r->ifcall.count)
                r->ifcall.count = a->length - r->ifcall.offset;

        werrstr("unknown error");
        if(Bseek(b, a->off+r->ifcall.offset, 0) < 0 
        || (n = Bread(b, r->ofcall.data, r->ifcall.count)) < 0) {
                err[0] = '\0';
                errstr(err, sizeof err);
                respond(r, err);
        } else {
                r->ofcall.count = n;
                respond(r, nil);        
        }
}

Srv fs = {
        .read=  fsread,
};

static void
usage(void)
{
        fprint(2, "usage: archfs [-abcC] [-m mtpt] archfile\n");
        exits("usage");
}

void
main(int argc, char **argv)
{
        Ahdr *a;
        ulong flag;
        char *mtpt;
        char err[ERRMAX];

        flag = 0;
        mtpt = "/mnt/arch";
        ARGBEGIN{
        case 'D':
                chatty9p++;
                break;
        case 'a':
                flag |= MAFTER;
                break;
        case 'b':
                flag |= MBEFORE;
                break;
        case 'c':
                flag |= MCREATE;
                break;
        case 'C':
                flag |= MCACHE;
                break;
        case 'm':
                mtpt = EARGF(usage());
                break;
        default:
                usage();
                break;
        }ARGEND;

        if(argc != 1)
                usage();

        if((b = Bopen(argv[0], OREAD)) == nil)
                sysfatal("open '%s': %r", argv[0]);

        archtree = fs.tree = alloctree("sys", "sys", DMDIR|0775, nil);
        while(a = gethdr(b)) {
                archcreatefile(a->name, newarch(Boffset(b), a->length), a);
                Bseek(b, a->length, 1);
        }

        err[0] = '\0';
        errstr(err, sizeof err);
        if(err[0])
                sysfatal("reading archive: %s", err);

        postmountsrv(&fs, nil, mtpt, flag);
        exits(0);
}