ref: c6a92afc7ac0382d90bf0fbd1d2e3e258a57aad4
dir: /sys/src/games/wadfs.c/
#include <u.h> #include <libc.h> #include <ctype.h> #include <fcall.h> #include <thread.h> #include <9p.h> #include <bio.h> enum{ Nsig = 4, Nhdr = Nsig+4+4, Ndict = 4+4+8, Nname = 8, Nbuf = 8192, Maxsz = 0x7fffffff - Nhdr }; enum{ LTnil, LTreg, LTmap, LTmrk, LTend }; typedef struct Lump Lump; struct Lump{ char name[Nname+1]; u32int ofs; uchar *buf; ulong nbuf; int type; File *f; Lump *l; Lump *lp; }; Lump l1 = {.l = &l1, .lp = &l1}, *lumps = &l1; Biobuf *wad; u32int nlmp; File *ldir, *fsig, *fwad; int rdonly, dirty; Srv fs; char *mapn[] = { "things", "linedefs", "sidedefs", "vertexes", "segs", "ssectors", "nodes", "sectors", "reject", "blockmap", "behavior" }; void strupr(char *s, char *p) { char c; do{ c = *p++; *s++ = toupper(c); }while(c != 0); } void strlwr(char *s, char *p) { char c; do{ c = *p++; *s++ = tolower(c); }while(c != 0); } void link(Lump *l, Lump *lp, int len) { l->lp = lp; l->l = lp->l; lp->l->lp = l; lp->l = l; nlmp++; fwad->length += Ndict + len; } void unlink(Lump *l) { if(l->l == nil) return; l->lp->l = l->l; l->l->lp = l->lp; l->l = nil; nlmp--; fwad->length -= Ndict + (l->f != nil ? l->f->length : 0); } void freelump(Lump *l) { unlink(l); free(l->buf); free(l); } void readlump(Lump *l, uchar *p, long n) { if(n <= 0) return; Bseek(wad, l->ofs, 0); if(Bread(wad, p, n) != n) fprint(2, "readlump: short read: %r\n"); } void loadlump(File *f, ulong n) { Lump *l; l = f->aux; if(f->length > n) n = f->length; l->buf = emalloc9p(n); l->nbuf = n; l->ofs = 0; readlump(l, l->buf, f->length); } Lump * lastlump(Lump *lp) { File *f, *dir; for(dir=lp->f, f=lp->l->f; lp->l!=lumps; lp=lp->l, f=lp->l->f) if(f->parent != dir && f->parent->parent != dir) break; if(lp->type == LTend && lp->f->parent == dir) lp = lp->lp; return lp; } int nextmaplump(char *s) { char **p; for(p=mapn; p<mapn+nelem(mapn); p++) if(strcmp(s, *p) == 0) return p-mapn; return -1; } Lump * sortmap(Lump *lp, Lump *l) { int ip, i; i = nextmaplump(l->f->name); for(; lp->l != lumps; lp=lp->l){ ip = nextmaplump(lp->l->f->name); if(ip < 0 || ip > i) break; } return lp; } int ismaplump(char *s) { return nextmaplump(s) >= 0; } int ismapname(char *s) { if(strncmp(s, "map", 3) == 0) return isdigit(s[3]) && isdigit(s[4]); return s[0] == 'e' && isdigit(s[1]) && s[2] == 'm' && isdigit(s[3]); } int ismarkname(char *s, char *m) { char *p; p = strstr(s, m); if(p == nil || p[strlen(m)] != 0) return 0; if(p - s > 2) return 0; return 1; } int validname(char *s, File *dir, int *type, int isnew, int isdir) { int n; char c, *p; Lump *lp; *type = LTnil; n = strlen(s); if(n < 1 || n > sizeof(lp->name)-1){ werrstr("invalid lump name"); return 0; } for(p=s+n-1; c=*p, p-->=s;) if(!isprint(c) || isupper(c) || c == '/'){ werrstr("invalid char %c in filename", c); return 0; } if(isnew && !ismaplump(s)) for(lp=lumps->l; lp!=lumps; lp=lp->l) if(cistrcmp(s, lp->name) == 0){ werrstr("duplicate non map lump"); return 0; } *type = LTreg; lp = dir->aux; if(ismapname(s)){ *type = LTmap; if(isnew && !isdir){ werrstr("map marker not a directory"); return 0; }else if(dir != fs.tree->root){ werrstr("nested map directory"); return 0; } return 1; }else if(ismarkname(s, "_end")){ *type = LTend; if(dir == fs.tree->root || lp == nil || lp->type == LTmap){ werrstr("orphaned end marker"); return 0; } return 1; }else if(ismarkname(s, "_start")){ *type = LTmrk; if(isnew){ werrstr("not allowed"); return 0; } goto mrkchk; }else if(isnew && isdir){ *type = LTmrk; if(n > 2){ werrstr("marker name too long"); return 0; } mrkchk: if(dir->parent != fs.tree->root){ werrstr("start marker nested too deep"); return 0; }else if(lp != nil && lp->type == LTmap){ werrstr("start marker within map directory"); return 0; } return 1; }else if(ismaplump(s) ^ (lp != nil && lp->type == LTmap)){ werrstr("map lump outside of map directory"); return 0; } return 1; } int endldir(Lump *lp, Lump *le) { char *s, name[sizeof lp->name]; Lump *l; File *f; l = emalloc9p(sizeof *l); strcpy(l->name, lp->name); s = strrchr(l->name, '_'); strcpy(s, "_END"); strlwr(name, l->name); fprint(2, "adding end marker %s\n", l->name); if(!validname(name, lp->f, &l->type, 1, 0) || l->type != LTend) goto err; f = createfile(lp->f, name, nil, lp->f->mode & 0666, l); if(f == nil) goto err; closefile(f); l->f = f; link(l, le, 0); return 0; err: free(l); return -1; } void accessfile(File *f, int mode) { f->atime = time(nil); if(mode & AWRITE){ f->mtime = f->atime; f->qid.vers++; dirty = 1; } } void fswstat(Req *r) { int type; char *e; File *f, *fp; Lump *lp; e = "permission denied"; if(rdonly) goto err; if(r->d.mode != ~0 || r->d.gid[0] != 0) goto err; f = r->fid->file; lp = f->aux; if(r->d.length != ~0 && r->d.length != f->length){ if(f == fsig || f->mode & DMDIR) goto err; if(!hasperm(f, r->fid->uid, AWRITE)) goto err; if(r->d.length < 0){ e = "invalid file length"; goto err; } if(fwad->length - f->length + r->d.length >= Maxsz){ e = "lump size exceeds wad limit"; goto err; } } if(r->d.name[0] != 0 && strcmp(r->d.name, f->name) != 0){ fp = f->parent; if(fp == nil){ e = "orphaned file"; goto err; } if(!hasperm(fp, r->fid->uid, AWRITE)) goto err; if(!validname(r->d.name, fp, &type, 1, f->mode & DMDIR)){ responderror(r); return; } if(lp->type != type){ e = "incompatible lump type"; goto err; } incref(fp); fp = walkfile(fp, r->d.name); if(fp != nil){ e = "file already exists"; goto err; } } if(r->d.length != ~0 && r->d.length != f->length){ if(lp->buf == nil) loadlump(f, r->d.length); fwad->length += r->d.length - f->length; f->length = r->d.length; } if(r->d.name[0] != 0 && strcmp(r->d.name, f->name) != 0){ free(f->name); f->name = estrdup9p(r->d.name); strupr(lp->name, f->name); if(lp->type == LTmrk) strcat(lp->name, "_START"); } accessfile(f, AWRITE); if(r->d.mtime != ~0) f->mtime = r->d.mtime; respond(r, nil); return; err: respond(r, e); } void fsremove(Req *r) { File *f; Lump *lp; f = r->fid->file; lp = f->aux; if(f == fsig || f == fwad){ respond(r, "not allowed"); return; }else if(lp->l->f != nil && lp->l->f->parent == f){ respond(r, "has children"); return; } unlink(f->aux); dirty = 1; respond(r, nil); } char * writesig(uchar *buf, char *s, vlong n) { if(n > Nsig+1 || strncmp(s, "IWAD", Nsig) != 0 && strncmp(s, "PWAD", Nsig) != 0) return "invalid wad signature"; memcpy(buf, s, Nsig); dirty = 1; return nil; } void fswrite(Req *r) { vlong n, m, ofs, end; File *f; Lump *l; f = r->fid->file; n = r->ifcall.count; ofs = r->ifcall.offset; if(f->mode & DMAPPEND) ofs = f->length; end = ofs + n; l = f->aux; if(f == fsig){ respond(r, writesig(l->buf, r->ifcall.data, n)); return; } if(l->buf == nil) loadlump(f, end + Nbuf); if(end > l->nbuf){ m = l->nbuf + Nbuf > end ? l->nbuf + Nbuf : end; if(fwad->length - l->nbuf + m >= Maxsz){ respond(r, "lump size exceeds wad limit"); return; } l->buf = erealloc9p(l->buf, m); l->nbuf = m; } memcpy(l->buf + ofs, r->ifcall.data, n); m = end - f->length; if(m > 0){ f->length += m; fwad->length += m; } accessfile(f, AWRITE); r->ofcall.count = n; respond(r, nil); } void makewad(void) { vlong n; uchar *p; u32int ofs; Lump *l, *lp; l = fwad->aux; free(l->buf); l->buf = emalloc9p(fwad->length); p = l->buf; lp = fsig->aux; memcpy(p, lp->buf, 4), p += 4; PBIT32(p, nlmp); p += 8; for(lp=lumps->l; lp!=lumps; p+=n, lp=lp->l){ n = lp->f->length; if(lp->buf != nil) memcpy(p, lp->buf, n); else readlump(lp, p, n); } PBIT32(l->buf + 8, p - l->buf); ofs = Nhdr; for(lp=lumps->l; lp!=lumps; ofs+=n, lp=lp->l){ n = lp->f->length; PBIT32(p, ofs); p += 4; PBIT32(p, n); p += 4; memcpy(p, lp->name, 8), p += 8; } dirty = 0; } void fsread(Req *r) { vlong n, ofs, end; File *f; Lump *l; f = r->fid->file; l = f->aux; ofs = r->ifcall.offset + l->ofs; end = l->ofs + f->length; n = r->ifcall.count; if(ofs + n >= end) n = end - ofs; if(n <= 0){ r->ofcall.count = 0; respond(r, nil); return; } if(f == fwad && dirty) makewad(); if(l->buf != nil) memcpy(r->ofcall.data, l->buf+ofs, n); else{ Bseek(wad, ofs, 0); n = Bread(wad, r->ofcall.data, n); if(n < 0){ responderror(r); return; } } accessfile(f, AREAD); r->ofcall.count = n; respond(r, nil); } int addlump(Lump *l, File *dir) { Lump *lp; lp = lumps->lp; if(dir != fs.tree->root){ lp = dir->aux; lp = lp->type == LTmap ? sortmap(lp, l) : lastlump(lp); } if(l->type == LTend && lp->l->type == LTend && lp->l->f->parent == dir){ werrstr("an end marker already exists"); return -1; } link(l, lp, 0); if(l->type == LTmrk){ strcat(l->name, "_START"); if(endldir(l, l) < 0) return -1; }else if(l->type == LTreg){ l->buf = emalloc9p(Nbuf); l->nbuf = Nbuf; } dirty = 1; return 0; } Lump * createlump(char *s, File *dir, int ismark) { int type; Lump *l; if(!validname(s, dir, &type, 1, ismark)) return nil; l = emalloc9p(sizeof *l); l->type = type; strupr(l->name, s); return l; } void fscreate(Req *r) { int p; File *f; Lump *l; f = r->fid->file; p = r->ifcall.perm; if(p & DMDIR) p = p & ~0777 | p & f->mode & 0777; else p = p & ~0666 | p & f->mode & 0666; l = createlump(r->ifcall.name, f, p & DMDIR); if(l == nil) goto err; f = createfile(f, r->ifcall.name, r->fid->uid, p, l); if(f == nil){ free(l); goto err; } l->f = f; if(addlump(l, r->fid->file) < 0){ removefile(f); goto err; } r->fid->file = f; r->ofcall.qid = f->qid; respond(r, nil); return; err: responderror(r); } void fsopen(Req *r) { File *f; f = r->fid->file; if((f->mode & DMAPPEND) == 0 && (r->ifcall.mode & OTRUNC) != 0 && f != fsig){ fwad->length -= f->length; f->length = 0; dirty = 1; } respond(r, nil); } void fsdestroyfile(File *f) { freelump(f->aux); } Srv fs = { .open = fsopen, .create = fscreate, .read = fsread, .write = fswrite, .remove = fsremove, .wstat = fswstat }; int get32(Biobuf *bf, u32int *v) { int n; uchar u[4]; n = Bread(bf, u, sizeof u); if(n != sizeof u) return -1; *v = GBIT32(u); return 0; } File * replacefile(File *dir, char *fname, int mode, Lump *l) { File *f; incref(dir); f = walkfile(dir, fname); if(f == nil) return nil; if(removefile(f) < 0) return nil; f = createfile(dir, fname, nil, mode, l); return f; } void addsigfile(char *sig) { int n; Lump *l; File *f; n = strlen(sig) + 1; l = emalloc9p(sizeof *l); l->buf = (uchar *)estrdup9p(sig); l->buf[n-1] = '\n'; f = createfile(fs.tree->root, "SIG", nil, rdonly ? 0444 : 0666, l); if(f == nil) sysfatal("addsigfile: %r"); else{ fsig = f; f->length = n; } } void addwadfile(void) { Lump *l; File *f; l = emalloc9p(sizeof *l); f = createfile(fs.tree->root, "WAD", nil, 0444, l); if(f == nil) sysfatal("addwadfile: %r"); else{ fwad = f; f->length = Nhdr; } dirty++; } void checkends(void) { Lump *lp; if(ldir == fs.tree->root) return; lp = ldir->aux; if(lp->type != LTmap && endldir(lp, lastlump(lp)) < 0) fprint(2, "checkends: %r\n"); ldir = ldir->parent; checkends(); } int addfile(Lump *l, u32int *len, int mode) { int err; char fname[sizeof l->name], *s; Lump *lp; File *f; *len = 0; if(get32(wad, &l->ofs) < 0 || get32(wad, len) < 0) return -1; if(Bread(wad, l->name, sizeof(l->name)-1) != sizeof(l->name)-1) return -1; strlwr(fname, l->name); lp = ldir->aux; err = !validname(fname, ldir, &l->type, 0, 0); switch(l->type){ case LTmap: closefile(ldir); ldir = fs.tree->root; if(err && lp != nil && lp->type != LTmap){ fprint(2, "addfile %s ofs=%#ux len=%#ux: %r\n", l->name, l->ofs, *len); if(endldir(lp, lastlump(lp)) < 0) fprint(2, "endldir: %r\n"); } mode |= DMDIR|0111; *len = 0; break; case LTmrk: if(err){ if(lp != nil && lp->type == LTmap){ closefile(ldir); ldir = fs.tree->root; }else{ fprint(2, "addfile %s ofs=%#ux len=%#ux: %r\n", l->name, l->ofs, *len); if(endldir(lp, lastlump(lp)) < 0) return -1; ldir = ldir->parent; } } s = strrchr(fname, '_'); *s = 0; mode |= DMDIR|0111; *len = 0; break; case LTend: if(err){ ldir = ldir->parent; return -1; } *len = 0; break; case LTreg: if(err){ if(ismaplump(fname)) fprint(2, "addfile %s ofs=%#ux len=%#ux: %r\n", l->name, l->ofs, *len); else ldir = fs.tree->root; } break; default: return -1; } f = createfile(ldir, fname, nil, mode, l); if(f == nil){ fprint(2, "createfile %s: %r\n", l->name); if(mode & DMDIR) return -1; f = replacefile(ldir, fname, mode, l); if(f == nil) return -1; } if(mode & DMDIR) ldir = f; else if(l->type == LTend) ldir = ldir->parent; else closefile(f); f->length = *len; l->f = f; return 0; } void parsewad(void) { int n, ne, mode; u32int len; Lump *l; mode = rdonly ? 0444 : 0666; ldir = fs.tree->root; for(n=0, ne=nlmp, nlmp=0; n<ne; n++){ l = emalloc9p(sizeof *l); if(addfile(l, &len, mode) < 0){ fprint(2, "addfile %s ofs=%#ux len=%#ux: %r\n", l->name, l->ofs, len); free(l); continue; } link(l, lumps->lp, len); } checkends(); } void wadinfo(char *sig) { int n; u32int dictofs; n = Bread(wad, sig, Nsig); if(n != Nsig) sysfatal("readwad: short read: %r"); sig[4] = 0; if(strcmp(sig, "IWAD") != 0 && strcmp(sig, "PWAD") != 0) sysfatal("invalid wad signature"); if(get32(wad, &nlmp) < 0 || get32(wad, &dictofs) < 0) sysfatal("wadinfo: %r"); Bseek(wad, dictofs, 0); } void usage(void) { fprint(2, "usage: %s [-Dr] [-m mtpt] [-S srvname] [wad]\n", argv0); exits("usage"); } void main(int argc, char **argv) { int fl, p; char *mtpt, *srvname, sig[Nsig+1] = "PWAD"; mtpt = "/mnt/wad"; srvname = nil; fl = MREPL|MCREATE; p = DMDIR|0777; ARGBEGIN{ case 'D': chatty9p++; break; case 'S': srvname = EARGF(usage()); break; case 'm': mtpt = EARGF(usage()); break; case 'r': rdonly++; p &= ~0222; fl &= ~MCREATE; break; default: usage(); }ARGEND if(*argv != nil){ wad = Bopen(*argv, OREAD); if(wad == nil) sysfatal("Bopen: %r"); wadinfo(sig); } fs.tree = alloctree(nil, nil, p, fsdestroyfile); addsigfile(sig); addwadfile(); parsewad(); postmountsrv(&fs, srvname, mtpt, fl); exits(nil); }