shithub: riscv

ref: 466cf20d3524b8e42edc333a6d2df2a01e99a95b
dir: /sys/src/cmd/upas/ned/nedmail.c/

#include "common.h"
#include <ctype.h>
#include <plumb.h>
#include <regexp.h>

typedef struct Cmd Cmd;
typedef struct Ctype Ctype;
typedef struct Dirstats Dirstats;
typedef struct Message Message;
typedef Message* (Mfn)(Cmd*,Message*);

enum{
	/* nflags */
	Nmissing	= 1<<0,
	Nnoflags	= 1<<1,

	Narg	= 32,
};

struct Message {
	Message	*next;
	Message	*prev;
	Message	*cmd;
	Message	*child;
	Message	*parent;
	char	*path;
	int	id;
	int	len;
	int	fileno;	/* number of directory */
	char	*info;
	char	*from;
	char	*to;
	char	*cc;
	char	*replyto;
	char	*date;
	char	*subject;
	char	*type;
	char	*disposition;
	char	*filename;
	uchar	flags;
	uchar	nflags;
};
#pragma varargck	type	"D"	Message*

enum{
	Display	= 1<<0,
	Rechk	= 1<<1,	/* always use file to check content type */
};

struct Ctype {
	char	*type;
	char 	*ext;
	uchar	flag;
	char	*plumbdest;
	Ctype	*next;
};

/* first element is the default return value */
Ctype ctype[] = {
	{ "application/octet-stream", 	"bin", 	Rechk, 	0,	0,	},
	{ "text/plain",			"txt",	Display,	0	},
	{ "text/html",			"htm",	Display,	0	},
	{ "text/html",			"html",	Display,	0	},
	{ "text/tab-separated-values",	"tsv",	Display,	0	},
	{ "text/richtext",			"rtx",	Display,	0	},
	{ "text/rtf",			"rtf",	Display,	0	},
	{ "text",				"txt",	Display,	0	},
	{ "message/rfc822",		"msg",	0,	0	},
	{ "image/bmp",			"bmp",	0,	"image"	},
	{ "image/jpg",			"jpg",	0,	"image"	},
	{ "image/jpeg",			"jpg",	0,	"image"	},
	{ "image/gif",			"gif",	0,	"image"	},
	{ "image/png",			"png",	0,	"image"	},
	{ "image/x-png",			"png",	0,	"image"	},
	{ "image/tiff",			"tif",	0,	"image"	},
	{ "application/pdf",		"pdf",	0,	"postscript"	},
	{ "application/postscript",		"ps",	0,	"postscript"	},
	{ "application/vnd.openxmlformats-officedocument.wordprocessingml.document",		"docx",	0,	"docx"	},
	{ "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",		"xlsx",	0,	"xlsx"	},
	{ "application/",			0,	0,	0	},
	{ "image/",			0,	0,	0	},
	{ "multipart/",			"mul",	0,	0	},

};

struct Dirstats {
	int	new;
	int	del;
	int	old;
	int	unread;
};

Mfn	acmd;
Mfn	bangcmd;
Mfn	bcmd;
Mfn	dcmd;
Mfn	eqcmd;
Mfn	Fcmd;
Mfn	fcmd;
Mfn	fqcmd;
Mfn	Hcmd;
Mfn	hcmd;
Mfn	helpcmd;
Mfn	icmd;
Mfn	Kcmd;
Mfn	kcmd;
Mfn	mbcmd;
Mfn	mcmd;
Mfn	Pcmd;
Mfn	pcmd;
Mfn	pipecmd;
Mfn	qcmd;
Mfn	quotecmd;
Mfn	rcmd;
Mfn	rpipecmd;
Mfn	scmd;
Mfn	tcmd;
Mfn	ucmd;
Mfn	wcmd;
Mfn	xcmd;
Mfn	ycmd;

struct {
	char	*cmd;
	int	args;
	int	addr;
	Mfn	*f;
	char	*help;
} cmdtab[] = {
	{ "a",	1, 1,	acmd,	"a\t"		"reply to sender and recipients" },
	{ "A",	1, 0,	acmd,	"A\t"		"reply to sender and recipients with copy" },
	{ "b",	0, 0,	bcmd,	"b\t"		"print the next 10 headers" },
	{ "d",	0, 1,	dcmd,	"d\t"		"mark for deletion" },
	{ "F",	1, 1,	Fcmd,	"f\t"		"set message flags [+-][aDdfrSs]" },
	{ "f",	0, 1,	fcmd,	"f\t"		"file message by from address" },
	{ "fq",	0, 1,	fqcmd,	"fq\t"		"print mailbox f appends" },
	{ "H",	0, 0,	Hcmd,	"H\t"		"print message's MIME structure" },
	{ "h",	0, 0,	hcmd,	"h\t"		"print message summary (,h for all)" },
	{ "help", 0, 0,	helpcmd, "help\t"		"print this info" },
	{ "i",	0, 0,	icmd,	"i\t"		"incorporate new mail" },
	{ "k",	1, 1,	kcmd,	"k [flags]\t"	"mark mail" },
	{ "K",	1, 1,	Kcmd,	"K [flags]\t"	"unmark mail" },
	{ "m",	1, 1,	mcmd,	"m addr\t"	"forward mail" },
	{ "M",	1, 0,	mcmd,	"M addr\t"	"forward mail with message" },
	{ "mb",	1, 0,	mbcmd,	"mb mbox\t"	"switch mailboxes" },
	{ "p",	1, 0,	pcmd,	"p\t"		"print the processed message" },
	{ "P",	0, 0,	Pcmd,	"P\t"		"print the raw message" },
	{ "\"",	0, 0,	quotecmd, "\"\t"		"print a quoted version of msg" },
	{ "\"\"",	0, 0,	quotecmd, "\"\"\t"		"format and quote message" },
	{ "q",	0, 0,	qcmd,	"q\t"		"exit and remove all deleted mail" },
	{ "r",	1, 1,	rcmd,	"r [addr]\t"	"reply to sender plus any addrs specified" },
	{ "rf",	1, 0,	rcmd,	"rf [addr]\t"	"file message and reply" },
	{ "R",	1, 0,	rcmd,	"R [addr]\t"	"reply including copy of message" },
	{ "Rf",	1, 0,	rcmd,	"Rf [addr]\t"	"file message and reply with copy" },
	{ "s",	1, 1,	scmd,	"s file\t"		"append raw message to file" },
	{ "t",	1, 0,	tcmd,	"t\t"		"text formatter" },
	{ "u",	0, 0,	ucmd,	"u\t"		"remove deletion mark" },
	{ "w",	1, 1,	wcmd,	"w file\t"		"store message contents as file" },
	{ "x",	0, 0,	xcmd,	"x\t"		"exit without flushing deleted messages" },
	{ "y",	0, 0,	ycmd,	"y\t"		"synchronize with mail box" },
	{ "=",	1, 0,	eqcmd,	"=\t"		"print current message number" },
	{ "|",	1, 1,	pipecmd, "|cmd\t"		"pipe message body to a command" },
	{ "||",	1, 1,	rpipecmd, "||cmd\t"	"pipe raw message to a command" },
	{ "!",	1, 0,	bangcmd, "!cmd\t"		"run a command" },
};

struct Cmd {
	Message	*msgs;
	Mfn	*f;
	int	an;
	char	*av[Narg];
	char	cmdline[2*1024];
	int	delete;
};

int		dir2message(Message*, int, Dirstats*);
int		mdir2message(Message*);
char*		extendp(char*, char*);
char*		parsecmd(char*, Cmd*, Message*, Message*);
void		system(Message*, char*, char**, int);
int		switchmb(char *, int);
void		closemb(void);
Message*	dosingleton(Message*, char*);
char*		rooted(char*);
int		plumb(Message*, Ctype*);
void		exitfs(char*);
Message*	flushdeleted(Message*);

int	didopen;
int	doflush;
int	interrupted;
int	longestfrom = 12;
int	longestto = 12;
int	hcmdfmt;
Qid	mbqid;
int	mbvers;
char	mbname[Pathlen];
char	mbpath[Pathlen];
int	natural;
Biobuf	out;
int	reverse;
char	root[Pathlen];
int	rootlen;
int	startedfs;
Message	top;
char	*user;
char	homewd[Pathlen];
char	wd[Pathlen];
char	textfmt[Pathlen];

char*
idfmt(char *p, char *e, Message *m)
{
	char buf[32];
	int sz, l;

	for(; (sz = e - p) > 0; ){
		l = snprint(buf, sizeof buf, "%d", m->id);
		if(l + 1 > sz)
			return "*GOK*";
		e -= l;
		memcpy(e, buf, l);
		if((m = m->parent) == &top)
			break;
		e--;
		*e = '.';
	}
	return e;
}

int
eprint(char *fmt, ...)
{
	int n;
	va_list args;

	Bflush(&out);

	va_start(args, fmt);
	n = vfprint(2, fmt, args);
	va_end(args);
	return n;
}

