void
dumpobj(void)
{
NodeList *externs, *tmp;
bout = Bopen(outfile, OWRITE);
if(bout == nil) {
flusherrors();
print("can't create %s: %r\n", outfile);
errorexit();
}
Bprint(bout, "go object %s %s %s %s\n", getgoos(), thestring, getgoversion(), expstring());
Bprint(bout, " exports automatically generated from\n");
Bprint(bout, " %s in package \"%s\"\n", curio.infile, localpkg->name);
dumpexport();
Bprint(bout, "\n!\n");
outhist(bout);
externs = nil;
if(externdcl != nil)
externs = externdcl->end;
dumpglobls();
dumptypestructs();
// Dump extra globals.
tmp = externdcl;
if(externs != nil)
externdcl = externs->next;
dumpglobls();
externdcl = tmp;
dumpdata();
dumpfuncs();
Bterm(bout);
}
int
getc(void){
if(peekc>=0){
lastc=peekc;
peekc=-1;
return lastc;
}
if(lbuf==0){
File *f;
if(file->next==0)
return lastc=-1;
free(file->name);
Bterm(file->b);
free(file->b);
close(file->fd);
f=file->next;
free((char *)file);
file=f;
line=file->line;
lbuf=file->lbuf;
if(lbuf==0)
lbuf=(unsigned char *)"";
--nfile;
}
if(*lbuf==0){
file->line++;
line=file->line;
if(file->lbuf){
free((char *)file->lbuf);
file->lbuf=0;
}
lbuf=(unsigned char *)Brdline(file->b, '\n');
if(lbuf)
lbuf[BLINELEN(file->b)-1] = 0;
return lastc='\n';
}
return lastc=*lbuf++;
}
/*
* patterns are either
* ~ regular expression
* = exact match string
*
* all comparisons are case insensitive
*/
static int
readpatterns(char *path)
{
Biobuf *b;
char *p;
char *token[2];
int n;
int bang;
b = Bopen(path, OREAD);
if(b == nil)
return -1;
while((p = Brdline(b, '\n')) != nil){
p[Blinelen(b)-1] = 0;
n = tokenize(p, token, 2);
if(n == 0)
continue;
mklower(token[0]);
p = token[0];
if(*p == '!'){
p++;
bang = 1;
} else
bang = 0;
if(*p == '='){
if(newpattern(Texact, p+1, bang) < 0)
return -1;
} else if(*p == '~'){
if(newpattern(Tregexp, p+1, bang) < 0)
return -1;
} else if(strcmp(token[0], "#include") == 0 && n == 2)
readpatterns(token[1]);
}
Bterm(b);
return 0;
}
void
threadmain(int argc, char *argv[])
{
int i;
Index *ix;
u32int bcmem;
bcmem = 0;
ARGBEGIN{
case 'B':
bcmem = unittoull(ARGF());
break;
default:
usage();
break;
}ARGEND
if(argc < 1)
usage();
fmtinstall('H', encodefmt);
if(initventi(argv[0], &conf) < 0)
sysfatal("can't init venti: %r");
if(bcmem < maxblocksize * (mainindex->narenas + mainindex->nsects * 4 + 16))
bcmem = maxblocksize * (mainindex->narenas + mainindex->nsects * 4 + 16);
if(0) fprint(2, "initialize %d bytes of disk block cache\n", bcmem);
initdcache(bcmem);
ix = mainindex;
Binit(&bout, 1, OWRITE);
for(i=0; i<ix->nsects; i++)
if(shoulddump(ix->sects[i]->name, argc-1, argv+1))
dumpisect(ix->sects[i]);
Bterm(&bout);
threadexitsall(0);
}
void
reread(void)
{
int i;
extern int catnr;
char *q;
assert(f == nil);
if((f = Bopen(mapname, OREAD)) == nil)
fprint(2, "reread: %s: %r\n", mapname);
freetree(root);
root = nil;
for(i = 0; i< ntoken; i++){
free(tokenlist[i].name);
catsetfree(&tokenlist[i].categories);
}
catnr = 0;
free(tokenlist);
free(catobjects);
catobjects = nil;
ncat = 0;
tokenlist = nil;
ntoken = Ntoken;
inittokenlist();
free(file);
file = strdup(mapname);
free(startdir);
startdir = strdup(mapname);
if ((q = strrchr(startdir, '/')))
*q = '\0';
else
startdir[0] = '\0';
getobject(Root, nil);
root->parent = root;
Bterm(f);
f = nil;
}
void
writesnarf(Vnc *v, long n)
{
uchar buf[8192];
long m;
Biobuf *b;
if((b = Bopen("/dev/snarf", OWRITE)) == nil) {
vncgobble(v, n);
return;
}
while(n > 0) {
m = n;
if(m > sizeof(buf))
m = sizeof(buf);
vncrdbytes(v, buf, m);
n -= m;
Bwrite(b, buf, m);
}
Bterm(b);
snarfvers++;
}
/*
* dump any cached information, forget the hash tables, and reopen a single file
*/
int
ndbreopen(Ndb *db)
{
int fd;
Dir *d;
/* forget what we know about the open files */
if(db->mtime){
_ndbcacheflush(db);
hffree(db);
close(Bfildes(&db->b));
Bterm(&db->b);
db->mtime = 0;
}
/* try the open again */
fd = open(db->file, OREAD);
if(fd < 0)
return -1;
d = dirfstat(fd);
if(d == nil){
close(fd);
return -1;
}
/* no hashfile for /net/ndb (avoids deadlock in cs) */
if(d->type == 'I')
db->nohash = 1;
db->qid = d->qid;
db->mtime = d->mtime;
db->length = d->length;
Binits(&db->b, fd, OREAD, db->buf, sizeof(db->buf));
free(d);
return 0;
}
void
main(int argc, char *argv[])
{
Fils fstr[NFILES];
int nfdone = 0;
Binit(&bout, 1, OWRITE);
Files = fstr;
for(argc = findopt(argc, argv); argc > 0; --argc, ++argv)
if(Multi == 'm') {
if(Nfiles >= NFILES - 1)
die("too many files");
if(mustopen(*argv, &Files[Nfiles++]) == 0)
nfdone++; /* suppress printing */
} else {
if(pr(*argv))
Bterm(Files->f_f);
nfdone++;
}
if(!nfdone) /* no files named, use stdin */
pr(nulls); /* on GCOS, use current file, if any */
errprint(); /* print accumulated error reports */
exits(error? "error": 0);
}
static void
rdgeom(SDunit *unit)
{
char *line;
char *flds[5];
Biobuf bb;
Biobuf *bp;
static char geom[] = "geometry ";
bp = &bb;
seek(unit->ctl, 0, 0);
Binit(bp, unit->ctl, OREAD);
while((line = Brdline(bp, '\n')) != nil){
line[Blinelen(bp) - 1] = '\0';
if (strncmp(line, geom, sizeof geom - 1) == 0)
break;
}
if (line != nil && tokenize(line, flds, nelem(flds)) >= 3) {
unit->sectors = atoll(flds[1]);
unit->secsize = atoll(flds[2]);
}
Bterm(bp);
seek(unit->ctl, 0, 0);
}
static uint32_t
freemem(void)
{
int nf, pgsize = 0;
uint64_t size, userpgs = 0, userused = 0;
char *ln, *sl;
char *fields[2];
Biobuf *bp;
size = 64*1024*1024;
bp = Bopen("#c/swap", OREAD);
if (bp != nil) {
while ((ln = Brdline(bp, '\n')) != nil) {
ln[Blinelen(bp)-1] = '\0';
nf = tokenize(ln, fields, nelem(fields));
if (nf != 2)
continue;
if (strcmp(fields[1], "pagesize") == 0)
pgsize = atoi(fields[0]);
else if (strcmp(fields[1], "user") == 0) {
sl = strchr(fields[0], '/');
if (sl == nil)
continue;
userpgs = atoll(sl+1);
userused = atoll(fields[0]);
}
}
Bterm(bp);
if (pgsize > 0 && userpgs > 0 && userused > 0)
size = (userpgs - userused) * pgsize;
}
/* cap it to keep the size within 32 bits */
if (size >= 3840UL * 1024 * 1024)
size = 3840UL * 1024 * 1024;
return size;
}
void
readlife(char *filename)
{
int c, i, j;
char name[256];
Biobuf *bp;
if ((bp = Bopen(filename, OREAD)) == nil) {
snprint(name, sizeof name, "/sys/games/lib/life/%s", filename);
if ((bp = Bopen(name, OREAD)) == nil)
sysfatal("can't read %s: %r", name);
}
draw(screen, screen->r, display->white, nil, ZP);
for (i = 0; i != NLIFE; i++) {
row[i] = col[i] = 0;
for (j = 0; j != NLIFE; j++)
life[i][j] = 0;
}
c = 0;
for (i = 1; i != NLIFE - 1 && c >= 0; i++) {
j = 1;
while ((c = Bgetc(bp)) >= 0 && c != '\n')
if (j != NLIFE - 1)
switch (c) {
case '.':
j++;
break;
case 'x':
birth(i, j);
j++;
break;
}
}
Bterm(bp);
centerlife();
}
void
main(int argc, char **argv)
{
int i;
ARGBEGIN {
# ifdef DEBUG
case 'd': debug++; break;
case 'y': yydebug = TRUE; break;
# endif
case 't': case 'T':
Binit(&fout, 1, OWRITE);
errorf= 2;
foutopen = 1;
break;
case 'v': case 'V':
report = 1;
break;
case 'n': case 'N':
report = 0;
break;
case '9':
nine = 1;
break;
default:
warning("Unknown option %c", ARGC());
} ARGEND
sargc = argc;
sargv = argv;
if (argc > 0){
yyfile = argv[fptr++];
fin = Bopen(yyfile, OREAD);
if(fin == 0)
error ("%s - can't open file: %r", yyfile);
sargc--;
sargv++;
}
else {
yyfile = "/fd/0";
fin = myalloc(sizeof(Biobuf), 1);
if(fin == 0)
exits("core");
Binit(fin, 0, OREAD);
}
if(Bgetc(fin) == Beof) /* no input */
exits(0);
Bseek(fin, 0, 0);
gch();
/* may be gotten: def, subs, sname, stchar, ccl, dchar */
get1core();
/* may be gotten: name, left, right, nullstr, parent, ptr */
strcpy((char*)sp, "INITIAL");
sname[0] = sp;
sp += strlen("INITIAL") + 1;
sname[1] = 0;
if(yyparse()) exits("error"); /* error return code */
/* may be disposed of: def, subs, dchar */
free1core();
/* may be gotten: tmpstat, foll, positions, gotof, nexts, nchar, state, atable, sfall, cpackflg */
get2core();
ptail();
mkmatch();
# ifdef DEBUG
if(debug) pccl();
# endif
sect = ENDSECTION;
if(tptr>0)cfoll(tptr-1);
# ifdef DEBUG
if(debug)pfoll();
# endif
cgoto();
# ifdef DEBUG
if(debug){
print("Print %d states:\n",stnum+1);
for(i=0;i<=stnum;i++)stprt(i);
}
# endif
/* may be disposed of: positions, tmpstat, foll, state, name, left, right, parent, ccl, stchar, sname */
/* may be gotten: verify, advance, stoff */
free2core();
get3core();
layout();
/* may be disposed of: verify, advance, stoff, nexts, nchar,
gotof, atable, ccpackflg, sfall */
# ifdef DEBUG
free3core();
# endif
fother = Bopen(cname,OREAD);
if(fother == 0)
error("Lex driver missing, file %s: %r",cname);
while ( (i=Bgetc(fother)) != Beof)
Bputc(&fout, i);
Bterm(fother);
Bterm(&fout);
if(
# ifdef DEBUG
debug ||
# endif
report == 1)statistics();
if (fin)
Bterm(fin);
exits(0); /* success return code */
}
void
main(int argc, char *argv[])
{
Reprog *exp;
char *pattern = 0;
int n = 1000;
char *line;
int xflag = 0;
int iflag = 0;
Biobuf bin;
Biobuf *b = &bin;
char buf[256];
ARGBEGIN {
case 'l':
case 'n':
n=atoi(EARGF(usage()));
break;
case 'e':
pattern = strdup(EARGF(usage()));
break;
case 'f':
stem = strdup(EARGF(usage()));
break;
case 's':
suffix = strdup(EARGF(usage()));
break;
case 'x':
xflag++;
break;
case 'i':
iflag++;
break;
default:
usage();
break;
} ARGEND;
if(argc < 0 || argc > 1)
usage();
if(argc != 0) {
b = Bopen(argv[0], OREAD);
if(b == nil) {
fprint(2, "split: can't open %s: %r\n", argv[0]);
exits("open");
}
} else
Binit(b, 0, OREAD);
if(pattern) {
Resub match[2];
if(!(exp = regcomp(iflag? fold(pattern, strlen(pattern)):
pattern)))
badexp();
memset(match, 0, sizeof match);
matchfile(match);
while((line=Brdline(b,'\n')) != 0) {
memset(match, 0, sizeof match);
line[Blinelen(b)-1] = 0;
if(regexec(exp, iflag? fold(line, Blinelen(b)-1): line,
match, 2)) {
if(matchfile(match) && xflag)
continue;
} else if(output == 0)
nextfile(); /* at most once */
Bwrite(output, line, Blinelen(b)-1);
Bputc(output, '\n');
}
} else {
int linecnt = n;
while((line=Brdline(b,'\n')) != 0) {
if(++linecnt > n) {
nextfile();
linecnt = 1;
}
Bwrite(output, line, Blinelen(b));
}
/*
* in case we didn't end with a newline, tack whatever's
* left onto the last file
*/
while((n = Bread(b, buf, sizeof(buf))) > 0)
Bwrite(output, buf, n);
}
if(b != nil)
Bterm(b);
exits(0);
}
int
image2psfile(int fd, Memimage *im, int dpi) {
Rectangle r;
Rectangle bbox;
int e;
int xmargin = 36;
int ymargin = 36;
double paperaspectratio;
double imageaspectratio;
Biobuf ioutb;
Memimage *tmp;
if(im->depth >= 8 && im->chan != CMAP8 && im->chan != GREY8){
/*
* the postscript libraries can only handle [1248]-bit grey, 8-bit cmap,
* and 24-bit color, so convert.
*/
tmp = allocmemimage(im->r, strtochan("b8g8r8"));
if(tmp == nil)
return 1;
memimagedraw(tmp, tmp->r, im, im->r.min, nil, ZP, S);
freememimage(im);
im = tmp;
}
Binit(&ioutb, fd, OWRITE);
r = im->r;
width = Dx(r);
height = Dy(r);
imageaspectratio = (double) width / (double) height;
if (landscape) {
paperaspectratio = ((double)paperlength - (ymargin * 2)) / ((double)paperwidth - (xmargin * 2));
if (dpi > 0) {
iwidth = width * 72 / dpi;
iheight = height * 72 / dpi;
} else if (imageaspectratio > paperaspectratio) {
iwidth = paperlength - (ymargin * 2);
iheight = iwidth / imageaspectratio;
} else {
iheight = paperwidth - (xmargin * 2);
iwidth = iheight * imageaspectratio;
}
xstart = paperwidth - xmargin - (iheight * ymagnification);
ystart = paperlength - ymargin;
rotation = -90;
} else {
paperaspectratio = ((double)paperwidth - (xmargin * 2)) / ((double)paperlength - (ymargin * 2));
if (dpi > 0) {
iwidth = width * 72 / dpi;
iheight = height * 72 / dpi;
} else if (imageaspectratio > paperaspectratio) {
iwidth = paperwidth - (xmargin * 2);
iheight = iwidth / imageaspectratio;
} else {
iheight = paperlength - (ymargin * 2);
iwidth = iheight * imageaspectratio;
}
xstart = xmargin;
ystart = paperlength - ymargin - (iheight * ymagnification);
rotation = 0;
}
bbox = Rect(xstart,ystart,xstart+iwidth,ystart+iheight);
e = preamble(&ioutb, bbox);
if(e != 0)
return e;
Bprint(&ioutb, "%%%%Page: 1\n%%%%BeginPageSetup\n");
Bprint(&ioutb, "/pgsave save def\n");
Bprint(&ioutb, "%%%%EndPageSetup\n");
bps = im->depth;
Bprint(&ioutb, "%d 0 %d %d %d %d %d %d %s doimage\n", iheight, iwidth, ystart, xstart, height, width, bps, im->flags&Fgrey ? "true" : "false");
imagebits(&ioutb, im);
Bprint(&ioutb, "pgsave restore\nshowpage\n");
e = trailer(&ioutb, 1);
if(e != 0)
return e;
Bterm(&ioutb);
return 0;
}
void
main(int argc, char *argv[])
{
int i, n, nolines, optout;
char **args, **a, *cp, *buf;
char body[Bodysize+2];
Resub match[1];
Biobuf *bp;
optout = 1;
a = args = Malloc((argc+1)*sizeof(char*));
sprint(patfile, "%s/patterns", UPASLIB);
sprint(linefile, "%s/lines", UPASLOG);
sprint(holdqueue, "%s/queue.hold", SPOOL);
sprint(copydir, "%s/copy", SPOOL);
*a++ = argv[0];
for(argc--, argv++; argv[0] && argv[0][0] == '-'; argc--, argv++) {
switch(argv[0][1]) {
case 'c': /* save copy of message */
cflag = 1;
break;
case 'd': /* debug */
debug++;
*a++ = argv[0];
break;
case 'h': /* queue held messages by sender domain */
hflag = 1; /* -q flag must be set also */
break;
case 'n': /* NOHOLD mode */
nflag = 1;
break;
case 'p': /* pattern file */
if(argv[0][2] || argv[1] == 0)
usage();
argc--;
argv++;
strecpy(patfile, patfile+sizeof patfile, *argv);
break;
case 'q': /* queue name */
if(argv[0][2] || argv[1] == 0)
usage();
*a++ = argv[0];
argc--;
argv++;
qname = a;
*a++ = argv[0];
break;
case 's': /* save copy of dumped message */
sflag = 1;
break;
case 't': /* test mode - don't log match
* and write message to /dev/null
*/
tflag = 1;
break;
case 'v': /* vebose - print matches */
vflag = 1;
break;
default:
*a++ = argv[0];
break;
}
}
if(argc < 3)
usage();
Binit(&bin, 0, OREAD);
bp = Bopen(patfile, OREAD);
if(bp) {
parsepats(bp);
Bterm(bp);
}
qdir = a;
sender = argv[2];
/* copy the rest of argv, acummulating the recipients as we go */
for(i = 0; argv[i]; i++) {
*a++ = argv[i];
if(i < 4) /* skip queue, 'mail', sender, dest sys */
continue;
/* recipients and smtp flags - skip the latter*/
if(strcmp(argv[i], "-g") == 0) {
*a++ = argv[++i];
continue;
}
if(recips)
s_append(recips, ", ");
else
recips = s_new();
s_append(recips, argv[i]);
if(optout && !optoutofspamfilter(argv[i]))
optout = 0;
}
*a = 0;
/* construct a command string for matching */
snprint(cmd, sizeof(cmd)-1, "%s %s", sender, s_to_c(recips));
cmd[sizeof(cmd)-1] = 0;
for(cp = cmd; *cp; cp++)
*cp = tolower(*cp);
/* canonicalize a copy of the header and body.
* buf points to orginal message and n contains
* number of bytes of original message read during
* canonicalization.
*/
*body = 0;
*header = 0;
buf = canon(&bin, header+1, body+1, &n);
if (buf == 0)
exits("read");
/* if all users opt out, don't try matches */
if(optout) {
if(cflag)
cout = opencopy(sender);
exits(qmail(args, buf, n, cout));
}
/* Turn off line logging, if command line matches */
nolines = matchaction(Lineoff, cmd, match);
for(i = 0; patterns[i].action; i++) {
/* Lineoff patterns were already done above */
if(i == Lineoff)
continue;
/* don't apply "Line" patterns if excluded above */
if(nolines && i == SaveLine)
continue;
/* apply patterns to the sender/recips, header and body */
if(matchaction(i, cmd, match))
break;
if(matchaction(i, header+1, match))
break;
if(i == HoldHeader)
continue;
if(matchaction(i, body+1, match))
break;
}
if(cflag && patterns[i].action == 0) /* no match found - save msg */
cout = opencopy(sender);
exits(qmail(args, buf, n, cout));
}
void
objfile(char *file, char *pkg)
{
vlong off, l;
Biobuf *f;
char magbuf[SARMAG];
char pname[150];
struct ar_hdr arhdr;
pkg = smprint("%i", pkg);
if(debug['v'] > 1)
Bprint(&bso, "%5.2f ldobj: %s (%s)\n", cputime(), file, pkg);
Bflush(&bso);
f = Bopen(file, 0);
if(f == nil) {
diag("cannot open file: %s", file);
errorexit();
}
l = Bread(f, magbuf, SARMAG);
if(l != SARMAG || strncmp(magbuf, ARMAG, SARMAG)){
/* load it as a regular file */
l = Bseek(f, 0L, 2);
Bseek(f, 0L, 0);
ldobj(f, pkg, l, file, file, FileObj);
Bterm(f);
free(pkg);
return;
}
/* skip over optional __.GOSYMDEF and process __.PKGDEF */
off = Boffset(f);
l = nextar(f, off, &arhdr);
if(l <= 0) {
diag("%s: short read on archive file symbol header", file);
goto out;
}
if(strncmp(arhdr.name, symname, strlen(symname)) == 0) {
off += l;
l = nextar(f, off, &arhdr);
if(l <= 0) {
diag("%s: short read on archive file symbol header", file);
goto out;
}
}
if(strncmp(arhdr.name, pkgname, strlen(pkgname))) {
diag("%s: cannot find package header", file);
goto out;
}
off += l;
if(debug['u'])
ldpkg(f, pkg, atolwhex(arhdr.size), file, Pkgdef);
/*
* load all the object files from the archive now.
* this gives us sequential file access and keeps us
* from needing to come back later to pick up more
* objects. it breaks the usual C archive model, but
* this is Go, not C. the common case in Go is that
* we need to load all the objects, and then we throw away
* the individual symbols that are unused.
*
* loading every object will also make it possible to
* load foreign objects not referenced by __.GOSYMDEF.
*/
for(;;) {
l = nextar(f, off, &arhdr);
if(l == 0)
break;
if(l < 0) {
diag("%s: malformed archive", file);
goto out;
}
off += l;
l = SARNAME;
while(l > 0 && arhdr.name[l-1] == ' ')
l--;
snprint(pname, sizeof pname, "%s(%.*s)", file, utfnlen(arhdr.name, l), arhdr.name);
l = atolwhex(arhdr.size);
ldobj(f, pkg, l, pname, file, ArchiveObj);
}
out:
Bterm(f);
free(pkg);
}
void
hostlink(void)
{
char *p, **argv;
int c, i, w, n, argc, len;
Hostobj *h;
Biobuf *f;
static char buf[64<<10];
if(linkmode != LinkExternal || nerrors > 0)
return;
c = 0;
p = extldflags;
while(p != nil) {
while(*p == ' ')
p++;
if(*p == '\0')
break;
c++;
p = strchr(p + 1, ' ');
}
argv = malloc((13+nhostobj+nldflag+c)*sizeof argv[0]);
argc = 0;
if(extld == nil)
extld = "gcc";
argv[argc++] = extld;
switch(thechar){
case '8':
argv[argc++] = "-m32";
break;
case '6':
argv[argc++] = "-m64";
break;
case '5':
argv[argc++] = "-marm";
break;
}
if(!debug['s'] && !debug_s) {
argv[argc++] = "-gdwarf-2";
} else {
argv[argc++] = "-s";
}
if(HEADTYPE == Hdarwin)
argv[argc++] = "-Wl,-no_pie,-pagezero_size,4000000";
if(HEADTYPE == Hopenbsd)
argv[argc++] = "-Wl,-nopie";
if(iself && AssumeGoldLinker)
argv[argc++] = "-Wl,--rosegment";
if(flag_shared) {
argv[argc++] = "-Wl,-Bsymbolic";
argv[argc++] = "-shared";
}
argv[argc++] = "-o";
argv[argc++] = outfile;
if(rpath)
argv[argc++] = smprint("-Wl,-rpath,%s", rpath);
// Force global symbols to be exported for dlopen, etc.
if(iself)
argv[argc++] = "-rdynamic";
// already wrote main object file
// copy host objects to temporary directory
for(i=0; i<nhostobj; i++) {
h = &hostobj[i];
f = Bopen(h->file, OREAD);
if(f == nil) {
ctxt->cursym = S;
diag("cannot reopen %s: %r", h->pn);
errorexit();
}
Bseek(f, h->off, 0);
p = smprint("%s/%06d.o", tmpdir, i);
argv[argc++] = p;
w = create(p, 1, 0775);
if(w < 0) {
ctxt->cursym = S;
diag("cannot create %s: %r", p);
errorexit();
}
len = h->len;
while(len > 0 && (n = Bread(f, buf, sizeof buf)) > 0){
if(n > len)
n = len;
dowrite(w, buf, n);
len -= n;
}
if(close(w) < 0) {
ctxt->cursym = S;
diag("cannot write %s: %r", p);
errorexit();
}
Bterm(f);
}
argv[argc++] = smprint("%s/go.o", tmpdir);
for(i=0; i<nldflag; i++)
argv[argc++] = ldflag[i];
p = extldflags;
while(p != nil) {
while(*p == ' ')
*p++ = '\0';
if(*p == '\0')
break;
argv[argc++] = p;
p = strchr(p + 1, ' ');
}
argv[argc] = nil;
quotefmtinstall();
if(debug['v']) {
Bprint(&bso, "host link:");
for(i=0; i<argc; i++)
Bprint(&bso, " %q", argv[i]);
Bprint(&bso, "\n");
Bflush(&bso);
}
if(runcmd(argv) < 0) {
ctxt->cursym = S;
diag("%s: running %s failed: %r", argv0, argv[0]);
errorexit();
}
}
static void
loadfont(int n, int s)
{
char file[256];
int i, fd, t, deep;
static char *try[3] = {"", "times/R.", "pelm/"};
Subfont *f;
Font *ff;
try[0] = fname[n];
for (t = 0; t < 3; t++) {
i = s * mag * charmap[fmap[n]].xheight/0.72; /* a pixel is 0.72 points */
if (i < MINSIZE)
i = MINSIZE;
dprint(2, "size %d, i %d, mag %g\n", s, i, mag);
for(; i >= MINSIZE; i--) {
/* if .font file exists, take that */
snprint(file, sizeof file, "%s/%s%d.font",
libfont, try[t], i);
ff = openfont(display, file);
if(ff != 0) {
fonttab[n][s] = ff;
dprint(2, "using %s for font %d %d\n", file, n, s);
return;
}
/* else look for a subfont file */
for (deep = log2[screen->depth]; deep >= 0; deep--) {
snprint(file, sizeof file, "%s/%s%d.%d",
libfont, try[t], i, deep);
dprint(2, "trying %s for %d\n", file, i);
if ((fd = open(file, 0)) >= 0) {
f = readsubfont(display, file, fd, 0);
if (f == 0) {
fprint(2, "can't rdsubfontfile %s: %r\n", file);
exits("rdsubfont");
}
close(fd);
ff = mkfont(f, 0);
if(ff == 0) {
fprint(2, "can't mkfont %s: %r\n", file);
exits("rdsubfont");
}
fonttab[n][s] = ff;
dprint(2, "using %s for font %d %d\n", file, n, s);
return;
}
}
}
}
fprint(2, "can't find font %s.%d or substitute, quitting\n", fname[n], s);
exits("no font");
}
void
loadfontname(int n, char *s)
{
int i;
Font *f, *g = 0;
if (strcmp(s, fname[n]) == 0)
return;
if(fname[n] && fname[n][0]) {
if(lastload[n] && strcmp(lastload[n], fname[n]) == 0)
return;
strcpy(lastload[n], fname[n]);
}
fontlookup(n, s);
for (i = 0; i < NSIZE; i++)
if (f = fonttab[n][i]) {
if (f != g) {
freefont(f);
g = f;
}
fonttab[n][i] = 0;
}
}
void
allfree(void)
{
int i;
for (i=0; i<NFONT; i++)
loadfontname(i, "??");
}
void
readmapfile(char *file)
{
Biobuf *fp;
char *p, cmd[100];
if ((fp=Bopen(file, OREAD)) == 0) {
fprint(2, "proof: can't open map file %s\n", file);
exits("urk");
}
while((p=Brdline(fp, '\n')) != 0) {
p[Blinelen(fp)-1] = 0;
scanstr(p, cmd, 0);
if(p[0]=='\0' || eq(cmd, "#")) /* skip comments, empty */
continue;
else if(eq(cmd, "xheight"))
buildxheight(fp);
else if(eq(cmd, "map"))
buildmap(fp);
else if(eq(cmd, "special"))
buildtroff(p);
else if(eq(cmd, "troff"))
buildtroff(p);
else
fprint(2, "weird map line %s\n", p);
}
Bterm(fp);
}
void
dumpobj(void)
{
NodeList *externs, *tmp;
char arhdr[ArhdrSize];
vlong startobj, size;
Sym *zero;
bout = Bopen(outfile, OWRITE);
if(bout == nil) {
flusherrors();
print("can't create %s: %r\n", outfile);
errorexit();
}
startobj = 0;
if(writearchive) {
Bwrite(bout, "!<arch>\n", 8);
memset(arhdr, 0, sizeof arhdr);
Bwrite(bout, arhdr, sizeof arhdr);
startobj = Boffset(bout);
}
Bprint(bout, "go object %s %s %s %s\n", getgoos(), getgoarch(), getgoversion(), expstring());
dumpexport();
if(writearchive) {
Bflush(bout);
size = Boffset(bout) - startobj;
if(size&1)
Bputc(bout, 0);
Bseek(bout, startobj - ArhdrSize, 0);
formathdr(arhdr, "__.PKGDEF", size);
Bwrite(bout, arhdr, ArhdrSize);
Bflush(bout);
Bseek(bout, startobj + size + (size&1), 0);
memset(arhdr, 0, ArhdrSize);
Bwrite(bout, arhdr, ArhdrSize);
startobj = Boffset(bout);
Bprint(bout, "go object %s %s %s %s\n", getgoos(), getgoarch(), getgoversion(), expstring());
}
Bprint(bout, "\n!\n");
externs = nil;
if(externdcl != nil)
externs = externdcl->end;
dumpglobls();
dumptypestructs();
// Dump extra globals.
tmp = externdcl;
if(externs != nil)
externdcl = externs->next;
dumpglobls();
externdcl = tmp;
zero = pkglookup("zerovalue", runtimepkg);
ggloblsym(zero, zerosize, 1, 1);
dumpdata();
writeobj(ctxt, bout);
if(writearchive) {
Bflush(bout);
size = Boffset(bout) - startobj;
if(size&1)
Bputc(bout, 0);
Bseek(bout, startobj - ArhdrSize, 0);
snprint(namebuf, sizeof namebuf, "_go_.%c", thechar);
formathdr(arhdr, namebuf, size);
Bwrite(bout, arhdr, ArhdrSize);
}
Bterm(bout);
}
static int
bzip(char *file, long mtime, int ifd, Biobuf *bout)
{
int e, n, done, onemore;
char buf[8192];
char obuf[8192];
Biobuf bin;
bz_stream strm;
USED(file);
USED(mtime);
memset(&strm, 0, sizeof strm);
BZ2_bzCompressInit(&strm, level, verbose, 0);
strm.next_in = buf;
strm.avail_in = 0;
strm.next_out = obuf;
strm.avail_out = sizeof obuf;
done = 0;
Binit(&bin, ifd, OREAD);
/*
* onemore is a crummy hack to go 'round the loop
* once after we finish, to flush the output buffer.
*/
onemore = 1;
SET(e);
do {
if(!done && strm.avail_in < sizeof buf) {
if(strm.avail_in)
memmove(buf, strm.next_in, strm.avail_in);
n = Bread(&bin, buf+strm.avail_in, sizeof(buf)-strm.avail_in);
if(n <= 0)
done = 1;
else
strm.avail_in += n;
strm.next_in = buf;
}
if(strm.avail_out < sizeof obuf) {
Bwrite(bout, obuf, sizeof(obuf)-strm.avail_out);
strm.next_out = obuf;
strm.avail_out = sizeof obuf;
}
if(onemore == 0)
break;
} while((e=BZ2_bzCompress(&strm, done ? BZ_FINISH : BZ_RUN)) == BZ_RUN_OK || e == BZ_FINISH_OK || onemore--);
if(e != BZ_STREAM_END) {
fprint(2, "bzip2: compress failed\n");
return 0;
}
if(BZ2_bzCompressEnd(&strm) != BZ_OK) {
fprint(2, "bzip2: compress end failed (can't happen)\n");
return 0;
}
Bterm(&bin);
return 1;
}
static int
bzipf(char *file, int stdout)
{
Dir *dir;
char ofile[128], *f, *s;
int ifd, ofd, ok;
ifd = open(file, OREAD);
if(ifd < 0){
fprint(2, "bzip2: can't open %s: %r\n", file);
return 0;
}
dir = dirfstat(ifd);
if(dir == nil){
fprint(2, "bzip2: can't stat %s: %r\n", file);
close(ifd);
return 0;
}
if(dir->mode & DMDIR){
fprint(2, "bzip2: can't compress a directory\n");
close(ifd);
free(dir);
return 0;
}
if(stdout){
ofd = 1;
strcpy(ofile, "<stdout>");
}else{
f = strrchr(file, '/');
if(f != nil)
f++;
else
f = file;
s = strrchr(f, '.');
if(s != nil && s != ofile && strcmp(s, ".tar") == 0){
*s = '\0';
snprint(ofile, sizeof(ofile), "%s.tbz", f);
}else
snprint(ofile, sizeof(ofile), "%s.bz2", f);
ofd = create(ofile, OWRITE, 0666);
if(ofd < 0){
fprint(2, "bzip2: can't open %s: %r\n", ofile);
free(dir);
close(ifd);
return 0;
}
}
if(verbose)
fprint(2, "compressing %s to %s\n", file, ofile);
Binit(&bout, ofd, OWRITE);
ok = bzip(file, dir->mtime, ifd, &bout);
if(!ok || Bflush(&bout) < 0){
fprint(2, "bzip2: error writing %s: %r\n", ofile);
if(!stdout)
remove(ofile);
}
Bterm(&bout);
free(dir);
close(ifd);
close(ofd);
return ok;
}
static int
bunzip(int ofd, char *ofile, Biobuf *bin)
{
int e, n, done, onemore;
char buf[8192];
char obuf[8192];
Biobuf bout;
bz_stream strm;
USED(ofile);
memset(&strm, 0, sizeof strm);
BZ2_bzDecompressInit(&strm, verbose, 0);
strm.next_in = buf;
strm.avail_in = 0;
strm.next_out = obuf;
strm.avail_out = sizeof obuf;
done = 0;
Binit(&bout, ofd, OWRITE);
/*
* onemore is a crummy hack to go 'round the loop
* once after we finish, to flush the output buffer.
*/
onemore = 1;
SET(e);
do {
if(!done && strm.avail_in < sizeof buf) {
if(strm.avail_in)
memmove(buf, strm.next_in, strm.avail_in);
n = Bread(bin, buf+strm.avail_in, sizeof(buf)-strm.avail_in);
if(n <= 0)
done = 1;
else
strm.avail_in += n;
strm.next_in = buf;
}
if(strm.avail_out < sizeof obuf) {
Bwrite(&bout, obuf, sizeof(obuf)-strm.avail_out);
strm.next_out = obuf;
strm.avail_out = sizeof obuf;
}
if(onemore == 0)
break;
if(strm.avail_in == 0 && strm.avail_out == sizeof obuf)
break;
} while((e=BZ2_bzDecompress(&strm)) == BZ_OK || onemore--);
if(e != BZ_STREAM_END) {
fprint(2, "bunzip2: decompress failed\n");
return 0;
}
if(BZ2_bzDecompressEnd(&strm) != BZ_OK) {
fprint(2, "bunzip2: decompress end failed (can't happen)\n");
return 0;
}
Bterm(&bout);
return 1;
}
static int
bunzipf(char *file, int stdout)
{
char ofile[64], *s;
int ofd, ifd, ok;
infile = file;
ifd = open(file, OREAD);
if(ifd < 0){
fprint(2, "bunzip2: can't open %s: %r\n", file);
return 0;
}
Binit(&bin, ifd, OREAD);
if(Bgetc(&bin) != 'B' || Bgetc(&bin) != 'Z' || Bgetc(&bin) != 'h'){
fprint(2, "bunzip2: %s is not a bzip2 file\n", file);
Bterm(&bin);
close(ifd);
return 0;
}
Bungetc(&bin);
Bungetc(&bin);
Bungetc(&bin);
if(stdout){
ofd = 1;
strcpy(ofile, "<stdout>");
}else{
s = strrchr(file, '/');
if(s != nil)
s++;
else
s = file;
strecpy(ofile, ofile+sizeof ofile, s);
s = strrchr(ofile, '.');
if(s != nil && s != ofile && strcmp(s, ".bz2") == 0)
*s = '\0';
else if(s != nil && (strcmp(s, ".tbz") == 0 || strcmp(s, ".tbz2") == 0))
strcpy(s, ".tar");
else if(strcmp(file, ofile) == 0){
fprint(2, "bunzip2: can't overwrite %s\n", file);
Bterm(&bin);
close(ifd);
return 0;
}
ofd = create(ofile, OWRITE, 0666);
if(ofd < 0){
fprint(2, "bunzip2: can't create %s: %r\n", ofile);
Bterm(&bin);
close(ifd);
return 0;
}
delfile = ofile;
}
ok = bunzip(ofd, ofile, &bin);
Bterm(&bin);
close(ifd);
if(!ok){
fprint(2, "bunzip2: can't write %s: %r\n", ofile);
if(delfile)
remove(delfile);
}
delfile = nil;
if(!stdout && ofd >= 0)
close(ofd);
return ok;
}
void
main(int argc, char *argv[])
{
int i, fd, n, aflag, vflag;
char body[Bodysize+2], *raw, *ret;
Biobuf *bp;
sprint(patfile, "%s/patterns", UPASLIB);
aflag = -1;
vflag = 0;
ARGBEGIN {
case 'a':
aflag = 1;
break;
case 'v':
vflag = 1;
break;
case 'd':
debug++;
break;
case 'p':
strcpy(patfile,ARGF());
break;
} ARGEND
bp = Bopen(patfile, OREAD);
if(bp){
parsepats(bp);
Bterm(bp);
}
if(argc >= 1){
fd = open(*argv, OREAD);
if(fd < 0){
fprint(2, "can't open %s\n", *argv);
exits("open");
}
Binit(&bin, fd, OREAD);
} else
Binit(&bin, 0, OREAD);
*body = 0;
*header = 0;
ret = 0;
for(;;){
raw = canon(&bin, header+1, body+1, &n);
if(raw == 0)
break;
if(aflag == 0)
continue;
if(aflag < 0)
aflag = 0;
if(vflag){
if(header[1]) {
fprint(2, "\t**** Header ****\n\n");
write(2, header+1, strlen(header+1));
fprint(2, "\n");
}
fprint(2, "\t**** Body ****\n\n");
if(body[1])
write(2, body+1, strlen(body+1));
fprint(2, "\n");
}
for(i = 0; patterns[i].action; i++){
if(matchaction(&patterns[i], header+1))
ret = patterns[i].action;
if(i == HoldHeader)
continue;
if(matchaction(&patterns[i], body+1))
ret = patterns[i].action;
}
}
exits(ret);
}
void
main(int argc, char **argv)
{
int i, hdr, n, eof, off;
Dreprog *re[3];
int m[3];
char *p, *ep, *tag;
Biobuf bout, bin;
char msg[1024+1];
char buf[1024];
refile = unsharp(refile);
buildre(re);
ARGBEGIN{
case 'D':
debug = 1;
break;
case 'n':
maxtoklen = atoi(EARGF(usage()));
break;
case 'r':
refile = EARGF(usage());
break;
default:
usage();
}ARGEND;
if(argc > 1)
usage();
if(argc == 1){
close(0);
if(open(argv[0], OREAD) < 0)
sysfatal("open %s: %r", argv[0]);
}
tag = nil;
Binit(&bin, 0, OREAD);
Binit(&bout, 1, OWRITE);
ep = msg;
p = msg;
eof = 0;
off = 0;
hdr = 1;
for(;;){
/* replenish buffer */
if(ep - p < 512 && !eof){
if(p > msg + 1){
n = ep - p;
memmove(msg, p-1, ep-(p-1));
off += (p-1) - msg;
p = msg+1;
ep = p + n;
}
n = Bread(&bin, ep, msg+(sizeof msg - 1)- ep);
if(n < 0)
sysfatal("read error: %r");
if(n == 0)
eof = 1;
ep += n;
*ep = 0;
}
if(p >= ep)
break;
if(*p == 0){
p++;
continue;
}
if(hdr && p[-1]=='\n'){
if(p[0]=='\n')
hdr = 0;
else if(cistrncmp(p-1, "\nfrom:", 6) == 0)
tag = "From*";
else if(cistrncmp(p-1, "\nto:", 4) == 0)
tag = "To*";
else if(cistrncmp(p-1, "\nsubject:", 9) == 0)
tag = "Subject*";
else if(cistrncmp(p-1, "\nreturn-path:", 13) == 0)
tag = "Return-Path*";
else
tag = nil;
}
m[0] = dregexec(re[0], p, p==msg || p[-1]=='\n');
m[1] = dregexec(re[1], p, p==msg || p[-1]=='\n');
m[2] = dregexec(re[2], p, p==msg || p[-1]=='\n');
n = m[0];
if(n < m[1])
n = m[1];
if(n < m[2])
n = m[2];
if(n <= 0){
fprint(2, "«%s» %.2ux", p, p[0]);
sysfatal("no regexps matched at %ld", off + (p-msg));
}
if(m[0] >= m[1] && m[0] >= m[2]){
/* "From " marks start of new message */
Bprint(&bout, "*From*\n");
n = m[0];
hdr = 1;
}else if(m[2] > 1){
/* ignore */
n = m[2];
}else if(m[1] >= m[0] && m[1] >= m[2] && m[1] > 2 && m[1] <= maxtoklen){
/* keyword */
/* should do UTF-aware lowercasing, too much bother */
/*
for(i=0; i<n; i++)
if('A' <= p[i] && p[i] <= 'Z')
p[i] += 'a' - 'A';
*/
if(tag){
i = strlen(tag);
memmove(buf, tag, i);
memmove(buf+i, p, m[1]);
buf[i+m[1]] = 0;
}else{
memmove(buf, p, m[1]);
buf[m[1]] = 0;
}
Bprint(&bout, "%s\n", buf);
while(trim(buf) >= 0)
Bprint(&bout, "stem*%s\n", buf);
n = m[1];
}else
n = m[2];
if(debug)
fprint(2, "%.*s¦", utfnlen(p, n), p);
p += n;
}
Bterm(&bout);
exits(0);
}
static int
nsop(char *fn, int argc, char *argv[], AuthRpc *rpc)
{
char *argv0;
ulong flags;
int fd, i;
Biobuf *b;
int cdroot;
cdroot = 0;
flags = 0;
argv0 = 0;
if (newnsdebug){
for (i = 0; i < argc; i++)
fprint(2, "%s ", argv[i]);
fprint(2, "\n");
}
ARGBEGIN{
case 'a':
flags |= MAFTER;
break;
case 'b':
flags |= MBEFORE;
break;
case 'c':
flags |= MCREATE;
break;
case 'C':
flags |= MCACHE;
break;
}ARGEND
if(!(flags & (MAFTER|MBEFORE)))
flags |= MREPL;
if(strcmp(argv0, ".") == 0 && argc == 1){
b = Bopen(argv[0], OREAD);
if(b == nil)
return 0;
cdroot |= nsfile(fn, b, rpc);
Bterm(b);
}else if(strcmp(argv0, "clear") == 0 && argc == 0)
rfork(RFCNAMEG);
else if(strcmp(argv0, "bind") == 0 && argc == 2){
if(bind(argv[0], argv[1], flags) < 0 && newnsdebug)
fprint(2, "%s: bind: %s %s: %r\n", fn, argv[0], argv[1]);
}else if(strcmp(argv0, "unmount") == 0){
if(argc == 1)
unmount(nil, argv[0]);
else if(argc == 2)
unmount(argv[0], argv[1]);
}else if(strcmp(argv0, "mount") == 0){
fd = open(argv[0], ORDWR);
if(argc == 2){
if(famount(fd, rpc, argv[1], flags, "") < 0 && newnsdebug)
fprint(2, "%s: mount: %s %s: %r\n", fn, argv[0], argv[1]);
}else if(argc == 3){
if(famount(fd, rpc, argv[1], flags, argv[2]) < 0 && newnsdebug)
fprint(2, "%s: mount: %s %s %s: %r\n", fn, argv[0], argv[1], argv[2]);
}
close(fd);
}else if(strcmp(argv0, "import") == 0){
fd = callexport(argv[0], argv[1]);
if(argc == 2)
famount(fd, rpc, argv[1], flags, "");
else if(argc == 3)
famount(fd, rpc, argv[2], flags, "");
close(fd);
}else if(strcmp(argv0, "cd") == 0 && argc == 1){
if(chdir(argv[0]) == 0 && *argv[0] == '/')
cdroot = 1;
}
return cdroot;
}
/*
* perform the 'r' and 'u' commands
*/
void
arcmd(char *arname, int count, char **files)
{
int fd;
int i;
Arfile *ap;
Armember *bp;
Dir *d;
Biobuf *bfile;
fd = openar(arname, ORDWR, 1);
if (fd >= 0) {
Binit(&bar, fd, OREAD);
Bseek(&bar,seek(fd,0,1), 1);
}
astart = newtempfile(artemp);
ap = astart;
aend = 0;
for(i = 0; fd >= 0; i++) {
bp = getdir(&bar);
if (!bp)
break;
if (bamatch(file, poname)) { /* check for pivot */
aend = newtempfile(tailtemp);
ap = aend;
}
/* pitch symdef file */
if (i == 0 && strcmp(file, symdef) == 0) {
skip(&bar, bp->size);
continue;
}
if (count && !match(count, files)) {
scanobj(&bar, ap, bp->size);
arcopy(&bar, ap, bp);
continue;
}
bfile = Bopen(file, OREAD);
if (!bfile) {
if (count != 0)
fprint(2, "ar: cannot open %s\n", file);
scanobj(&bar, ap, bp->size);
arcopy(&bar, ap, bp);
continue;
}
d = dirfstat(Bfildes(bfile));
if (d == nil)
fprint(2, "ar: cannot stat %s: %r\n", file);
if (uflag && (d == nil || d->mtime <= bp->date)) {
scanobj(&bar, ap, bp->size);
arcopy(&bar, ap, bp);
Bterm(bfile);
free(d);
continue;
}
mesg('r', file);
skip(&bar, bp->size);
scanobj(bfile, ap, d->length);
free(d);
armove(bfile, ap, bp);
Bterm(bfile);
}
if(fd >= 0)
close(fd);
/* copy in remaining files named on command line */
for (i = 0; i < count; i++) {
file = files[i];
if(file == 0)
continue;
files[i] = 0;
bfile = Bopen(file, OREAD);
if (!bfile)
fprint(2, "ar: %s cannot open\n", file);
else {
mesg('a', file);
d = dirfstat(Bfildes(bfile));
if (d == nil)
fprint(2, "ar: can't stat %s: %r\n", file);
else {
scanobj(bfile, astart, d->length);
armove(bfile, astart, newmember());
free(d);
}
Bterm(bfile);
}
}
if(fd < 0 && !cflag)
install(arname, astart, 0, aend, 1); /* issue 'creating' msg */
else
install(arname, astart, 0, aend, 0);
}
void
spout(int fd, char *name)
{
char *s, *t, *w;
Rune r;
int inword, wordchar;
int n, wn, wid, c, m;
char buf[1024];
Binit(&b, fd, OREAD);
n = 0;
wn = 0;
while((s = Brdline(&b, '\n')) != nil){
if(s[0] == '.')
for(c=0; c<3 && *s>' '; c++){
n++;
s++;
}
inword = 0;
w = s;
t = s;
do{
c = *(uchar*)t;
if(c < Runeself)
wid = 1;
else{
wid = chartorune(&r, t);
c = r;
}
wordchar = 0;
if(isalpha(c))
wordchar = 1;
if(inword && !wordchar){
if(c=='\'' && isalpha(t[1]))
goto Continue;
m = t-w;
if(m > 1){
memmove(buf, w, m);
buf[m] = 0;
Bprint(&bout, "%s:#%d,#%d:%s\n", name, wn, n, buf);
}
inword = 0;
}else if(!inword && wordchar){
wn = n;
w = t;
inword = 1;
}
if(c=='\\' && (isalpha(t[1]) || t[1]=='(')){
switch(t[1]){
case '(':
m = 4;
break;
case 'f':
if(t[2] == '(')
m = 5;
else
m = 3;
break;
case 's':
if(t[2] == '+' || t[2]=='-'){
if(t[3] == '(')
m = 6;
else
m = 4;
}else{
if(t[2] == '(')
m = 5;
else if(t[2]=='1' || t[2]=='2' || t[2]=='3')
m = 4;
else
m = 3;
}
break;
default:
m = 2;
}
while(m-- > 0){
if(*t == '\n')
break;
n++;
t++;
}
continue;
}
Continue:
n++;
t += wid;
}while(c != '\n');
}
Bterm(&b);
}
/*
* try a message
*/
void
dofile(Dir *dp)
{
Dir *d;
int dfd, ac, dtime, efd, pid, i, etime;
char *buf, *cp, **av;
Waitmsg *wm;
Biobuf *b;
Mlock *l = nil;
if(debug)
fprint(2, "dofile %s\n", dp->name);
/*
* if no data file or empty control or data file, just clean up
* the empty control file must be 15 minutes old, to minimize the
* chance of a race.
*/
d = dirstat(file(dp->name, 'D'));
if(d == nil){
syslog(0, runqlog, "no data file for %s", dp->name);
remmatch(dp->name);
return;
}
if(dp->length == 0){
if(time(0)-dp->mtime > 15*60){
syslog(0, runqlog, "empty ctl file for %s", dp->name);
remmatch(dp->name);
}
return;
}
dtime = d->mtime;
free(d);
/*
* retry times depend on the age of the errors file
*/
if(!Eflag && (d = dirstat(file(dp->name, 'E'))) != nil){
etime = d->mtime;
free(d);
if(etime - dtime < 15*60){
/* up to the first 15 minutes, every 30 seconds */
if(time(0) - etime < 30)
return;
} else if(etime - dtime < 60*60){
/* up to the first hour, try every 15 minutes */
if(time(0) - etime < 15*60)
return;
} else {
/* after the first hour, try once an hour */
if(time(0) - etime < 60*60)
return;
}
}
/*
* open control and data
*/
b = sysopen(file(dp->name, 'C'), "rl", 0660);
if(b == 0) {
if(debug)
fprint(2, "can't open %s: %r\n", file(dp->name, 'C'));
return;
}
dfd = open(file(dp->name, 'D'), OREAD);
if(dfd < 0){
if(debug)
fprint(2, "can't open %s: %r\n", file(dp->name, 'D'));
Bterm(b);
sysunlockfile(Bfildes(b));
return;
}
/*
* make arg list
* - read args into (malloc'd) buffer
* - malloc a vector and copy pointers to args into it
*/
buf = malloc(dp->length+1);
if(buf == 0){
warning("buffer allocation", 0);
Bterm(b);
sysunlockfile(Bfildes(b));
close(dfd);
return;
}
if(Bread(b, buf, dp->length) != dp->length){
warning("reading control file %s\n", dp->name);
Bterm(b);
sysunlockfile(Bfildes(b));
close(dfd);
free(buf);
return;
}
buf[dp->length] = 0;
av = malloc(2*sizeof(char*));
if(av == 0){
warning("argv allocation", 0);
close(dfd);
free(buf);
Bterm(b);
sysunlockfile(Bfildes(b));
return;
}
for(ac = 1, cp = buf; *cp; ac++){
while(isspace(*cp))
*cp++ = 0;
if(*cp == 0)
break;
av = realloc(av, (ac+2)*sizeof(char*));
if(av == 0){
warning("argv allocation", 0);
close(dfd);
free(buf);
Bterm(b);
sysunlockfile(Bfildes(b));
return;
}
av[ac] = cp;
while(*cp && !isspace(*cp)){
if(*cp++ == '"'){
while(*cp && *cp != '"')
cp++;
if(*cp)
cp++;
}
}
}
av[0] = cmd;
av[ac] = 0;
if(!Eflag &&time(0) - dtime > giveup){
if(returnmail(av, dp->name, "Giveup") != 0)
logit("returnmail failed", dp->name, av);
remmatch(dp->name);
goto done;
}
for(i = 0; i < nbad; i++){
if(strcmp(av[3], badsys[i]) == 0)
goto done;
}
/*
* Ken's fs, for example, gives us 5 minutes of inactivity before
* the lock goes stale, so we have to keep reading it.
*/
l = keeplockalive(file(dp->name, 'C'), Bfildes(b));
/*
* transfer
*/
pid = fork();
switch(pid){
case -1:
sysunlock(l);
sysunlockfile(Bfildes(b));
syslog(0, runqlog, "out of procs");
exits(0);
case 0:
if(debug) {
fprint(2, "Starting %s", cmd);
for(ac = 0; av[ac]; ac++)
fprint(2, " %s", av[ac]);
fprint(2, "\n");
}
logit("execing", dp->name, av);
close(0);
dup(dfd, 0);
close(dfd);
close(2);
efd = open(file(dp->name, 'E'), OWRITE);
if(efd < 0){
if(debug) syslog(0, "runq", "open %s as %s: %r", file(dp->name,'E'), getuser());
efd = create(file(dp->name, 'E'), OWRITE, 0666);
if(efd < 0){
if(debug) syslog(0, "runq", "create %s as %s: %r", file(dp->name, 'E'), getuser());
exits("could not open error file - Retry");
}
}
seek(efd, 0, 2);
exec(cmd, av);
error("can't exec %s", cmd);
break;
default:
for(;;){
wm = wait();
if(wm == nil)
error("wait failed: %r", "");
if(wm->pid == pid)
break;
free(wm);
}
if(debug)
fprint(2, "wm->pid %d wm->msg == %s\n", wm->pid, wm->msg);
if(wm->msg[0]){
if(debug)
fprint(2, "[%d] wm->msg == %s\n", getpid(), wm->msg);
syslog(0, runqlog, "message: %s\n", wm->msg);
if(strstr(wm->msg, "Ignore") != nil){
/* fix for fish/chips, leave message alone */
logit("ignoring", dp->name, av);
}else if(!Rflag && strstr(wm->msg, "Retry")==0){
/* return the message and remove it */
if(returnmail(av, dp->name, wm->msg) != 0)
logit("returnmail failed", dp->name, av);
remmatch(dp->name);
} else {
/* add sys to bad list and try again later */
nbad++;
badsys = realloc(badsys, nbad*sizeof(char*));
badsys[nbad-1] = strdup(av[3]);
}
} else {
/* it worked remove the message */
remmatch(dp->name);
}
free(wm);
}
done:
if (l)
sysunlock(l);
Bterm(b);
sysunlockfile(Bfildes(b));
free(buf);
free(av);
close(dfd);
}
/*
* check for expiration
*/
void
douser(Fs *f, char *user)
{
int n, nwarn;
char buf[128];
int32_t rcvrs, et, now;
char *l;
snprint(buf, sizeof buf, "%s/expire", user);
et = readnumfile(buf);
now = time(0);
/* start warning 2 weeks ahead of time */
if(et <= now || et > now+14*24*60*60)
return;
snprint(buf, sizeof buf, "%s/warnings", user);
nwarn = readnumfile(buf);
if(et <= now+14*24*60*60 && et > now+7*24*60*60){
/* one warning 2 weeks before expiration */
if(nwarn > 0)
return;
nwarn = 1;
} else {
/* one warning 1 week before expiration */
if(nwarn > 1)
return;
nwarn = 2;
}
/*
* if we can't open the who file, just mail to the user and hope
* for it makes it.
*/
if(f->b){
if(Bseek(f->b, 0, 0) < 0){
Bterm(f->b);
f->b = 0;
}
}
if(f->b == 0){
f->b = Bopen(f->who, OREAD);
if(f->b == 0){
if(mail(f, user, user, et) > 0)
writenumfile(buf, nwarn);
return;
}
}
/*
* look for matches in the who file and mail to every address on
* matching lines
*/
rcvrs = 0;
while((l = Brdline(f->b, '\n')) != nil){
n = strlen(user);
if(strncmp(l, user, n) == 0 && (l[n] == ' ' || l[n] == '\t'))
rcvrs += mailin(f, user, et, l, l+Blinelen(f->b));
}
/*
* if no matches, try the user directly
*/
if(rcvrs == 0)
rcvrs = mail(f, user, user, et);
rcvrs += mail(f, "netkeys", user, et);
if(rcvrs)
writenumfile(buf, nwarn);
}
