#include <u.h>
#include <libc.h>
#include <ctype.h>
#include <bio.h>
#include <draw.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
#include "trafficfs.h"
/*
* we generate a three-level directory structure:
* root/
* trafficfs (our own root)
* ctl (toc of generated files; generate files)
* toc (table of contents of nr files)
* 21/ (group of levels with same minimal solution move count)
* 0 (first level in this group)
* 1 (second level in this group)
* ...
* 22/
* 0 (first level in this group)
* 1 (second level in this group)
* ...
* ...
* foo (generated file)
* bar (generated file)
*/
typedef struct Aux Aux;
struct Aux {
int doff;
int gnr;
int gidx;
int lnr;
};
enum {
Qroot = 0,
Qdir,
Qctl,
Qtoc,
Qgen,
Qgrp,
Qlvl,
};
#define PATH(qid,grp,lvl) (((lvl)<<16)|(((grp)&0xFF)<<8)|((qid)&0xFF))
#define QDIR(qid) ((int)((qid)&0xFF))
#define GRP(qid) (((qid)>>8) &0xFF)
#define LVL(qid) ((qid)>>16)
int debug;
ulong starttime;
/* representation of levels */
Directory *directory;
/* stuff used to on-the-fly generate the combined level files */
int *choicelist; /* array from which we choose problems */
int maxchoicelist; /* max nr of entries in choicelist (without subtracting seen levels) */
Seen *dirseen; /* keeps track of levels that user has seen */
Generated *generated; /* on-the-fly generated files of levels */
int ngenerated; /* number of items in generated */
void printlevel(char *s, Level *l);
void chooseproblems(Generated *g);
void*
emalloc(ulong sz)
{
void *v;
v = malloc(sz);
if(v == nil) {
abort();
sysfatal("malloc %lud fails\n", sz);
}
setmalloctag(v, getcallerpc(&sz));
memset(v, 0, sz);
return v;
}
void*
erealloc(void *p, ulong sz)
{
void *v;
v = realloc(p, sz);
if(v == nil)
sysfatal("realloc %lud fails\n", sz);
setrealloctag(v, getcallerpc(&p));
return v;
}
static Point
lin2grouplvl(int n)
{
Group *gp;
Level *lp;
lp = directory->level + n;
for (gp=directory->group; gp<directory->group+directory->ngroup; gp++) {
if (lp >= gp->base && lp < gp->beyond)
return Pt(gp->moves, lp-gp->base);
}
return Pt(0,0);
}
int
index(int n)
{
if (n < directory->base)
return -1;
if (n > directory->beyond)
return -1;
return n - directory->base;
}
int
isseen(uchar *seen, int n)
{
int i, r;
i = n / 8;
r = n % 8;
return (seen[i] & 1<<r) == (1<<r);
}
void
setseen(uchar *seen, int n)
{
int i, r;
i = n / 8;
r = n % 8;
seen[i] |= 1<<r;
}
void
unsetseen(uchar *seen, int n)
{
int i, r;
i = n / 8;
r = n % 8;
seen[i] &= ~(1<<r);
if(debug) fprint(2, "unsetseen %d i=%d r=%d\n", n, i, r);
}
void
dirsetseen(Seen *s, int n)
{
Point p;
int i;
p = lin2grouplvl(n);
i = index(p.x);
if (debug) fprint(2, "setseenlin %d -> %d (%d), %d\n", n, p.x, i, p.y);
if (!isseen(s->seen, n)) {
setseen(s->seen, n);
s->group[i].nseen++;
}
}
void
resetseen(Seen *s, int base, int beyond)
{
int baselvl, beyondlvl, count, nextlvl, i;
baselvl = directory->group[base - directory->base].base - directory->level;
beyondlvl = directory->group[beyond - directory->base - 1].beyond - directory->level;
if (debug) fprint(2, "resetseen base %d beyond %d baselvl %d beyondlvl %d\n", base, beyond, baselvl, beyondlvl);
/* first bits in byte containing also bits for previous level */
for(i=baselvl; i<beyondlvl && i%8 != 0; i++) {
unsetseen(s->seen, i);
if (debug) fprint(2, "resetseen %d beyondlvl=%d\n", i, beyondlvl);
}
nextlvl = i;
count = beyondlvl - nextlvl;
/* complete bytes containing only bits for this level */
if (count/8 > 0) {
if (debug) fprint(2, "resetseen off %d count %d\n", nextlvl/8, count/8);
memset(s->seen+(nextlvl/8), 0, count/8);
nextlvl += (count/8)*8;
}
/* last bits in byte containing also bits for next level */
for(i=nextlvl; i<beyondlvl; i++) {
unsetseen(s->seen, i);
if (debug) fprint(2, "resetseen %d nextlvl=%d beyondlvl=%d\n", i, nextlvl, beyondlvl);
}
for (i=base - directory->base; i < beyond - directory->base; i++)
s->group[i].nseen = 0;
}
static void
fsattach(Req *r)
{
r->fid->qid = (Qid){Qroot, 0, QTDIR};
r->ofcall.qid = r->fid->qid;
r->fid->aux = emalloc(sizeof(Aux));
respond(r, nil);
}
static char*
fsclone(Fid *old, Fid *new)
{
Aux *na;
na = emalloc(sizeof(Aux));
*na = *((Aux*)old->aux);
new->aux = na;
return nil;
}
static char*
fswalk1(Fid *fid, char *name, Qid *qid)
{
int i, n;
char *p;
Aux *a;
a = fid->aux;
switch(QDIR(fid->qid.path)) {
case Qroot:
if(strcmp(name, "..") == 0) {
*qid = (Qid){Qroot, 0, QTDIR};
return nil;
}
if(strcmp(name, "trafficfs") == 0) {
*qid = (Qid){Qdir, 0, QTDIR};
return nil;
}
return "file not found";
case Qdir:
if(strcmp(name, "..") == 0) {
*qid = (Qid){Qroot, 0, QTDIR};
return nil;
}
if(strcmp(name, "toc") == 0) {
*qid = (Qid){Qtoc, 0, QTFILE};
return nil;
}
if(strcmp(name, "ctl") == 0) {
*qid = (Qid){Qctl, 0, QTFILE};
return nil;
}
/* group directories */
n = strtoul(name, &p, 0);
if('0'<=name[0] && name[0]<='9' && *p=='\0'){
for(i=0; i<directory->ngroup; i++)
if(directory->group[i].moves == n) {
*qid = (Qid){PATH(Qgrp,i,0), 0, QTDIR};
a->gnr = n;
a->gidx = i;
return nil;
}
}
/* generated files */
for (i=0; i < ngenerated; i++) {
if(strcmp(generated[i].name, name) ==0) {
*qid = (Qid){PATH(Qgen,i,0), 0, QTFILE};
return nil;
}
}
return "file not found";
case Qgrp:
if(strcmp(name, "..") == 0) {
*qid = (Qid){Qdir, 0, QTDIR};
return nil;
}
/* level files */
n = strtoul(name, &p, 0);
if('0'<=name[0] && name[0]<='9' && *p=='\0'){
if (n >= 0 && n < directory->group[a->gidx].count) {
*qid = (Qid){PATH(Qlvl,a->gidx,n), 0, QTFILE};
a->lnr = n;
return nil;
}
}
return "file not found";
default: /* bug: lib9p could handle this */
return "walk in non-directory";
}
}
static void
fsopen(Req *r)
{
int omode;
omode = r->ifcall.mode;
if(omode == OREAD)
respond(r, nil);
else if ((omode&~OTRUNC) == OWRITE && QDIR(r->fid->qid.path) == Qctl)
respond(r, nil);
else
respond(r, "permission denied");
}
int
fillstat(ulong qid, Dir *d)
{
char buf[32];
memset(d, 0, sizeof(Dir));
d->uid = estrdup9p("rushhour");
d->gid = estrdup9p("rushhour");
d->muid = estrdup9p("");
d->qid = (Qid){qid, 0, 0};
d->atime = d->mtime = starttime;
switch(QDIR(qid)){
case Qroot:
d->name = estrdup9p("/");
d->qid.type = QTDIR;
d->mode = DMDIR|0555;
break;
case Qdir:
d->name = estrdup9p("trafficfs");
d->qid.type = QTDIR;
d->mode = DMDIR|0555;
break;
case Qctl:
d->name = estrdup9p("ctl");
d->qid.type = QTFILE;
d->mode = 0666;
break;
case Qtoc:
d->name = estrdup9p("toc");
d->qid.type = QTFILE;
d->mode = 0444;
break;
case Qgen:
d->name = estrdup9p(generated[GRP(qid)].name);
d->qid.type = QTFILE;
d->mode = 0444;
d->mtime = generated[GRP(qid)].mtime;
d->length = generated[GRP(qid)].ndata;
break;
case Qgrp:
sprint(buf, "%d", directory->group[GRP(qid)].moves);
d->name = estrdup9p(buf);
d->qid.type = QTDIR;
d->mode = DMDIR|0555;
break;
case Qlvl:
sprint(buf, "%uld", LVL(qid));
d->name = estrdup9p(buf);
d->qid.type = QTFILE;
d->mode = 0444;
break;
default:
/* should not happen */
return 0;
break;
}
return 1;
}
static void
fsstat(Req *r)
{
fillstat((ulong)r->fid->qid.path, &r->d);
respond(r, nil);
}
static int
genroot(int n, Dir *dir, void *aux)
{
USED(aux);
if (n==0)
return fillstat(PATH(Qdir,0, 0), dir);
else
return -1;
}
static int
gendir(int n, Dir *dir, void *aux)
{
USED(aux);
if (n==0)
return fillstat(PATH(Qctl,0, 0), dir);
else if (n == 1)
return fillstat(PATH(Qtoc,0, 0), dir);
else if (n < ngenerated+1+1)
return fillstat(PATH(Qgen,n-1-1, 0), dir);
else if (n < 1+1+ngenerated+directory->ngroup)
return fillstat(PATH(Qgrp,n-1-1-ngenerated, 0), dir);
else
return -1;
}
static int
gengrp(int n, Dir *dir, void *aux)
{
Aux *a;
a = aux;
if (n < directory->group[a->gidx].count)
return fillstat(PATH(Qlvl,a->gidx,n), dir);
else
return -1;
}
static void
fsread(Req *r)
{
int j, m, cum;
Fid *fid;
vlong offset;
char s[1024];
Aux *a;
Generated *g;
Level *lp;
fid = r->fid;
offset = r->ifcall.offset;
a = fid->aux;
switch(QDIR(fid->qid.path)) {
case Qroot:
dirread9p(r, genroot, a);
respond(r, nil);
break;
case Qdir:
dirread9p(r, gendir, a);
respond(r, nil);
break;
case Qgrp:
dirread9p(r, gengrp, a);
respond(r, nil);
break;
case Qlvl:
/* XXX make sure that s is big enough */
sprint(s, "; moves %d level %d\n", a->gnr, a->lnr);
sprint(s+strlen(s), ":%d/%d\n", a->gnr, a->lnr);
lp = directory->group[a->gidx].base + a->lnr;
printlevel(s, lp);
readstr(r, s);
respond(r, nil);
break;
case Qctl:
/* XXX make sure that s is big enough */
sprint(s,"");
for(g=&generated[0]; g < &generated[ngenerated]; g++)
sprint(s+strlen(s), "%s %d of %d (%d-%d) in [%d,%d) (requested %d in [%d,%d)) \n", g->name, g->count, g->avail, g->total, g->seen, g->min, g->max, g->req.count, g->req.min, g->req.max);
s[strlen(s)] = '\0';
readstr(r, s);
respond(r, nil);
break;
case Qtoc:
m = directory->ngroup;
sprint(s,"");
cum=0;
for(j=0; j<m; j++) {
cum += directory->group[j].count;
sprint(s+strlen(s), "%d %d %d %d\n", directory->group[j].moves, directory->group[j].count, cum, dirseen->group[j].nseen);
}
s[strlen(s)] = '\0';
readstr(r, s);
respond(r, nil);
break;
case Qgen:
g = &generated[GRP(fid->qid.path)];
readbuf(r, g->data, g->ndata);
respond(r, nil);
break;
default:
/* should not happen */
break;
}
}
static int
parsectl(Req *r, char *data)
{
int ok, i, j, n, w;
char *lines[25];
char *words[25];
int min, max, count;
char *name, *p;
Generated *gp;
GrpSeen *sgp;
ok = 1;
n = gettokens(data, lines, 25, "\r\n");
for (j=0; j<n; j++) {
w = gettokens(lines[j], words, 25, "\t ");
if (w == 0)
continue;
if (strcmp(words[0], "gen") == 0 && w == 5) {
name = words[1]; /* To Fix: check name does not contain '/' */
if (strchr(name, '/') != nil) {
respond(r, "name should not contain /");
return 0;
}
for (p=name; *p != '\0' && isdigit(*p); p++)
;
if (p == '\0') {
respond(r, "name should not contain only digits");
return 0;
}
min = atoi(words[2]);
max = atoi(words[3]);
count = atoi(words[4]);
if (min < 0 || max < 0 || count < 0){
respond(r, "gen numbers should be positive");
return 0;
}
for(gp=generated; gp<generated+ngenerated; gp++){
if (strcmp(gp->name, name) == 0)
break;
}
if (gp == generated+ngenerated) {
generated = erealloc(generated, sizeof(Generated)*(ngenerated+1));
ngenerated += 1;
gp = generated+ngenerated-1;
gp->name = estrdup9p(name);
gp->data = nil;
gp->ndata = 0;
}
gp->req.min = min;
gp->req.max = max;
gp->req.count = count;
chooseproblems(gp);
} else if (strcmp(words[0], "reset") == 0 && w == 2) {
name = words[1];
for(gp=generated; gp<generated+ngenerated; gp++){
if (strcmp(gp->name, name) == 0) {
resetseen(dirseen, gp->min, gp->max);
break;
}
}
if (gp == generated+ngenerated) {
respond(r, "no such name");
return 0;
}
} else if (strcmp(words[0], "reset") == 0 && w == 1) {
memset(dirseen->seen, 0, (directory->nlevel/8)+1);
for(sgp=dirseen->group; sgp<dirseen->group+dirseen->ngroup; sgp++)
sgp->nseen = 0;
} else {
ok = 0;
for(i=0; i<w; i++)
fprint(2, "error:w[%d]=(%s) (strlen=%ld) %x\n", i, words[i], strlen(words[i]), *(words[i]));
}
}
if (!ok)
respond(r, "parse error");
return ok;
}
static void
fswrite(Req *r)
{
Fid *fid;
long count;
vlong offset;
static char *data = nil;
static int ndata = 0;
fid = r->fid;
count = r->ifcall.count;
offset = r->ifcall.offset;
switch(QDIR(fid->qid.path)) {
case Qctl:
/* if (offset == 0) { */
if (ndata < count+1){
data = erealloc(data, count+1);
ndata = count+1;
}
memcpy(data, r->ifcall.data, count);
data[count] = '\0';
if (!parsectl(r, data))
return;
/* } */
r->ofcall.count = count;
respond(r, nil);
break;
default:
respond(r, "permission denied");
break;
}
}
static void
fsdestroyfid(Fid *fid)
{
Aux *a;
a = fid->aux;
if(a == nil)
return;
free(a);
}
Srv fs = {
.attach= fsattach,
.destroyfid= fsdestroyfid,
.clone= fsclone,
.walk1= fswalk1,
.open= fsopen,
.read= fsread,
.write= fswrite,
.stat= fsstat,
};
int
levelscount(int min, int max)
{
int base, beyond, res;
if (min == max)
return 0;
if (min < directory->base)
min = directory->base;
if (min > directory->beyond)
min = directory->beyond;
if (max < directory->base)
max = directory->base;
if (max > directory->beyond)
max = directory->beyond;
if (min == max)
return 0;
base = min - directory->base;
beyond = max - directory->base;
if (beyond < 1)
return 0;
res = directory->group[beyond-1].beyond - directory->group[base].base;
// fprint(2, "levelscount min %d max %d base %d beyond %d res %d\n", min, max, base, beyond, res);
return res;
}
int
buildchoicelist(int cum, int min, int max, Generated *g, Seen*s)
{
int i, j, lvl, off;
int base, beyond;
maxchoicelist = cum;
free(choicelist);
choicelist = emalloc(sizeof(int)*maxchoicelist);
base = min - directory->base;
beyond = max - directory->base;
USED(beyond);
off = directory->group[base].base - directory->level;
lvl = off;
j = 0;
for(i=0; i<cum; i++) {
if (!isseen(s->seen, lvl)) {
choicelist[j] = lvl;
j++;
} else
if (debug) fprint(2, "buildchoicelist(%d, %d, %d) seen %d\n", cum, min, max, lvl);
lvl++;
}
g->avail = j;
g->total = lvl - off;
g->seen = g->total - g->avail ;
return j;
}
int
intcmp(void *pa, void *pb)
{
int *a, *b;
a = pa;
b = pb;
return (*a - *b);
}
/*
* we generate g->count random numbers for
* the levels in [g->min, g->max)
* we may generated duplicate random numbers.
* we just throw out duplicates, but thus may
* end up with < g->count numbers
*/
void
chooseproblems(Generated *g)
{
int i, *levels, n, cum, prev, v, r, k;
Point p;
char *lbuf, *lp;
uchar *seen;
Level *lvlp;
g->mtime =time(0);
g->min = g->req.min;
g->max = g->req.max;
if (g->min < directory->base)
g->min = directory->base;
if (g->max > directory->beyond)
g->max = directory->beyond;
if (g->min > g->max)
g->min = g->max;
cum = levelscount(g->min, g->max);
g->avail = buildchoicelist(cum, g->min, g->max, g, dirseen);
if (g->avail > g->req.count)
n = g->req.count;
else
n = g->avail;
levels = emalloc(sizeof(int) * n);
lbuf = emalloc(sizeof(char)*n*150); /* be sure 150 is enough */
if (debug) fprint(2, "levelscount %d %d -> %d ; n = %d\n", g->min, g->max, g->avail, n);
if (g->avail > g->req.count) {
seen = emalloc((g->avail/8)+1);
for(i=0; i<n; i++) {
r = nrand(g->avail);
v = choicelist[r];
k = 0;
while (isseen(seen, r) && k < g->avail){
r = nrand(g->avail);
v = choicelist[r];
k++;
}
// if (k > 0) fprint(2, "rand i=%d r=%d v=%d k=%d\n", i, r, v,k);
if (debug) fprint(2, "rand i=%d r=%d v=%d k=%d\n", i, r, v,k);
setseen(seen, r);
levels[i] = v;
dirsetseen(dirseen, v);
}
free(seen);
qsort(levels, n, sizeof(int), intcmp);
} else {
for(i=0; i<n; i++) {
v = choicelist[i];
levels[i] = v;
dirsetseen(dirseen, v);
}
}
lp = lbuf;
prev = -1;
g->count = 0;
for(i=0; i<n; i++) {
if (prev == levels[i])
continue; /* throw out duplicate */
prev = levels[i];
g->count ++;
p = lin2grouplvl(levels[i]);
sprint(lp, "; moves %d level %d\n", p.x, p.y);
sprint(lp+strlen(lp), ":%d/%d\n", p.x, p.y);
lvlp = directory->level + levels[i];
printlevel(lp, lvlp);
lp += strlen(lp);
}
free(levels);
free(g->data);
g->data = lbuf;
g->ndata = lp - lbuf;
}
Seen*
seeninit(Directory *d)
{
Seen* s;
s = emalloc(sizeof(Seen));
s->ngroup = d->ngroup;
s->group = emalloc(sizeof(GrpSeen)*s->ngroup);
s->seen = emalloc((d->nlevel/8)+1);
return s;
}
int
readint(Biobuf *bp)
{
int i, n;
uchar b;
n = 0;
for (i=0; i < 4; i++) {
Bread(bp, &b, 1);
n+= (b << (i*8));
}
return n;
}
Directory*
readlevels(Biobuf *bp)
{
Directory *d;
Group *gp;
Level *lp;
int lvl, *off, *op, noff;
char ignored[10];
d = emalloc(sizeof(Directory));
d->base = readint(bp) - 1; /* should be 21-1 */
d->beyond = readint(bp); /* should be 52 */
d->ngroup = d->beyond - d->base;
d->group = emalloc(sizeof(Group)*d->ngroup);
noff = d->ngroup + 1; /* +1 for offset to end of file */
off = emalloc(sizeof(int)*noff);
lvl = d->base;
op = off;
for (gp=d->group; gp<d->group+d->ngroup; gp++) {
gp->moves = lvl++;
*(op++) = readint(bp);
}
*op = readint(bp); /* one more time for offset to end of file */
d->nlevel = (off[d->ngroup] - off[0])/8; /* 8 bytes per level */
d->level = emalloc(sizeof(Level)*d->nlevel);
op = off;
lp = d->level;
for (gp=d->group; gp<d->group+d->ngroup; gp++) {
if (debug) fprint(2, "Group %d\n", gp->moves);
gp->base = lp;
gp->count = (*(op+1) - *op)/8;
gp->beyond = lp + gp->count;
for (; lp<gp->beyond; lp++) {
Bread(bp, lp->row, 3);
Bread(bp, ignored, 1);
Bread(bp, lp->col, 3);
Bread(bp, ignored, 1);
}
op++;
}
free(off);
return d;
}
void
setboard(char **board, Point p, int l, int orient, int v)
{
int i;
Point dir[] = {
[OCol] Pt(1,0),
[ORow] Pt(0,1),
};
if (orient == OCol)
p = Pt(p.y,p.x);
for (i=0; i<l; i++) {
board[1+p.x][1+p.y] = v;
p = addpt(p, dir[orient]);
}
}
void
decstrip(char **board, int i, int b, int orient, char *car, char *truck)
{
switch(b){
case 0:
break;
case 1:
case 2:
case 3:
case 4:
case 5:
setboard(board, Pt(i, b-1), 2, orient, *car);
(*car)++;
break;
case 6:
case 7:
case 8:
case 9:
setboard(board, Pt(i, b-6), 3, orient, *truck);
(*truck)++;
break;
case 10:
case 11:
case 12:
setboard(board, Pt(i, 0), 2, orient, *car);
(*car)++;
setboard(board, Pt(i, b-8), 2, orient, *car);
(*car)++;
break;
case 13:
case 14:
setboard(board, Pt(i, 1), 2, orient, *car);
(*car)++;
setboard(board, Pt(i, b-10), 2, orient, *car);
(*car)++;
break;
case 15:
setboard(board, Pt(i, 2), 2, orient, *car);
(*car)++;
setboard(board, Pt(i, 4), 2, orient, *car);
(*car)++;
break;
}
}
void
printlevel(char *s, Level *l)
{
/*
* unfortunately, the following gives
* brd[rownr, colnr]
* which is opposite to convention (of brd[x][y])
*/
char *brd[] = {
"########",
"#......#",
"#......#",
"#......@",
"#......#",
"#......#",
"#......#",
"########",
};
char *board[8]; /* same as nr of rows of brd */
char car = 'a';
char truck = 'o';
char us = 'x';
int i;
int bl[6];
/*
* brd is only initialized once, not for for every call;
* if we change brd in-place we will be confronted
* with these changes in next call of this function
*/
for(i=0; i<8; i++)
board[i] = estrdup9p(brd[i]);
bl[0] = l->row[0] & 0x0F;
bl[1] = (l->row[0] >> 4) & 0x0F;
bl[2] = l->row[1] & 0x0F;
bl[3] = (l->row[1] >> 4) & 0x0F;
bl[4] = l->row[2] & 0x0F;
bl[5] = (l->row[2] >> 4) & 0x0F;
for (i=0; i< 6; i++)
if (i == 2)
decstrip(board, i, bl[i], ORow, &us, &truck);
else
decstrip(board, i, bl[i], ORow, &car, &truck);
bl[0] = l->col[0] & 0x0F;
bl[1] = (l->col[0] >> 4) & 0x0F;
bl[2] = l->col[1] & 0x0F;
bl[3] = (l->col[1] >> 4) & 0x0F;
bl[4] = l->col[2] & 0x0F;
bl[5] = (l->col[2] >> 4) & 0x0F;
for (i=0; i< 6; i++)
decstrip(board, i, bl[i], OCol, &car, &truck);
for (i=0; i<8; i++)
sprint(s+strlen(s), "%s\n", board[i]);
sprint(s+strlen(s), "\n");
for(i=0; i<8; i++)
free(board[i]);
}
void
usage(void)
{
fprint(2, "Usage: %s [-m mntpnt] [-s srv] [levelfile]\n", argv0);
exits("usage");
}
void
main(int argc, char**argv)
{
Biobuf *bp;
char *mtpt, *srvpost, *srvname, *srvfile, *levelfile;
mtpt = "/mnt";
srvpost = nil;
srvname = nil;
levelfile = "/sys/games/lib/rushhour/levels/ttraffic.levels";
debug = 0;
ARGBEGIN{
case 'd':
debug++;
break;
case 'D':
chatty9p++;
break;
case 'm':
mtpt = EARGF(usage());
break;
case 's':
srvpost = EARGF(usage());
break;
default:
usage();
}ARGEND
if (mtpt != nil && *mtpt == 0)
mtpt = nil;
if (argc > 1)
usage();
if (argc == 1)
levelfile = argv[0];
starttime = time(0);
srand(time(0));
bp = Bopen(levelfile, OREAD);
if (bp == nil)
sysfatal("cannot open levelfile: %r");
directory = readlevels(bp);
Bterm(bp);
dirseen = seeninit(directory);
ngenerated = 0;
generated = nil;
if(srvpost){
srvname = smprint("trafficfs.%s", srvpost);
srvfile = smprint("/srv/%s", srvname);
remove(srvfile);
free(srvfile);
}
postmountsrv(&fs, srvname, mtpt, MBEFORE);
}
|