void
dissappeared(void)
{
	char buf[ERRMAX];

	rerrstr(buf, sizeof buf);
	if(strstr(buf, "hungup channel")){
		eprint("\n!she's dead, jim\n");
		exits(buf);
	}
	eprint("!message dissappeared\n");
}

int
Dfmt(Fmt *f)
{
	char *e, buf[128];
	Message *m;

	m = va_arg(f->args, Message*);
	if(m == nil)
		return fmtstrcpy(f, "*GOK*");
	if(m == &top)
		return 0;
	e = buf + sizeof buf - 1;
	*e = 0;
	return fmtstrcpy(f, idfmt(buf, e, m));
}

char*
readline(char *prompt, char *line, int len)
{
	char *p, *e, *q;
	int n, dump;

	e = line + len;
retry:
	dump = 0;
	interrupted = 0;
	eprint("%s", prompt);
	for(p = line;; p += n){
		if(p == e){
			dump = 1;
			p = line;
		}
		n = read(0, p, e - p);
		if(n < 0){
			if(interrupted)
				goto retry;
			return nil;
		}
		if(n == 0)
			return nil;
		if(q = memchr(p, '\n', n)){
			if(dump){
				eprint("!line too long\n");
				goto retry;
			}
			p = q;
			break;
		}
	}
	*p = 0;
	return line;
}

void
usage(void)
{
	fprint(2, "usage: %s [-nrt] [-f mailfile] [-s mailfile]\n", argv0);
	fprint(2, "       %s -c dir\n", argv0);
	exits("usage");
}

void
catchnote(void*, char *note)
{
	if(strstr(note, "interrupt") != nil){
		interrupted = 1;
		noted(NCONT);
	}
	noted(NDFLT);
}

char*
plural(int n)
{
	if (n == 1)
		return "";
	return "s";	
}

void
main(int argc, char **argv)
{
	char cmdline[2*1024], prompt[64], *err, *av[4], *mb;
	int n, cflag, singleton;
	Cmd cmd;
	Ctype *cp;
	Message *cur, *m, *x;

	Binit(&out, 1, OWRITE);

	mb = nil;
	singleton = 0;
	reverse = 1;
	cflag = 0;
	ARGBEGIN {
	case 'c':
		cflag = 1;
		break;
	case 's':
		singleton = 1;
	case 'f':
		mb = EARGF(usage());
		break;
	case 'r':
		reverse = 0;
		break;
	case 'n':
		natural = 1;
		reverse = 0;
		break;
	case 't':
		hcmdfmt = 1;
		break;
	default:
		usage();
		break;
	} ARGEND;

	fmtinstall('D', Dfmt);
	quotefmtinstall();
	doquote = needsrcquote;
	getwd(homewd, sizeof homewd);
	user = getlog();
	if(user == nil || *user == 0)
		sysfatal("can't read user name");

	if(cflag){
		if(argc > 0)
			n = creatembox(user, argv[0]);
		else
			n = creatembox(user, nil);
		exits(n? 0: "fail");
	}

	if(argc)
		usage();

	if(access("/mail/fs/ctl", 0) < 0){
		startedfs = 1;
		av[0] = "fs";
		av[1] = "-p";
		av[2] = 0;
		system(nil, "/bin/upas/fs", av, -1);
	}

	switchmb(mb, singleton);
	top.path = strdup(root);
	for(cp = ctype; cp < ctype + nelem(ctype) - 1; cp++)
		cp->next = cp + 1;

	if(singleton){
		cur = dosingleton(&top, mb);
		if(cur == nil){
			eprint("no message\n");
			exitfs(0);
		}
		pcmd(nil, cur);
	} else {
		cur = &top;
		if(icmd(nil, cur) == nil)
			sysfatal("can't read %s", top.path);
	}

	notify(catchnote);
	for(;;){
		snprint(prompt, sizeof prompt, "%D: ", cur);

		/*
		 * leave space at the end of cmd line in case parsecmd needs to
		 * add a space after a '|' or '!'
		 */
		if(readline(prompt, cmdline, sizeof cmdline - 1) == nil)
			break;
		err = parsecmd(cmdline, &cmd, top.child, cur);
		if(err != nil){
			eprint("!%s\n", err);
			continue;
		}
		if(singleton && (cmd.f == icmd || cmd.f == ycmd)){
			eprint("!illegal command\n");
			continue;
		}
		interrupted = 0;
		if(cmd.msgs == nil || cmd.msgs == &top){
			if(x = cmd.f(&cmd, &top))
				cur = x;
		} else for(m = cmd.msgs; m != nil; m = m->cmd){
			x = m;
			if(cmd.delete){
				dcmd(&cmd, x);

				/*
				 * dp acts differently than all other commands
				 * since its an old lesk idiom that people love.
				 * it deletes the current message, moves the current
				 * pointer ahead one and prints.
				 */
				if(cmd.f == pcmd){
					if(x->next == nil){
						eprint("!address\n");
						cur = x;
						break;
					} else
						x = x->next;
				}
			}
			x = cmd.f(&cmd, x);
			if(x != nil)
				cur = x;
			if(interrupted)
				break;
			if(singleton && (cmd.delete || cmd.f == dcmd))
				qcmd(nil, nil);
		}
		if(doflush)
			cur = flushdeleted(cur);
	}
	qcmd(nil, nil);
}

char*
file2string(char *dir, char *file)
{
	int fd, n;
	char *s, *p, *e;

	p = s = malloc(512);
	e = p + 511;

	fd = open(extendp(dir, file), OREAD);
	while((n = read(fd, p, e - p)) > 0){
		p += n;
		if(p == e){
			s = realloc(s, (n = p - s) + 512 + 1);
			if(s == nil)
				sysfatal("malloc: %r");
			p = s + n;
			e = p + 512;
		}
	}
	close(fd);
	*p = 0;
	return s;
}

#define Fields 		18			/* terrible hack; worth 10% */
#define Minfields	17

void
updateinfo(Message *m)
{
	char *s, *f[Fields + 1];
	int i, n, sticky;

	s = file2string(m->path, "info");
	if(s == nil)
		return;
	if((n = getfields(s, f, nelem(f), 0, "\n")) < Minfields){
		for(i = 0; i < n; i++)
			fprint(2, "info: %s\n", f[i]);
		sysfatal("info file invalid %s %D: %d fields", m->path, m, n);
	}
	if((m->nflags & Nnoflags) == 0){
		sticky = m->flags & Fdeleted;
		m->flags = buftoflags(f[17]) | sticky;
	}
	m->nflags &= ~Nmissing;
	free(s);
}

Message*
file2message(Message *parent, char *name)
{
	char *path, *f[Fields + 1];
	int i, n;
	Message *m;

	m = mallocz(sizeof *m, 1);
	if(m == nil)
		return nil;
	m->path = path = strdup(extendp(parent->path, name));
	m->fileno = atoi(name);
	m->info = file2string(path, "info");
	m->parent = parent;
	n = getfields(m->info, f, nelem(f), 0, "\n");
	if(n < Minfields){
		for(i = 0; i < n; i++)
			fprint(2, "info: [%s]\n", f[i]);
		sysfatal("info file invalid %s %D: %d fields", path, m, n);
	}
	m->from = f[0];
	m->to = f[1];
	m->cc = f[2];
	m->replyto = f[3];
	m->date = f[4];
	m->subject = f[5];
	m->type = f[6];
	m->disposition = f[7];
	m->filename = f[8];
	m->len = strtoul(f[16], 0, 0);
	if(n > 17)
		m->flags = buftoflags(f[17]);
	else
		m->nflags |= Nnoflags;

	if(m->type)
	if(strstr(m->type, "multipart") != nil || strcmp(m->type, "message/rfc822") == 0)
		mdir2message(m);
	return m;
}

void
freemessage(Message *m)
{
	Message *nm, *next;

	for(nm = m->child; nm != nil; nm = next){
		next = nm->next;
		freemessage(nm);
	}
	free(m->path);
	free(m->info);
	free(m);
}

/*
 * read a directory into a list of messages.  at the top level, there may be
 * large gaps in message numbers.  so we need to read the whole directory.
 * and pick out the messages we're interested in.  within a message, subparts
 * are contiguous and if we don't read the header/body/rawbody, we can avoid forcing
 * upas/fs to read the whole message.
 */
int
mdir2message(Message *parent)
{
	char buf[Pathlen];
	int i, highest, newmsgs;
	Dir *d;
	Message *first, *last, *m;

	/* count current entries */
	first = parent->child;
	highest = newmsgs = 0;
	for(last = parent->child; last != nil && last->next != nil; last = last->next)
		if(last->fileno > highest)
			highest = last->fileno;
	if(last != nil)
		if(last->fileno > highest)
			highest = last->fileno;
	for(i = highest + 1;; i++){
		snprint(buf, sizeof buf, "%s/%d", parent->path, i);
		if((d = dirstat(buf)) == nil)
			break;
		if((d->qid.type & QTDIR) == 0){
			free(d);
			continue;
		}
		free(d);
		snprint(buf, sizeof buf, "%d", i);
		m = file2message(parent, buf);
		if(m == nil)
			break;
		m->id = m->fileno;
		newmsgs++;
		if(first == nil)
			first = m;
		else
			last->next = m;
		m->prev = last;
		last = m;
	}
	parent->child = first;
	return newmsgs;
}

