865 lines
14 KiB
C
865 lines
14 KiB
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"
|
|
};
|
|
|
|
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);
|
|
}
|