/*
 * 99.9% of the time, we don't need to sort this list.
 * however, sometimes email is added to a mailbox
 * out of order.  or, sape copies it back in from the
 * dump.  in this case, we've got to sort.
 *
 * BOTCH.  we're not observing any sort of stable
 * order.  if an old message comes in while upas/fs
 * is running, it will appear out of order.  restarting
 * upas/fs will reorder things.
 */
int
dcmp(Dir *a, Dir *b)
{
	return atoi(a->name) - atoi(b->name);
}

void
itsallsapesfault(Dir *d, int n)
{
	int c, i, r, t;

	/* evade qsort suck */
	r = -1;
	for(i = 0; i < n; i++){
		t = atol(d[i].name);
		if(t > r){
			c = d[i].name[0];
			if(c >= '0' && c <= 9)
				break;
		}
		r = t;
	}
	if(i != n)
		qsort(d, n, sizeof *d, (int (*)(void*, void*))dcmp);
}

int
dir2message(Message *parent, int reverse, Dirstats *s)
{
	int i, c, n, fd;
	Dir *d;
	Message *first, *last, *m, **ll;

	memset(s, 0, sizeof *s);
	fd = open(parent->path, OREAD);
	if(fd < 0)
		return -1;
	first = parent->child;
	last = nil;
	if(first)
		for(last = first; last->next; last = last->next)
			;
	n = dirreadall(fd, &d);
	itsallsapesfault(d, n);
	if(reverse)
		ll = &last;
	else
		ll = &parent->child;
	for(i = 0; *ll || i < n; ){
		if(i < n && (d[i].qid.type & QTDIR) == 0){
			i++;
			continue;
		}
		c = -1;
		if(i >= n)
			c = 1;
		else if(*ll)
			c = atoi(d[i].name) - (*ll)->fileno;
		if(c < 0){
			m = file2message(parent, d[i].name);
			if(m == nil)
				break;
			if(reverse){
				m->next = first;
				if(first != nil)
					first->prev = m;
				first = m;
			}else{
				if(first == nil)
					first = m;
				else
					last->next = m;
				m->prev = last;
				last = m;
			}
			*ll = m;
			s->new++;
			s->unread += (m->flags & Fseen) == 0;
			i++;
		}else if(c > 0){
			(*ll)->nflags |= Nmissing;
			s->del++;
		}else{
			updateinfo(*ll);
			s->old++;
			i++;
		}

		if(reverse)
			ll = &(*ll)->prev;
		else
			ll = &(*ll)->next;
	}
	free(d);
	close(fd);
	parent->child = first;

	/* renumber and file longest from */
	i = 1;
	longestfrom = 12;
	longestto = 12;
	for(m = first; m != nil; m = m->next){
		m->id = natural ? m->fileno : i++;
		n = strlen(m->from);
		if(n > longestfrom)
			longestfrom = n;
		n = strlen(m->to);
		if(n > longestto)
			longestto = n;
	}
	return 0;
}

/*
 *   point directly to a message
 */
Message*
dosingleton(Message *parent, char *path)
{
	char *p, *np;
	Message *m;

	/* walk down to message and read it */
	if(strlen(path) < rootlen)
		return nil;
	if(path[rootlen] != '/')
		return nil;
	p = path + rootlen + 1;
	np = strchr(p, '/');
	if(np != nil)
		*np = 0;
	m = file2message(parent, p);
	if(m == nil)
		return nil;
	parent->child = m;
	m->id = 1;

	/* walk down to requested component */
	while(np != nil){
		*np = '/';
		np = strchr(np + 1, '/');
		if(np != nil)
			*np = 0;
		for(m = m->child; m != nil; m = m->next)
			if(strcmp(path, m->path) == 0)
				return m;
		if(m == nil)
			return nil;
	}
	return m;
}

/*
 *   walk the path name an element
 */
char*
extendp(char *dir, char *name)
{
	static char buf[Pathlen];

	if(strcmp(dir, ".") == 0)
		snprint(buf, sizeof buf, "%s", name);
	else
		snprint(buf, sizeof buf, "%s/%s", dir, name);
	return buf;
}

char*
nosecs(char *t)
{
	char *p;

	p = strchr(t, ':');
	if(p == nil)
		return t;
	p = strchr(p + 1, ':');
	if(p != nil)
		*p = 0;
	return t;
}

char *months[12] =
{
	"jan", "feb", "mar", "apr", "may", "jun",
	"jul", "aug", "sep", "oct", "nov", "dec"
};

int
month(char *m)
{
	int i;

	for(i = 0; i < 12; i++)
		if(cistrcmp(m, months[i]) == 0)
			return i + 1;
	return 1;
}

enum
{
	Yearsecs	= 365*24*60*60,
};

void
cracktime(char *d, char *out, int len)
{
	char in[64], *f[6], *dtime;
	int n;
	long now, then;
	Tm tm;

	*out = 0;
	if(d == nil)
		return;
	strncpy(in, d, sizeof in);
	in[sizeof in - 1] = 0;
	n = getfields(in, f, 6, 1, " \t\r\n");
	if(n != 6){
		/* unknown style */
		snprint(out, 16, "%10.10s", d);
		return;
	}
	now = time(0);
	memset(&tm, 0, sizeof tm);
	if(strchr(f[0], ',') != nil && strchr(f[4], ':') != nil){
		/* 822 style */
		tm.year = atoi(f[3])-1900;
		tm.mon = month(f[2]);
		tm.mday = atoi(f[1]);
		dtime = nosecs(f[4]);
		then = tm2sec(&tm);
	} else if(strchr(f[3], ':') != nil){
		/* unix style */
		tm.year = atoi(f[5])-1900;
		tm.mon = month(f[1]);
		tm.mday = atoi(f[2]);
		dtime = nosecs(f[3]);
		then = tm2sec(&tm);
	} else {
		then = now;
		tm = *localtime(now);
		dtime = "";
	}

	if(now - then < Yearsecs/2)
		snprint(out, len, "%2d/%2.2d %s", tm.mon, tm.mday, dtime);
	else
		snprint(out, len, "%2d/%2.2d  %4d", tm.mon, tm.mday, tm.year + 1900);
}

int
matchtype(char *s, Ctype *t)
{
	return strncmp(t->type, s, strlen(t->type)) == 0;
}

Ctype*
findctype(Message *m)
{
	char *p, ftype[256];
	int n, pfd[2];
	Ctype *a, *cp;

	for(cp = ctype; cp; cp = cp->next)
		if(matchtype(m->type, cp))
			if((cp->flag & Rechk) == 0)
				return cp;
			else
				break;

	if(pipe(pfd) < 0)
		return ctype;
	*ftype = 0;
	switch(fork()){
	case -1:
		break;
	case 0:
		close(pfd[1]);
		close(0);
		dup(pfd[0], 0);
		close(1);
		dup(pfd[0], 1);
		execl("/bin/file", "file", "-m", extendp(m->path, "body"), nil);
		exits(0);
	default:
		close(pfd[0]);
		n = read(pfd[1], ftype, sizeof ftype - 1);
		while(n > 0 && isspace(ftype[n - 1]))
			n--;
		ftype[n] = 0;
		close(pfd[1]);
		waitpid();
		break;
	}
	for(cp = ctype; cp; cp = cp->next)
		if(matchtype(ftype, cp))
			return cp;
	if(*ftype == 0 || (p = strchr(ftype, '/')) == nil)
		return ctype;
	*p++ = 0;

	a = mallocz(sizeof *a, 1);
	a->type = strdup(ftype);
	a->ext = strdup(p);
	a->flag = 0;
	a->plumbdest = strdup(ftype);
	for(cp = ctype; cp->next; cp = cp->next)
		;
	cp->next = a;
	a->next = nil;
	return a;
}

/*
 * traditional
 */
void
hds(char *buf, Message *m)
{
	buf[0] = m->child? 'H': ' ';
	buf[1] = m->flags & Fdeleted ? 'd' : ' ';
	buf[2] = m->flags & Fstored? 's': ' ';
	buf[3] = m->flags & Fseen? ' ': '*';
	if(m->flags & Fanswered)
		buf[3] = 'a';
	if(m->flags & Fflagged)
		buf[3] = '\'';
	buf[4] = 0;
}

void
pheader0(char *buf, int len, Message *m)
{
	char *f, *p, *q, frombuf[40], timebuf[32], h[5];
	int max;

	hds(h, m);
	if(hcmdfmt == 0){
		f = m->from;
		max = longestfrom;
	}else{
		snprint(frombuf, sizeof frombuf-5, "%s", m->to);
		p = strchr(frombuf, ' ');
		if(p != nil)
			snprint(p, 5, " ...");
		f = frombuf;
		max = longestto;
		if(max > sizeof frombuf)
			max = sizeof frombuf;
	}

	if(*f == 0)
		snprint(buf, len, "%3D    %s %6d  %s",
			m, m->type, m->len, m->filename);
	else if(*m->subject){
		q = p = strdup(m->subject);
		while(*p == ' ')
			p++;
		if(strlen(p) > 50)
			p[50] = 0;
		cracktime(m->date, timebuf, sizeof timebuf);
		snprint(buf, len, "%3D %s %6d  %11.11s %-*.*s %s",
			m, h, m->len, timebuf, max, max, f, p);
		free(q);
	} else {
		cracktime(m->date, timebuf, sizeof timebuf);
		snprint(buf, len, "%3D %s %6d  %11.11s %s",
			m, h, m->len, timebuf, f);
	}
}

void
pheader(char *buf, int len, int indent, Message *m)
{
	char *p, *e, typeid[80];

	e = buf + len;
	snprint(typeid, sizeof typeid, "%D    %s", m, m->type);
	if(indent < 6)
		p = seprint(buf, e, "%-32s %-6d ", typeid, m->len);
	else
		p = seprint(buf, e, "%-64s %-6d ", typeid, m->len);
	if(m->filename && *m->filename)
		p = seprint(p, e, "(file,%s)", m->filename);
	if(m->from && *m->from)
		p = seprint(p, e, "(from,%s)", m->from);
	if(m->subject && *m->subject)
		seprint(p, e, "(subj,%s)", m->subject);
}

char sstring[256];

/*
 * 	cmd := range cmd ' ' arg-list ;
 * 	range := address
 * 		| address ',' address
 * 		| 'g' search ;
 * 	address := msgno
 * 		| search ;
 * 	msgno := number
 * 		| number '/' msgno ;
 * 	search := '/' string '/'
 * 		| '%' string '%'
 *		| '#' (field '#')? re '#'
 *
 */
static char*
qstrchr(char *s, int c)
{
	for(;; s++){
		if(*s == '\\')
			s++;
		else if(*s == c)
			return s;
		if(*s == 0)
			return nil;
	}
}

Reprog*
parsesearch(char **pp, char *buf, int bufl)
{
	char *p, *np, *e;
	int c, n;

	buf[0] = 0;
	p = *pp;
	c = *p++;
	if(c == '#')
		snprint(buf, bufl, "from");
	np = qstrchr(p, c);
	if(c == '#' && np)
	if(e = qstrchr(np + 1, c)){
		snprint(buf, bufl, "%.*s", utfnlen(p, np - p), p);
		p = np + 1;
		np = e;
	}
	if(np != nil){
		*np++ = 0;
		*pp = np;
	} else {
		n = strlen(p);
		*pp = p + n;
	}
	if(*p == 0)
		p = sstring;
	else{
		strncpy(sstring, p, sizeof sstring);
		sstring[sizeof sstring - 1] = 0;
	}
	return regcomp(p);
}

enum{
	Comma = 1,
};

/*
 *   search a message for a regular expression match
 */
int
fsearch(Message *m, Reprog *prog, char *field)
{
	char buf[4096 + 1];
	int i, fd, rv;
	uvlong o;

	rv = 0;
	fd = open(extendp(m->path, field), OREAD);
	/*
	 *  march through raw message 4096 bytes at a time
	 *  with a 128 byte overlap to chain the re search.
	 */
	for(o = 0;; o += i - 128){
		i = pread(fd, buf, sizeof buf - 1, o);
		if(i <= 0)
			break;
		buf[i] = 0;
		if(regexec(prog, buf, nil, 0)){
			rv = 1;
			break;
		}
		if(i < sizeof buf - 1)
			break;
	}
	close(fd);
	return rv;
}

int
rsearch(Message *m, Reprog *prog, char*)
{
	return fsearch(m, prog, "raw");
}

int
hsearch(Message *m, Reprog *prog, char*)
{
	char buf[256];

	pheader0(buf, sizeof buf, m);
	return regexec(prog, buf, nil, 0);
}

/*
 * ack: returns int (*)(Message*, Reprog*, char*)
 */
int (*
chartosearch(int c))(Message*, Reprog*, char*)
{
	switch(c){
	case '%':
		return rsearch;
	case '/':
	case '?':
		return hsearch;
	case '#':
		return fsearch;
	}
	return 0;
}

char*
parseaddr(char **pp, Message *first, Message *cur, Message *unspec, Message **mp, int f)
{
	char *p, buf[256];
	int n, c, sign;
	Message *m, *m0;
	Reprog *prog;
	int (*fn)(Message*, Reprog*, char*);

	*mp = nil;
	p = *pp;

	sign = 0;
	if(*p == '+'){
		sign = 1;
		p++;
		*pp = p;
	} else if(*p == '-'){
		sign = -1;
		p++;
		*pp = p;
	}

	switch(*p){
	default:
		if(sign){
			n = 1;
			goto number;
		}
		*mp = unspec;
		break;
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
		n = strtoul(p, pp, 10);
		if(n == 0){
			if(sign)
				*mp = cur;
			else
				*mp = &top;
			break;
		}
	number:
		m0 = m = nil;
		switch(sign){
		case 0:
			for(m = first; m != nil; m0 = m, m = m->next)
				if(m->id == n)
					break;
			break;
		case -1:
			if(cur != &top)
				for(m = cur; m0 = m, m != nil && n > 0; n--)
					m = m->prev;
			break;
		case 1:
			if(cur == &top){
				n--;
				cur = first;
			}
			for(m = cur; m != nil && n > 0; m0 = m, n--)
				m = m->next;
			break;
		}
		if(m == nil && f&Comma)
			m = m0;
		if(m == nil)
			return "address";
		*mp = m;
		break;
	case '?':
		/* legacy behavior.  no longer needed */
		sign = -1;
	case '%':
	case '/':
	case '#':
		c = *p;
		fn= chartosearch(c);
		prog = parsesearch(pp, buf, sizeof buf);
		if(prog == nil)
			return "badly formed regular expression";
		if(sign == -1){
			for(m = cur == &top ? nil : cur->prev; m; m = m->prev)
				if(fn(m, prog, buf))
					break;
		}else{
			for(m = cur == &top ? first : cur->next; m; m = m->next)
				if(fn(m, prog, buf))
					break;
		}
		if(m == nil)
			return "search";
		*mp = m;
		free(prog);
		break;
	case '$':
		for(m = first; m != nil && m->next != nil; m = m->next)
			;
		*mp = m;
		*pp = p + 1;
		break;
	case '.':
		*mp = cur;
		*pp = p + 1;
		break;
	case ',':
		*mp = first;
		*pp = p;
		break;
	}

	if(*mp != nil && **pp == '.'){
		(*pp)++;
		if((m = (*mp)->child) == nil)
			return "no sub parts";
		return parseaddr(pp, m, m, m, mp, 0);
	}
	c = **pp;
	if(c == '+' || c == '-' || c == '/' || c == '%' || c == '#')
		return parseaddr(pp, first, *mp, *mp, mp, 0);

	return nil;
}

char*
parsecmd(char *p, Cmd *cmd, Message *first, Message *cur)
{
	char buf[256], *err;
	int i, c, r;
	Reprog *prog;
	Message *m, *s, *e, **l, *last;
	int (*f)(Message*, Reprog*, char*);
	static char errbuf[ERRMAX];

	cmd->delete = 0;
	l = &cmd->msgs;
	*l = nil;

	while(*p == ' ' || *p == '\t')
		p++;

	/* null command is a special case (advance and print) */
	if(*p == 0){
		if(cur == &top)
			m = first;
		else {
			/* walk to the next message even if we have to go up */
			m = cur->next;
			while(m == nil && cur->parent != nil){
				cur = cur->parent;
				m = cur->next;
			}
		}
		if(m == nil)
			return "address";
		*l = m;
		m->cmd = nil;
		cmd->an = 0;
		cmd->f = pcmd;
		return nil;
	}

	/* global search ? */
	if(*p == 'g'){
		p++;

		/* no search string means all messages */
		if(*p == 'k'){
			for(m = first; m != nil; m = m->next)
			if(m->flags & Fflagged){
				*l = m;
				l = &m->cmd;
				*l = nil;
			}
			p++;
		}else if(*p != '/' && *p != '%' && *p != '#'){
			for(m = first; m != nil; m = m->next){
				*l = m;
				l = &m->cmd;
				*l = nil;
			}
		}else{
			/* mark all messages matching this search string */
			c = *p;
			f = chartosearch(c);
			prog = parsesearch(&p, buf, sizeof buf);
			if(prog == nil)
				return "badly formed regular expression";
			for(m = first; m != nil; m = m->next){
				if(f(m, prog, buf)){
					*l = m;
					l = &m->cmd;
					*l = nil;
				}
			}
			free(prog);
		}
	}else{
		/* parse an address */
		s = e = nil;
		err = parseaddr(&p, first, cur, cur, &s, 0);
		if(err != nil)
			return err;
		if(*p == ','){
			/* this is an address range */
			if(s == &top)
				s = first;
			p++;
			for(last = s; last != nil && last->next != nil; last = last->next)
				;
			err = parseaddr(&p, first, cur, last, &e, Comma);
			if(err != nil)
				return err;
			/* select all messages in the range */
			r = 0;
			if(s != nil && e != nil && s->id > e->id)
				r = 1;
			while(s != nil){
				*l = s;
				l = &s->cmd;
				*l = nil;
				if(s == e)
					break;
				if(r)
					s = s->prev;
				else
					s = s->next;
			}
			if(s == nil)
				return "null address range";
		} else {
			/* single address */
			if(s != &top){
				*l = s;
				s->cmd = nil;
			}
		}
	}

	while(*p == ' ' || *p == '\t')
		p++;
	/* hack to allow all messages to start with 'd' */
	if(*p == 'd' && p[1]){
		cmd->delete = 1;
		p++;
	}
	while(*p == ' ' || *p == '\t')
		p++;
	if(*p == 0)
		p = "p";
	for(i = nelem(cmdtab) - 1; i >= 0; i--)
		if(strncmp(p, cmdtab[i].cmd, strlen(cmdtab[i].cmd)) == 0)
			goto found;
	return "illegal command";
found:
	p += strlen(cmdtab[i].cmd);
	snprint(cmd->cmdline, sizeof cmd->cmdline, "%s", p);
	cmd->av[0] = cmdtab[i].cmd;
	cmd->an = 1 + tokenize(p, cmd->av + 1, nelem(cmd->av) - 2);
	if(cmdtab[i].args == 0 && cmd->an > 1){
		snprint(errbuf, sizeof errbuf, "%s doesn't take an argument", cmdtab[i].cmd);
		return errbuf;
	}
	cmd->f = cmdtab[i].f;

	if(cmdtab[i].addr && (cmd->msgs == nil || cmd->msgs == &top)){
		snprint(errbuf, sizeof errbuf, "%s requires an address", cmdtab[i].cmd);
		return errbuf;
 	}
	return nil;
}

Message*
aichcmd(Message *m, int indent)
{
	char hdr[256];

	pheader(hdr, sizeof hdr, indent, m);
	Bprint(&out, "%s\n", hdr);
	for(m = m->child; m != nil; m = m->next)
		aichcmd(m, indent + 1);
	return m;
}

Message*
Hcmd(Cmd*, Message *m)
{
	if(m == &top)
		return nil;
	return aichcmd(m, 0);
}

Message*
hcmd(Cmd*, Message *m)
{
	char hdr[256];

	if(m == &top)
		return nil;
	pheader0(hdr, sizeof hdr, m);
	Bprint(&out, "%s\n", hdr);
	return m;
}

Message*
bcmd(Cmd*, Message *m)
{
	int i;
	Message *om;

	om = m;
	if(m == &top)
		m = top.child;
	for(i = 0; i < 10 && m != nil; i++){
		hcmd(nil, m);
		om = m;
		m = m->next;
	}

	return m != nil? m: om;
}

Message*
ncmd(Cmd*, Message *m)
{
	if(m == &top)
		return m->child;
	return m->next;
}

int
writepart(char *m, char *part, char *s)
{
	char *e;
	int fd, n;

	fd = open(extendp(m, part), OWRITE);
	if(fd < 0){
		dissappeared();
		return -1;
	}
	for(e = s + strlen(s); e - s > 0; s += n){
		if((n = write(fd, s, e - s)) <= 0){
			eprint("!writepart:%s: %r\n", part);
			break;
		}
		if(interrupted)
			break;
	}
	close(fd);
	return s == e? 0: -1;
}

Message	*xpipecmd(Cmd*, Message*, char*);

Message*
printfmt(Message *m, char *part, char *cmd)
{
	Cmd c;

	c.an = 2;
	snprint(c.cmdline, sizeof c.cmdline, "%s", cmd);
	Bflush(&out);
	return xpipecmd(&c, m, part);
}

int
printpart0(Message *m, char *part)
{
	char buf[4096];
	int n, fd, tot;

	fd = open(extendp(m->path, part), OREAD);
	if(fd < 0){
		dissappeared();
		return 0;
	}
	tot = 0;
	while((n = read(fd, buf, sizeof buf)) > 0){
		if(interrupted)
			break;
		if(Bwrite(&out, buf, n) <= 0)
			break;
		tot += n;
	}
	close(fd);
	return tot;
}

int
printpart(Message *m, char *part, char *cmd)
{
	if(cmd == nil || cmd[0] == 0)
		return printpart0(m, part);
	printfmt(m, part, cmd);
	return 1;
}

int
printhtml(Message *m)
{
	Cmd c;

	memset(&c, 0, sizeof c);
	c.an = 3;
	snprint(c.cmdline, sizeof c.cmdline, "/bin/htmlfmt -l60 -cutf8");
	eprint("!/bin/htmlfmt\n");
	pipecmd(&c, m);
	return 0;
}

Message*
Pcmd(Cmd*, Message *m)
{
	if(m == &top)
		return &top;
	if(m->parent == &top)
		printpart(m, "unixheader", nil);
	printpart(m, "raw", nil);
	return m;
}

void
compress(char *p)
{
	char *np;
	int last;

	last = ' ';
	for(np = p; *p; p++){
		if(*p != ' ' || last != ' '){
			last = *p;
			*np++ = last;
		}
	}
	*np = 0;
}

void
setflags(Message *m, char *f)
{
	uchar f0;

	f0 = m->flags;
	txflags(f, &m->flags);
	if(f0 != m->flags)
		if((m->nflags & Nnoflags) == 0)
			writepart(m->path, "flags", f);
}

Message*
Fcmd(Cmd *c, Message *m)
{
	int i;

	for(i = 1; i < c->an; i++)
		setflags(m, c->av[i]);
	return m;
}

void
seen(Message *m)
{
	setflags(m, "s");
}

/*
 * sleeze
 */
int
magicpart(Message *m, char *s, char *part)
{
	char buf[4096];
	int n, fd, c;

	fd = open(extendp(s, part), OREAD);
	if(fd < 0){
		if(strcmp(part, "id") == 0)
			Bprint(&out, "%D ", m);
		else if(strcmp(part, "fpath") == 0)
			Bprint(&out, "%s ", rooted(m->path));
		else
			Bprint(&out, "%s ", part);
		return 0;
	}

	c = 0;
	while((n = read(fd, buf, sizeof buf)) > 0){
		c = -1;
		if(interrupted)
			break;
		if(Bwrite(&out, buf, n) <= 0)
			break;
		c = buf[n - 1];
	}
	close(fd);
	if(!interrupted && n != -1 && c != -1)
	if(strstr(part, "body") != nil || strcmp(part, "rawunix") == 0)
		seen(m);
	return c;
}

Message*
pcmd0(Cmd *c, Message *m, int mayplumb, char *tfmt)
{
	char *s, buf[128];
	int i, ch;
	Ctype *cp;
	Message *nm;

	if(m == &top)
		return &top;
	if(c && c->an >= 2){
		ch = 0;
		for(i = 1; i < c->an; i++)
			ch = magicpart(m, m->path, c->av[i]);
		if(ch != '\n')
			Bprint(&out, "\n");
		return m;
	}
	if(m->parent == &top){
		seen(m);
		printpart(m, "unixheader", nil);
	}
	if(printpart(m, "header", nil) > 0)
		Bprint(&out, "\n");
	cp = findctype(m);
	if(cp->flag & Display){
		if(strcmp(m->type, "text/html") == 0)
			printhtml(m);
		else
			printpart(m, "body", tfmt);
	}else if(strcmp(m->type, "multipart/alternative") == 0){
		for(nm = m->child; nm != nil; nm = nm->next){
			cp = findctype(nm);
			if(cp->ext != nil && strncmp(cp->ext, "txt", 3) == 0)
				break;
		}
		if(nm == nil)
			for(nm = m->child; nm != nil; nm = nm->next){
				cp = findctype(nm);
				if(cp->flag & Display)
					break;
			}
		if(nm != nil)
			pcmd0(nil, nm, mayplumb, tfmt);
		else
			hcmd(nil, m);
	}else if(strncmp(m->type, "multipart/", 10) == 0){
		nm = m->child;
		if(nm != nil){
			/* always print first part */
			pcmd0(nil, nm, mayplumb, tfmt);

			for(nm = nm->next; nm != nil; nm = nm->next){
				s = rooted(nm->path);
				cp = findctype(nm);
				pheader(buf, sizeof buf, -1, nm);
				compress(buf);
				if(strcmp(nm->disposition, "inline") == 0){
					if(cp->ext != nil)
						Bprint(&out, "\n--- %s %s/body.%s\n\n",
							buf, s, cp->ext);
					else
						Bprint(&out, "\n--- %s %s/body\n\n",
							buf, s);
					pcmd0(nil, nm, 0, tfmt);
				} else {
					if(cp->ext != nil)
						Bprint(&out, "\n!--- %s %s/body.%s\n",
							buf, s, cp->ext);
					else
						Bprint(&out, "\n!--- %s %s/body\n",
							buf, s);
				}
			}
		} else {
			hcmd(nil, m);
		}
	}else if(strcmp(m->type, "message/rfc822") == 0)
		pcmd(nil, m->child);
	else if(!mayplumb){
	}else if(plumb(m, cp) >= 0){
		Bprint(&out, "\n!--- using plumber to type %s", cp->type);
		if(strcmp(cp->type, m->type) != 0)
			Bprint(&out, " (was %s)", m->type);
		Bprint(&out, "\n");
	}else
		Bprint(&out, "\n!--- cannot display %s\n", cp->type);

	return m;
}

Message*
pcmd(Cmd *c, Message *m)
{
	return pcmd0(c, m, 1, textfmt);
}

Message*
tcmd(Cmd *c, Message *m)
{
	switch(c->an){
	case 1:
		if(textfmt[0] != 0)
			textfmt[0] = 0;
		else
			snprint(textfmt, sizeof textfmt, "%s", "upas/tfmt");
		break;
	default:
		snprint(textfmt, sizeof textfmt, "%s", c->cmdline);
		break;
	}
	eprint("!textfmt %s\n", textfmt);
	return m;
}

void
printpartindented(char *s, char *part, char *indent)
{
	char *p;
	Biobuf *b;

	b = Bopen(extendp(s, part), OREAD);
	if(b == nil){
		dissappeared();
		return;
	}
	while((p = Brdline(b, '\n')) != nil){
		if(interrupted)
			break;
		p[Blinelen(b)-1] = 0;
		if(Bprint(&out, "%s%s\n", indent, p) < 0)
			break;
	}
	Bprint(&out, "\n");
	Bterm(b);
}

void
printpartindent2(char *s, char *part, char *indent)
{
	Cmd c;

	memset(&c, 0, sizeof c);
	snprint(c.cmdline, sizeof c.cmdline, "fmt -q '> ' %s | sed 's/^/%s/g' ",
		rooted(extendp(s, part)), indent);
	Bflush(&out);
	bangcmd(&c, nil);
}

Message*
quotecmd0(Cmd *c, Message *m, void (*p)(char*, char*, char*))
{
	Ctype *cp;
	Message *nm;

	if(m == &top)
		return &top;
	Bprint(&out, "\n");
	if(m->from != nil && *m->from)
		Bprint(&out, "On %s, %s wrote:\n", m->date, m->from);
	cp = findctype(m);
	if(cp->flag & Display)
		p(m->path, "body", "> ");
	else if(strcmp(m->type, "multipart/alternative") == 0){
		for(nm = m->child; nm != nil; nm = nm->next){
			cp = findctype(nm);
			if(cp->ext != nil && strncmp(cp->ext, "txt", 3) == 0)
				break;
		}
		if(nm == nil)
			for(nm = m->child; nm != nil; nm = nm->next){
				cp = findctype(nm);
				if(cp->flag & Display)
					break;
			}
		if(nm != nil)
			quotecmd(c, nm);
	}else if(strncmp(m->type, "multipart/", 10) == 0){
		nm = m->child;
		if(nm != nil){
			cp = findctype(nm);
			if(cp->flag & Display || strncmp(m->type, "multipart/", 10) == 0)
				quotecmd(c, nm);
		}
	}
	return m;
}

Message*
quotecmd(Cmd *c, Message *m)
{
	void (*p)(char*, char*, char*);

	p = printpartindented;
	if(strstr(c->av[0], "\"\"") != nil)
		p = printpartindent2;
	return quotecmd0(c, m, p);
}


/* really delete messages */
Message*
flushdeleted(Message *cur)
{
	char buf[1024], *p, *e, *msg;
	int i, deld, n, fd;
	Message *m, **l;

	doflush = 0;
	deld = 0;

	fd = open("/mail/fs/ctl", ORDWR);
	if(fd < 0){
		eprint("!can't delete mail, opening /mail/fs/ctl: %r\n");
		exitfs(0);
	}
	e = buf + sizeof buf;
	p = seprint(buf, e, "delete %s", mbname);
	n = 0;
	for(l = &top.child; *l != nil;){
		m = *l;
		if((m->nflags & Nmissing) == 0)
		if((m->flags & Fdeleted) == 0){
			l = &(*l)->next;
			continue;
		}

		/* don't return a pointer to a deleted message */
		if(m == cur)
			cur = m->next;
		deld++;
		if(m->flags & Fdeleted){
			msg = strrchr(m->path, '/');
			if(msg == nil)
				msg = m->path;
			else
				msg++;
			if(e - p < 10){
				write(fd, buf, p - buf);
				n = 0;
				p = seprint(buf, e, "delete %s", mbname);
			}
			p = seprint(p, e, " %s", msg);
			n++;
		}
		/* unchain and free */
		*l = m->next;
		if(m->next)
			m->next->prev = m->prev;
		freemessage(m);
	}
	if(n)
		write(fd, buf, p - buf);

	close(fd);

	if(deld)
		Bprint(&out, "!%d message%s deleted\n", deld, plural(deld));

	/* renumber */
	i = 1;
	for(m = top.child; m != nil; m = m->next)
		m->id = natural ? m->fileno : i++;

	/*
	 *  if we're out of messages, go back to first
	 *  if no first, return the fake first
	 */
	if(cur == nil){
		if(top.child)
			return top.child;
		else
			return &top;
	}
	return cur;
}

Message*
mbcmd(Cmd *c, Message*)
{
	char *mb, oldmb[Pathlen];
	Message *m, **l;

	switch(c->an){
	case 1:
		mb = "mbox";
		break;
	case 2:
		mb = c->av[1];
		break;
	default:
		eprint("!usage: mbcmd [mbox]\n");
		return nil;	
	}

	/* flushdeleted(nil); ? */
	for(l = &top.child; *l; ){
		m = *l;
		*l = m->next;
		freemessage(m);
	}
	top.child = nil;

	strcpy(oldmb, mbpath);
	if(switchmb(mb, 0) < 0){
		eprint("!no mb\n");
		if(switchmb(oldmb, 0) < 0){
			eprint("!mb disappeared\n");
			exits("fail");
		}
	}
	icmd(nil, nil);
	interrupted = 1;	/* no looping */
	return &top;
}

Message*
qcmd(Cmd*, Message*)
{
	flushdeleted(nil);
	if(didopen)
		closemb();
	Bflush(&out);
	exitfs(0);
	return nil;
}

Message*
ycmd(Cmd *c, Message *m)
{
	doflush = 1;
	return icmd(c, m);
}

Message*
xcmd(Cmd*, Message*)
{
	exitfs(0);
	return nil;
}

Message*
eqcmd(Cmd*, Message *m)
{
	Bprint(&out, "%D\n", m);
	return m;
}

Message*
dcmd(Cmd*, Message *m)
{
	while(m->parent != &top)
		m = m->parent;
	m->flags |= Fdeleted;
	return m;
}

Message*
ucmd(Cmd*, Message *m)
{
	if(m == &top)
		return nil;
	while(m->parent != &top)
		m = m->parent;
	m->flags &= ~Fdeleted;
	return m;
}

int
skipscan(void)
{
	int r;
	Dir *d;
	static int lastvers = -1;

	d = dirstat(top.path);
	r = d && d->qid.path == mbqid.path && d->qid.vers == mbqid.vers;
	r = r && mbvers == lastvers;
	if(d != nil){
		mbqid = d->qid;
		lastvers = mbvers;
	}
	free(d);
	return r;
}

Message*
icmd(Cmd *c, Message *m)
{
	char buf[128], *p, *e;
	Dirstats s;

	if(skipscan())
		return m;
	if(dir2message(&top, reverse, &s) < 0)
		return nil;
	p = buf;
	e = buf + sizeof buf;
	if(s.new > 0 && c == nil){
		p = seprint(p, e, "%d message%s", s.new, plural(s.new));
		if(s.unread > 0)
			p = seprint(p, e, ", %d unread", s.unread);
	}
	else if(s.new > 0)
		Bprint(&out, "%d new message%s", s.new, plural(s.new));
	if(s.new && s.del)
		p = seprint(p, e, "; ");
	if(s.del > 0)
		p = seprint(p, e, "%d deleted message%s", s.del, plural(s.del));
	if(s.new + s.del)
		p = seprint(p, e, "\n");
	if(p > buf){
		Bflush(&out);
		eprint("%s", buf);
	}
	return m;
}

Message*
kcmd0(Cmd *c, Message *m)
{
	char *f, *s;
	int sticky;

	if(c->an > 2){
		eprint("!usage k [flags]\n");
		return nil;
	}
	if(c->f == kcmd)
		f = "f";
	else
		f = "-f";
	if(c->an == 2)
		f = c->av[1];
	setflags(m, f);
	if(c->an == 2 && (m->nflags & Nnoflags) == 0){
		sticky = m->flags & Fdeleted;
		s = file2string(m->path, "flags");
		m->flags = buftoflags(s) | sticky;
		free(s);
	}
	return m;
}

Message*
kcmd(Cmd *c, Message *m)
{
	return kcmd0(c, m);
}

Message*
Kcmd(Cmd *c, Message *m)
{
	return kcmd0(c, m);
}

Message*
helpcmd(Cmd*, Message *m)
{
	int i;

	Bprint(&out, "Commands are of the form [<range>] <command> [args]\n");
	Bprint(&out, "<range> := <addr> | <addr>','<addr>| 'g'<search>\n");
	Bprint(&out, "<addr> := '.' | '$' | '^' | <number> | <search> | <addr>'+'<addr> | <addr>'-'<addr>\n");
	Bprint(&out, "<search> := 'k' | '/'<re>'/' | '?'<re>'?' | '%%'<re>'%%' | '#' <field> '#' <re> '#' \n");
	Bprint(&out, "<command> :=\n");
	for(i = 0; i < nelem(cmdtab); i++)
		Bprint(&out, "%s\n", cmdtab[i].help);
	return m;
}

/* ed thinks this is a good idea */
void
marshal(char **path, char **argv0)
{
	char *s;

	s = getenv("marshal");
	if(s == nil || *s == 0)
		s = "/bin/upas/marshal";
	*path = s;
	*argv0 = strrchr(s, '/') + 1;
	if(*argv0 == (char*)1)
		*argv0 = s;
}

int
tomailer(char **av)
{
	int pid, i;
	char *p, *a;
	Waitmsg *w;

	switch(pid = fork()){
	case -1:
		eprint("can't fork: %r\n");
		return -1;
	case 0:
		marshal(&p, &a);
		Bprint(&out, "!%s", p);
		for(i = 1; av[i]; i++)
			Bprint(&out, " %q", av[i]);
		Bprint(&out, "\n");
		Bflush(&out);
		av[0] = a;
		chdir(wd);
		exec(p, av);
		eprint("couldn't exec %s\n", p);
		exits(0);
	default:
		w = wait();
		if(w == nil){
			if(interrupted)
				postnote(PNPROC, pid, "die");
			waitpid();
			return -1;
		}
		if(w->msg[0]){
			eprint("mailer failed: %s\n", w->msg);
			free(w);
			return -1;
		}
		free(w);
//		Bprint(&out, "!\n");
		break;
	}
	return 0;
}

/*
 *  like tokenize but obey "" quoting
 */
int
tokenize822(char *str, char **args, int max)
{
	int na, intok, inquote;

	if(max <= 0)
		return 0;
	intok = inquote = 0;
	for(na=0; ;str++)
		switch(*str) {
		case ' ':
		case '\t':
			if(inquote)
				goto Default;
			/* fall through */
		case '\n':
			*str = 0;
			if(!intok)
				continue;
			intok = 0;
			if(na < max)
				continue;
			/* fall through */
		case 0:
			return na;
		case '"':
			inquote ^= 1;
			/* fall through */
		Default:
		default:
			if(intok)
				continue;
			args[na++] = str;
			intok = 1;
		}
}

static char *rec[] = {"Re: ", "AW:", };
static char *fwc[] = {"Fwd: ", };

char*
addrecolon(char **tab, int n, char *s)
{
	char *prefix;
	int i;

	prefix = "";
	for(i = 0; i < n; i++)
		if(cistrncmp(s, tab[i], strlen(tab[i]) - 1) == 0)
			break;
	if(i == n)
		prefix = tab[0];
	return smprint("%s%s", prefix, s);
}

Message*
rcmd(Cmd *c, Message *m)
{
	char *from, *path, *subject, *rpath, *addr, *av[128];
	int i, ai;
	Message *nm;

	ai = 1;
	av[ai++] = "-8";
	addr = path = subject = nil;
	for(nm = m; nm != &top; nm = nm->parent)
 		if(*nm->replyto != 0){
			addr = nm->replyto;
			break;
		}
	if(addr == nil){
		eprint("!no reply address\n");
		return nil;
	}

	if(nm == &top){
		print("!noone to reply to\n");
		return nil;
	}

	for(nm = m; nm != &top; nm = nm->parent)
		if(*nm->subject){
			av[ai++] = "-s";
			subject = addrecolon(rec, nelem(rec), nm->subject);
			av[ai++] = subject;
			break;
		}

	av[ai++] = "-R";
	av[ai++] = rpath = strdup(rooted(m->path));

	if(strchr(c->av[0], 'f') != nil){
		fcmd(c, m);
		av[ai++] = "-F";
	}

	if(strchr(c->av[0], 'R') != nil){
		av[ai++] = "-t";
		av[ai++] = "message/rfc822";
		av[ai++] = "-A";
		path = strdup(rooted(extendp(m->path, "raw")));
		av[ai++] = path;
	}

	for(i = 1; i < c->an && ai < nelem(av)-1; i++)
		av[ai++] = c->av[i];
	ai += tokenize822(from = strdup(addr), &av[ai], nelem(av) - ai);
	av[ai] = 0;
	if(tomailer(av) == -1)
		m = nil;
	else
		m->flags |= Fanswered;
	free(path);
	free(rpath);
	free(subject);
	free(from);
	return m;
}

Message*
mcmd(Cmd *c, Message *m)
{
	char *subject, *av[128];
	int i, ai;

	if(c->an < 2){
		eprint("!usage: M list-of addresses\n");
		return nil;
	}

	ai = 1;
	subject = nil;
	if(m->subject){
		av[ai++] = "-s";
		subject = addrecolon(fwc, nelem(fwc), m->subject);
		av[ai++] = subject;
	}

	av[ai++] = "-t";
	if(m->parent == &top)
		av[ai++] = "message/rfc822";
	else
		av[ai++] = "mime";

	av[ai++] = "-A";
	av[ai++] = rooted(extendp(m->path, "raw"));
	if(strchr(c->av[0], 'M') == nil)
		av[ai++] = "-n";
	else
		av[ai++] = "-8";
	for(i = 1; i < c->an && ai < nelem(av)-1; i++)
		av[ai++] = c->av[i];
	av[ai] = 0;

	if(tomailer(av) == -1)
		m = nil;
	else
		m->flags |= Fanswered;
	free(subject);
	return m;
}

Message*
acmd(Cmd *c, Message *m)
{
	char *av[128], *rpath, *subject, *from, *to, *cc;
	int i, ai;

	if(m->from == nil || m->to == nil || m->cc == nil){
		eprint("!bad message\n");
		return nil;
	}

	ai = 1;
	av[ai++] = "-8";
	av[ai++] = "-R";
	av[ai++] = rpath = strdup(rooted(m->path));

	subject = nil;
	if(m->subject && *m->subject){
		av[ai++] = "-s";
		subject = addrecolon(rec, nelem(rec), m->subject);
		av[ai++] = subject;
	}

	if(strchr(c->av[0], 'A') != nil){
		av[ai++] = "-t";
		av[ai++] = "message/rfc822";
		av[ai++] = "-A";
		av[ai++] = rooted(extendp(m->path, "raw"));
	}

	for(i = 1; i < c->an && ai < nelem(av)-1; i++)
		av[ai++] = c->av[i];
	ai += tokenize822(from = strdup(m->from), &av[ai], nelem(av) - ai);
	ai += tokenize822(to = strdup(m->to), &av[ai], nelem(av) - ai);
	ai += tokenize822(cc = strdup(m->cc), &av[ai], nelem(av) - ai);
	av[ai] = 0;
	if(tomailer(av) == -1)
		m = nil;
	else
		m->flags |= Fanswered;
	free(from);
	free(to);
	free(cc);
	free(subject);
	free(rpath);
	return m;
}

int
appendtofile(Message *m, char *part, char *base, int mbox, int f)
{
	char *folder, path[Pathlen];
	int in, rv, rp;

	in = open(extendp(m->path, part), OREAD);
	if(in == -1){
		dissappeared();
		return -1;
	}
	rp = 0;
	if(*base == '/')
		folder = base;
	else if(!mbox){
		snprint(path, sizeof path, "%s/%s", wd, base);
		folder = path;
		rp = 1;
	}else if(f)
		folder = ffoldername(mbpath, user, base);
	else
		folder = foldername(mbpath, user, base);
	if(folder == nil)
		return -1;
	if(mbox)
		rv = fappendfolder(0, 0, folder, in);
	else
		rv = fappendfile(m->from, folder, in);
	close(in);
	if(rv >= 0){
		eprint("!saved in %s\n", rp? base: folder);
		setflags(m, "S");
	}else
		eprint("!error %r\n");
	return rv;
}

Message*
scmd(Cmd *c, Message *m)
{
	char *file;

	switch(c->an){
	case 1:
		file = "stored";
		break;
	case 2:
		file = c->av[1];
		break;
	default:
		eprint("!usage: s filename\n");
		return nil;
	}

	if(appendtofile(m, "rawunix", file, 1, 0) < 0)
		return nil;
	return m;
}

Message*
wcmd(Cmd *c, Message *m)
{
	char *file;

	switch(c->an){
	case 2:
		file = c->av[1];
		break;
	case 1:
		if(*m->filename == 0){
			eprint("!usage: w filename\n");
			return nil;
		}
		file = strrchr(m->filename, '/');
		if(file != nil)
			file++;
		else
			file = m->filename;
		break;
	default:
		eprint("!usage: w filename\n");
		return nil;
	}

	if(appendtofile(m, "body", file, 0, 0) < 0)
		return nil;
	return m;
}

typedef struct Xtab Xtab;
struct Xtab {
	char	*a;
	char	*b;
};
Xtab	*xtab;
int	nxtab;

void
loadxfrom(int fd)
{
	char *f[3], *s, *p;
	int n, a, inc;
	Biobuf b;
	Xtab *x;

	Binit(&b, fd, OREAD);
	a = 0;
	inc = 100;
	for(; s = Brdstr(&b, '\n', 1);){
		if(p = strchr(s, '#'))
			*p = 0;
		n = tokenize(s, f, nelem(f));
		if(n != 2){
			free(s);
			continue;
		}
		if(nxtab == a){
			a += inc;
			xtab = realloc(xtab, a*sizeof *xtab);
			if(xtab == nil)
				sysfatal("realloc: %r");
			inc *= 2;
		}
		for(x = xtab+nxtab; x > xtab && strcmp(x[-1].a, f[0]) > 0; x--)
			x[0] = x[-1];
		x->a = f[0];
		x->b = f[1];
		nxtab++;
	}
}

char*
frombox(char *from)
{
	char *s;
	int n, m, fd;
	Xtab *t, *p;
	static int once;

	if(once == 0){
		once = 1;
		s = foldername(mbpath, user, "fromtab-");
		fd = open(s, OREAD);
		if(fd != -1)
			loadxfrom(fd);
		close(fd);
	}
	t = xtab;
	n = nxtab;
	while(n > 1) {
		m = n/2;
		p = t + m;
		if(strcmp(from, p->a) > 0){
			t = p;
			n = n - m;
		} else
			n = m;
	}
	if(n && strcmp(from, t->a) == 0)
		return t->b;
	return from;
}

Message*
fcmd(Cmd*, Message *m)
{
	char *f;

	f = frombox(m->from);
	if(appendtofile(m, "rawunix", f, 1, 1) < 0)
		return nil;
	return m;
}

Message*
fqcmd(Cmd*, Message *m)
{
	char *f;

	f = frombox(m->from);
	Bprint(&out, "! %s\n", f);
	return m;
}

void
system(Message *m, char *cmd, char **av, int in)
{
	switch(fork()){
	case -1:
		return;
	case 0:
		if(in >= 0){
			close(0);
			dup(in, 0);
			close(in);
		}
		if(wd[0] != 0)
			chdir(wd);
		if(m != nil && strcmp(m->path, ".") != 0)
			putenv("%", rooted(m->path));
		exec(cmd, av);
		eprint("!couldn't exec %s\n", cmd);
		exits(0);
	default:
		if(in >= 0)
			close(in);
		while(waitpid() < 0){
			if(!interrupted)
				break;
			interrupted = 0;
			continue;
		}
		break;
	}
}

Message*
bangcmd(Cmd *c, Message *m)
{
	char *av[4];

	av[0] = "rc";
	av[1] = "-c";
	av[2] = c->cmdline;
	av[3] = 0;
	system(m, "/bin/rc", av, -1);
//	Bprint(&out, "!\n");
	return m;
}

Message*
xpipecmd(Cmd *c, Message *m, char *part)
{
	char *av[4];
	int fd;

	if(c->an < 2){
		eprint("!usage: | cmd\n");
		return nil;
	}

	fd = open(extendp(m->path, part), OREAD);
	if(fd < 0){
		dissappeared();
		return nil;
	}

	av[0] = "rc";
	av[1] = "-c";
	av[2] = c->cmdline;
	av[3] = 0;
	system(m, "/bin/rc", av, fd);	/* system closes fd */
//	Bprint(&out, "!\n");
	return m;
}

Message*
pipecmd(Cmd *c, Message *m)
{
	return xpipecmd(c, m, "body");
}

Message*
rpipecmd(Cmd *c, Message *m)
{
	return xpipecmd(c, m, "rawunix");
}

void
closemb(void)
{
	int fd;

	fd = open("/mail/fs/ctl", ORDWR);
	if(fd < 0)
		sysfatal("can't open /mail/fs/ctl: %r");

	/* close current mailbox */
	if(*mbname && strcmp(mbname, "mbox") != 0)
	if(fprint(fd, "close %q", mbname) == -1)
		eprint("!close %q: %r", mbname);

	close(fd);
}

static char*
chop(char *s, int c)
{
	char *p;

	p = strrchr(s, c);
	if(p != nil && p > s) {
		*p = 0;
		return p - 1;
	}
	return 0;
}

/* sometimes opens the file (or open mbox) intended. */
int
switchmb(char *mb, int singleton)
{
	char *p, *e, pbuf[Pathlen], buf[Pathlen], file[Pathlen];
	int fd, abs;

	closemb();
	abs = 0;
	if(mb == nil)
		mb = "mbox";
	if(strcmp(mb, ".") == 0)	/* botch */
		mb = homewd;
	if(*mb == '/' || strncmp(mb, "./", 2) == 0 || strncmp(mb, "../", 3) == 0){
		snprint(file, sizeof file, "%s", mb);
		abs = 1;
	}else
		snprint(file, sizeof file, "/mail/fs/%s", mb);
	if(singleton){
		if(chop(file, '/') == nil || (p = strrchr(file, '/')) == nil || p - file < 2){
			eprint("!bad mbox name\n");
			return -1;
		}
		mboxpathbuf(pbuf, sizeof pbuf, user, "mbox");
		snprint(mbname, sizeof mbname, "%s", p + 1);
	}else if(abs || access(file, 0) < 0){
		fd = open("/mail/fs/ctl", ORDWR);
		if(fd < 0)
			sysfatal("can't open /mail/fs/ctl: %r");
		p = pbuf;
		e = pbuf + sizeof pbuf;
		if(abs && *file != '/')
			seprint(p, e, "%s/%s", getwd(buf, sizeof buf), mb);
		else if(abs)
			seprint(p, e, "%s", mb);
		else
			mboxpathbuf(pbuf, sizeof pbuf, user, mb);
		/* make up a handle to use when talking to fs */
		if((p = strrchr(mb, '/')) == nil)
			p = mb - 1;
		snprint(mbname, sizeof mbname, "%s%ld", p + 1, time(0));
		if(fprint(fd, "open %q %q", pbuf, mbname) < 0){
			eprint("!can't open %q %q: %r\n", pbuf, mbname);
			return -1;
		}
		close(fd);
		didopen = 1;
	}else{
		mboxpathbuf(pbuf, sizeof pbuf, user, mb);
		strcpy(mbname, mb);
	}

	snprint(root, sizeof root, "/mail/fs/%s", mbname);
	if(getwd(wd, sizeof wd) == nil)
		wd[0] = 0;
	if(!singleton && chdir(root) >= 0)
		strcpy(root, ".");
	rootlen = strlen(root);
	snprint(mbpath, sizeof mbpath, "%s", pbuf);
	memset(&mbqid, 0, sizeof mbqid);
	mbvers++;

	return 0;
}

char*
rooted(char *s)
{
	static char buf[Pathlen];

	if(strcmp(root, ".") != 0)
		return s;
	snprint(buf, sizeof buf, "/mail/fs/%s/%s", mbname, s);
	return buf;
}

int
plumb(Message *m, Ctype *cp)
{
	char *s;
	Plumbmsg *pm;
	static int fd = -2;

	if(cp->plumbdest == nil)
		return -1;
	if(fd < -1)
		fd = plumbopen("send", OWRITE);
	if(fd < 0)
		return -1;

	pm = mallocz(sizeof *pm, 1);
	pm->src = strdup("mail");
	if(*cp->plumbdest)
		pm->dst = strdup(cp->plumbdest);
	pm->type = strdup("text");
	pm->ndata = -1;
	s = rooted(extendp(m->path, "body"));
	if(cp->ext != nil)
		pm->data  = smprint("%s.%s", s, cp->ext);
	else
		pm->data  = strdup(s);
	plumbsend(fd, pm);
	plumbfree(pm);
	return 0;
}

void
regerror(char*)
{
}

void
exitfs(char *rv)
{
	if(startedfs)
		unmount(nil, "/mail/fs");
	chdir(homewd);			/* prof */
	exits(rv);
}