1 #include "common.h"
2 #include <ctype.h>
3 #include <plumb.h>
4 #include <9pclient.h>
5 #include <thread.h>
6 
7 #define system nedsystem
8 #define rcmd nedrcmd
9 
10 typedef struct Message Message;
11 typedef struct Ctype Ctype;
12 typedef struct Cmd Cmd;
13 
14 char	root[Pathlen];
15 char	mbname[Elemlen];
16 int	rootlen;
17 int	didopen;
18 char	*user;
19 char	wd[2048];
20 String	*mbpath;
21 int	natural;
22 int	doflush;
23 
24 int interrupted;
25 
26 struct Message {
27 	Message	*next;
28 	Message	*prev;
29 	Message	*cmd;
30 	Message	*child;
31 	Message	*parent;
32 	String	*path;
33 	int	id;
34 	int	len;
35 	int	fileno;	/* number of directory */
36 	String	*info;
37 	char	*from;
38 	char	*to;
39 	char	*cc;
40 	char	*replyto;
41 	char	*date;
42 	char	*subject;
43 	char	*type;
44 	char	*disposition;
45 	char	*filename;
46 	char	deleted;
47 	char	stored;
48 };
49 
50 Message top;
51 
52 struct Ctype {
53 	char	*type;
54 	char 	*ext;
55 	int	display;
56 	char	*plumbdest;
57 	Ctype	*next;
58 };
59 
60 Ctype ctype[] = {
61 	{ "text/plain",			"txt",	1,	0	},
62 	{ "text/html",			"htm",	1,	0	},
63 	{ "text/html",			"html",	1,	0	},
64 	{ "text/tab-separated-values",	"tsv",	1,	0	},
65 	{ "text/richtext",		"rtx",	1,	0	},
66 	{ "text/rtf",			"rtf",	1,	0	},
67 	{ "text",			"txt",	1,	0	},
68 	{ "message/rfc822",		"msg",	0,	0	},
69 	{ "message/delivery-status",	"txt",	1,	0	},
70 	{ "image/bmp",			"bmp",	0,	"image"	},
71 	{ "image/jpeg",			"jpg",	0,	"image"	},
72 	{ "image/gif",			"gif",	0,	"image"	},
73 	{ "image/png",			"png",	0,	"image"	},
74 	{ "application/pdf",		"pdf",	0,	"postscript"	},
75 	{ "application/postscript",	"ps",	0,	"postscript"	},
76 	{ "application/",		0,	0,	0	},
77 	{ "image/",			0,	0,	0	},
78 	{ "multipart/",			"mul",	0,	0	},
79 
80 };
81 
82 Message*	acmd(Cmd*, Message*);
83 Message*	bcmd(Cmd*, Message*);
84 Message*	dcmd(Cmd*, Message*);
85 Message*	eqcmd(Cmd*, Message*);
86 Message*	hcmd(Cmd*, Message*);
87 Message*	Hcmd(Cmd*, Message*);
88 Message*	helpcmd(Cmd*, Message*);
89 Message*	icmd(Cmd*, Message*);
90 Message*	pcmd(Cmd*, Message*);
91 Message*	qcmd(Cmd*, Message*);
92 Message*	rcmd(Cmd*, Message*);
93 Message*	scmd(Cmd*, Message*);
94 Message*	ucmd(Cmd*, Message*);
95 Message*	wcmd(Cmd*, Message*);
96 Message*	xcmd(Cmd*, Message*);
97 Message*	ycmd(Cmd*, Message*);
98 Message*	pipecmd(Cmd*, Message*);
99 Message*	rpipecmd(Cmd*, Message*);
100 Message*	bangcmd(Cmd*, Message*);
101 Message*	Pcmd(Cmd*, Message*);
102 Message*	mcmd(Cmd*, Message*);
103 Message*	fcmd(Cmd*, Message*);
104 Message*	quotecmd(Cmd*, Message*);
105 
106 struct {
107 	char		*cmd;
108 	int		args;
109 	Message*	(*f)(Cmd*, Message*);
110 	char		*help;
111 } cmdtab[] = {
112 	{ "a",	1,	acmd,	"a        reply to sender and recipients" },
113 	{ "A",	1,	acmd,	"A        reply to sender and recipients with copy" },
114 	{ "b",	0,	bcmd,	"b        print the next 10 headers" },
115 	{ "d",	0,	dcmd,	"d        mark for deletion" },
116 	{ "f",	0,	fcmd,	"f        file message by from address" },
117 	{ "h",	0,	hcmd,	"h        print elided message summary (,h for all)" },
118 	{ "help", 0,	helpcmd, "help     print this info" },
119 	{ "H",	0,	Hcmd,	"H        print message's MIME structure " },
120 	{ "i",	0,	icmd,	"i        incorporate new mail" },
121 	{ "m",	1,	mcmd,	"m addr   forward mail" },
122 	{ "M",	1,	mcmd,	"M addr   forward mail with message" },
123 	{ "p",	0,	pcmd,	"p        print the processed message" },
124 	{ "P",	0,	Pcmd,	"P        print the raw message" },
125 	{ "\"",	0,	quotecmd, "\"        print a quoted version of msg" },
126 	{ "q",	0,	qcmd,	"q        exit and remove all deleted mail" },
127 	{ "r",	1,	rcmd,	"r [addr] reply to sender plus any addrs specified" },
128 	{ "rf",	1,	rcmd,	"rf [addr]file message and reply" },
129 	{ "R",	1,	rcmd,	"R [addr] reply including copy of message" },
130 	{ "Rf",	1,	rcmd,	"Rf [addr]file message and reply with copy" },
131 	{ "s",	1,	scmd,	"s file   append raw message to file" },
132 	{ "u",	0,	ucmd,	"u        remove deletion mark" },
133 	{ "w",	1,	wcmd,	"w file   store message contents as file" },
134 	{ "x",	0,	xcmd,	"x        exit without flushing deleted messages" },
135 	{ "y",	0,	ycmd,	"y        synchronize with mail box" },
136 	{ "=",	1,	eqcmd,	"=        print current message number" },
137 	{ "|",	1,	pipecmd, "|cmd     pipe message body to a command" },
138 	{ "||",	1,	rpipecmd, "||cmd     pipe raw message to a command" },
139 	{ "!",	1,	bangcmd, "!cmd     run a command" },
140 	{ nil,	0,	nil, 	nil }
141 };
142 
143 enum
144 {
145 	NARG=	32
146 };
147 
148 struct Cmd {
149 	Message	*msgs;
150 	Message	*(*f)(Cmd*, Message*);
151 	int	an;
152 	char	*av[NARG];
153 	int	delete;
154 };
155 
156 Biobuf out;
157 int startedfs;
158 int reverse;
159 int longestfrom = 12;
160 
161 String*		file2string(String*, char*);
162 int		dir2message(Message*, int);
163 int		filelen(String*, char*);
164 String*		extendpath(String*, char*);
165 void		snprintheader(char*, int, Message*);
166 void		cracktime(char*, char*, int);
167 int		cistrncmp(char*, char*, int);
168 int		cistrcmp(char*, char*);
169 Reprog*		parsesearch(char**);
170 char*		parseaddr(char**, Message*, Message*, Message*, Message**);
171 char*		parsecmd(char*, Cmd*, Message*, Message*);
172 char*		readline(char*, char*, int);
173 void		messagecount(Message*);
174 void		system(char*, char**, int);
175 void		mkid(String*, Message*);
176 int		switchmb(char*, char*);
177 void		closemb(void);
178 int		lineize(char*, char**, int);
179 int		rawsearch(Message*, Reprog*);
180 Message*	dosingleton(Message*, char*);
181 String*		rooted(String*);
182 int		plumb(Message*, Ctype*);
183 String*		addrecolon(char*);
184 void		exitfs(char*);
185 Message*	flushdeleted(Message*);
186 
187 CFsys *mailfs;
188 
189 void
190 usage(void)
191 {
192 	fprint(2, "usage: %s [-nr] [-f mailfile] [-s mailfile]\n", argv0);
193 	fprint(2, "       %s -c dir\n", argv0);
194 	threadexitsall("usage");
195 }
196 
197 void
198 catchnote(void *x, char *note)
199 {
200 	USED(x);
201 
202 	if(strstr(note, "interrupt") != nil){
203 		interrupted = 1;
204 		noted(NCONT);
205 	}
206 	noted(NDFLT);
207 }
208 
209 char *
210 plural(int n)
211 {
212 	if (n == 1)
213 		return "";
214 
215 	return "s";		
216 }
217 
218 void
219 threadmain(int argc, char **argv)
220 {
221 	Message *cur, *m, *x;
222 	char cmdline[4*1024];
223 	Cmd cmd;
224 	Ctype *cp;
225 	char *err;
226 	int n, cflag;
227 	String *prompt;
228 	char *file, *singleton, *service;
229 
230 	Binit(&out, 1, OWRITE);
231 
232 	file = nil;
233 	singleton = nil;
234 	reverse = 1;
235 	cflag = 0;
236 	service = "mail";
237 	ARGBEGIN {
238 	case 'S':
239 		service = EARGF(usage());
240 		break;
241 	case 'c':
242 		cflag = 1;
243 		break;
244 	case 'f':
245 		file = EARGF(usage());
246 		break;
247 	case 's':
248 		singleton = EARGF(usage());
249 		break;
250 	case 'r':
251 		reverse = 0;
252 		break;
253 	case 'n':
254 		natural = 1;
255 		reverse = 0;
256 		break;
257 	default:
258 		usage();
259 		break;
260 	} ARGEND;
261 
262 	user = getlog();
263 	if(user == nil || *user == 0)
264 		sysfatal("can't read user name");
265 
266 	if(cflag){
267 		if(argc > 0)
268 			creatembox(user, argv[0]);
269 		else
270 			creatembox(user, nil);
271 		threadexitsall(0);
272 	}
273 
274 	if(argc)
275 		usage();
276 	if((mailfs = nsmount(service, nil)) == nil)
277 		sysfatal("cannot mount %s: %r", service);
278 
279 	switchmb(file, singleton);
280 
281 	top.path = s_copy(root);
282 
283 	for(cp = ctype; cp < ctype+nelem(ctype)-1; cp++)
284 		cp->next = cp+1;
285 
286 	if(singleton != nil){
287 		cur = dosingleton(&top, singleton);
288 		if(cur == nil){
289 			Bprint(&out, "no message\n");
290 			exitfs(0);
291 		}
292 		pcmd(nil, cur);
293 	} else {
294 		cur = &top;
295 		n = dir2message(&top, reverse);
296 		if(n < 0)
297 			sysfatal("can't read %s", s_to_c(top.path));
298 		Bprint(&out, "%d message%s\n", n, plural(n));
299 	}
300 
301 
302 	notify(catchnote);
303 	prompt = s_new();
304 	for(;;){
305 		s_reset(prompt);
306 		if(cur == &top)
307 			s_append(prompt, ": ");
308 		else {
309 			mkid(prompt, cur);
310 			s_append(prompt, ": ");
311 		}
312 
313 		/* leave space at the end of cmd line in case parsecmd needs to */
314 		/* add a space after a '|' or '!' */
315 		if(readline(s_to_c(prompt), cmdline, sizeof(cmdline)-1) == nil)
316 			break;
317 		err = parsecmd(cmdline, &cmd, top.child, cur);
318 		if(err != nil){
319 			Bprint(&out, "!%s\n", err);
320 			continue;
321 		}
322 		if(singleton != nil && cmd.f == icmd){
323 			Bprint(&out, "!illegal command\n");
324 			continue;
325 		}
326 		interrupted = 0;
327 		if(cmd.msgs == nil || cmd.msgs == &top){
328 			x = (*cmd.f)(&cmd, &top);
329 			if(x != nil)
330 				cur = x;
331 		} else for(m = cmd.msgs; m != nil; m = m->cmd){
332 			x = m;
333 			if(cmd.delete){
334 				dcmd(&cmd, x);
335 
336 				/* dp acts differently than all other commands */
337 				/* since its an old lesk idiom that people love. */
338 				/* it deletes the current message, moves the current */
339 				/* pointer ahead one and prints. */
340 				if(cmd.f == pcmd){
341 					if(x->next == nil){
342 						Bprint(&out, "!address\n");
343 						cur = x;
344 						break;
345 					} else
346 						x = x->next;
347 				}
348 			}
349 			x = (*cmd.f)(&cmd, x);
350 			if(x != nil)
351 				cur = x;
352 			if(interrupted)
353 				break;
354 			if(singleton != nil && (cmd.delete || cmd.f == dcmd))
355 				qcmd(nil, nil);
356 		}
357 		if(doflush)
358 			cur = flushdeleted(cur);
359 	}
360 	qcmd(nil, nil);
361 }
362 
363 static char*
364 mkaddrs(char *t)
365 {
366 	int i, nf, inquote;
367 	char **f, *s;
368 	Fmt fmt;
369 	
370 	inquote = 0;
371 	nf = 2;
372 	for(s=t; *s; s++){
373 		if(*s == '\'')
374 			inquote = !inquote;
375 		if(*s == ' ' && !inquote)
376 			nf++;
377 	}
378 	f = malloc(nf*sizeof f[0]);
379 	if(f == nil)
380 		return nil;
381 	nf = tokenize(t, f, nf);
382 	fmtstrinit(&fmt);
383 	for(i=0; i+1<nf; i+=2){
384 		if(i > 0)
385 			fmtprint(&fmt, " ");
386 	/*	if(f[i][0] == 0 || strcmp(f[i], f[i+1]) == 0) */
387 			fmtprint(&fmt, "%s", f[i+1]);
388 	/*	else */
389 	/*		fmtprint(&fmt, "%s <%s>", f[i], f[i+1]); */
390 	}
391 	free(f);
392 	return fmtstrflush(&fmt);
393 }
394 
395 /* */
396 /* read the message info */
397 /* */
398 Message*
399 file2message(Message *parent, char *name)
400 {
401 	Message *m;
402 	String *path;
403 	char *f[30], *s, *t;
404 	int i, nf;
405 	
406 	m = mallocz(sizeof(Message), 1);
407 	if(m == nil)
408 		return nil;
409 	m->path = path = extendpath(parent->path, name);
410 	m->fileno = atoi(name);
411 	m->info = file2string(path, "info");
412 	m->from = "";
413 	m->to = "";
414 	m->cc = "";
415 	m->replyto = "";
416 	m->date = "";
417 	m->subject = "";
418 	m->type = "";
419 	m->disposition = "";
420 	m->filename = "";
421 	nf = lineize(s_to_c(m->info), f, nelem(f));
422 	for(i=0; i<nf; i++){
423 		s = f[i];
424 		t = strchr(f[i], ' ');
425 		if(t == nil)
426 			continue;
427 		*t++ = 0;
428 		
429 		if(strcmp(s, "from") == 0)
430 			m->from = mkaddrs(t);
431 		else if(strcmp(s, "to") == 0)
432 			m->to = mkaddrs(t);
433 		else if(strcmp(s, "cc") == 0)
434 			m->cc = mkaddrs(t);
435 		else if(strcmp(s, "replyto") == 0)
436 			m->replyto = mkaddrs(t);
437 		else if(strcmp(s, "unixdate") == 0 && (t=strchr(t, ' ')) != nil)
438 			m->date = t;
439 		else if(strcmp(s, "subject") == 0)
440 			m->subject = t;
441 		else if(strcmp(s, "type") == 0)
442 			m->type = t;
443 		else if(strcmp(s, "disposition") == 0)
444 			m->disposition = t;
445 		else if(strcmp(s, "filename") == 0)
446 			m->filename = t;
447 	}
448 	m->len = filelen(path, "raw");
449 	if(strstr(m->type, "multipart") != nil || strcmp(m->type, "message/rfc822") == 0)
450 		dir2message(m, 0);
451 	m->parent = parent;
452 
453 	return m;
454 }
455 
456 void
457 freemessage(Message *m)
458 {
459 	Message *nm, *next;
460 
461 	for(nm = m->child; nm != nil; nm = next){
462 		next = nm->next;
463 		freemessage(nm);
464 	}
465 	s_free(m->path);
466 	s_free(m->info);
467 	free(m);
468 }
469 
470 /* */
471 /*  read a directory into a list of messages */
472 /* */
473 int
474 dir2message(Message *parent, int reverse)
475 {
476 	int i, n, highest, newmsgs;
477 	CFid *fd;
478 	
479 	Dir *d;
480 	Message *first, *last, *m;
481 
482 	fd = fsopen(mailfs, s_to_c(parent->path), OREAD);
483 	if(fd == nil)
484 		return -1;
485 
486 	/* count current entries */
487 	first = parent->child;
488 	highest = newmsgs = 0;
489 	for(last = parent->child; last != nil && last->next != nil; last = last->next)
490 		if(last->fileno > highest)
491 			highest = last->fileno;
492 	if(last != nil)
493 		if(last->fileno > highest)
494 			highest = last->fileno;
495 
496 	n = fsdirreadall(fd, &d);
497 	for(i = 0; i < n; i++){
498 		if((d[i].qid.type & QTDIR) == 0)
499 			continue;
500 		if(atoi(d[i].name) <= highest)
501 			continue;
502 		m = file2message(parent, d[i].name);
503 		/* fprint(2,"returned from file2message\n"); */
504 		if(m == nil)
505 			break;
506 		newmsgs++;
507 		if(reverse){
508 			m->next = first;
509 			if(first != nil)
510 				first->prev = m;
511 			first = m;
512 		} else {
513 			if(first == nil)
514 				first = m;
515 			else
516 				last->next = m;
517 			m->prev = last;
518 			last = m;
519 		}
520 	}
521 	free(d);
522 	fsclose(fd);
523 	parent->child = first;
524 
525 	/* renumber and file longest from */
526 	i = 1;
527 	longestfrom = 12;
528 	for(m = first; m != nil; m = m->next){
529 		m->id = natural ? m->fileno : i++;
530 		n = strlen(m->from);
531 		if(n > longestfrom)
532 			longestfrom = n;
533 	}
534 
535 	return newmsgs;
536 }
537 
538 /* */
539 /*  point directly to a message */
540 /* */
541 Message*
542 dosingleton(Message *parent, char *path)
543 {
544 	char *p, *np;
545 	Message *m;
546 
547 	/* walk down to message and read it */
548 	if(strlen(path) < rootlen)
549 		return nil;
550 	if(path[rootlen] != '/')
551 		return nil;
552 	p = path+rootlen+1;
553 	np = strchr(p, '/');
554 	if(np != nil)
555 		*np = 0;
556 	m = file2message(parent, p);
557 	if(m == nil)
558 		return nil;
559 	parent->child = m;
560 	m->id = 1;
561 
562 	/* walk down to requested component */
563 	while(np != nil){
564 		*np = '/';
565 		np = strchr(np+1, '/');
566 		if(np != nil)
567 			*np = 0;
568 		for(m = m->child; m != nil; m = m->next)
569 			if(strcmp(path, s_to_c(m->path)) == 0)
570 				return m;
571 		if(m == nil)
572 			return nil;
573 	}
574 	return m;
575 }
576 
577 /* */
578 /*  read a file into a string */
579 /* */
580 String*
581 file2string(String *dir, char *file)
582 {
583 	String *s;
584 	int n, m;
585 	CFid *fd;
586 
587 	s = extendpath(dir, file);
588 	fd = fsopen(mailfs, s_to_c(s), OREAD);
589 	s_grow(s, 512);			/* avoid multiple reads on info files */
590 	s_reset(s);
591 	if(fd == nil)
592 		return s;
593 
594 	for(;;){
595 		n = s->end - s->ptr;
596 		if(n == 0){
597 			s_grow(s, 128);
598 			continue;
599 		}
600 		m = fsread(fd, s->ptr, n);
601 		if(m <= 0)
602 			break;
603 		s->ptr += m;
604 		if(m < n)
605 			break;
606 	}
607 	s_terminate(s);
608 	fsclose(fd);
609 
610 	return s;
611 }
612 
613 /* */
614 /*  get the length of a file */
615 /* */
616 int
617 filelen(String *dir, char *file)
618 {
619 	String *path;
620 	Dir *d;
621 	int rv;
622 
623 	path = extendpath(dir, file);
624 	d = fsdirstat(mailfs, s_to_c(path));
625 	if(d == nil){
626 		s_free(path);
627 		return -1;
628 	}
629 	s_free(path);
630 	rv = d->length;
631 	free(d);
632 	return rv;
633 }
634 
635 /* */
636 /*  walk the path name an element */
637 /* */
638 String*
639 extendpath(String *dir, char *name)
640 {
641 	String *path;
642 
643 	if(strcmp(s_to_c(dir), ".") == 0)
644 		path = s_new();
645 	else {
646 		path = s_copy(s_to_c(dir));
647 		s_append(path, "/");
648 	}
649 	s_append(path, name);
650 	return path;
651 }
652 
653 int
654 cistrncmp(char *a, char *b, int n)
655 {
656 	while(n-- > 0){
657 		if(tolower(*a++) != tolower(*b++))
658 			return -1;
659 	}
660 	return 0;
661 }
662 
663 int
664 cistrcmp(char *a, char *b)
665 {
666 	for(;;){
667 		if(tolower(*a) != tolower(*b++))
668 			return -1;
669 		if(*a++ == 0)
670 			break;
671 	}
672 	return 0;
673 }
674 
675 char*
676 nosecs(char *t)
677 {
678 	char *p;
679 
680 	p = strchr(t, ':');
681 	if(p == nil)
682 		return t;
683 	p = strchr(p+1, ':');
684 	if(p != nil)
685 		*p = 0;
686 	return t;
687 }
688 
689 char *months[12] =
690 {
691 	"jan", "feb", "mar", "apr", "may", "jun",
692 	"jul", "aug", "sep", "oct", "nov", "dec"
693 };
694 
695 int
696 month(char *m)
697 {
698 	int i;
699 
700 	for(i = 0; i < 12; i++)
701 		if(cistrcmp(m, months[i]) == 0)
702 			return i+1;
703 	return 1;
704 }
705 
706 enum
707 {
708 	Yearsecs= 365*24*60*60
709 };
710 
711 void
712 cracktime(char *d, char *out, int len)
713 {
714 	char in[64];
715 	char *f[6];
716 	int n;
717 	Tm tm;
718 	long now, then;
719 	char *dtime;
720 
721 	*out = 0;
722 	if(d == nil)
723 		return;
724 	strncpy(in, d, sizeof(in));
725 	in[sizeof(in)-1] = 0;
726 	n = getfields(in, f, 6, 1, " \t\r\n");
727 	if(n != 6){
728 		/* unknown style */
729 		snprint(out, 16, "%10.10s", d);
730 		return;
731 	}
732 	now = time(0);
733 	memset(&tm, 0, sizeof tm);
734 	if(strchr(f[0], ',') != nil && strchr(f[4], ':') != nil){
735 		/* 822 style */
736 		tm.year = atoi(f[3])-1900;
737 		tm.mon = month(f[2]);
738 		tm.mday = atoi(f[1]);
739 		dtime = nosecs(f[4]);
740 		then = tm2sec(&tm);
741 	} else if(strchr(f[3], ':') != nil){
742 		/* unix style */
743 		tm.year = atoi(f[5])-1900;
744 		tm.mon = month(f[1]);
745 		tm.mday = atoi(f[2]);
746 		dtime = nosecs(f[3]);
747 		then = tm2sec(&tm);
748 	} else {
749 		then = now;
750 		tm = *localtime(now);
751 		dtime = "";
752 	}
753 
754 	if(now - then < Yearsecs/2)
755 		snprint(out, len, "%2d/%2.2d %s", tm.mon, tm.mday, dtime);
756 	else
757 		snprint(out, len, "%2d/%2.2d  %4d", tm.mon, tm.mday, tm.year+1900);
758 }
759 
760 Ctype*
761 findctype(Message *m)
762 {
763 	char *p;
764 	char ftype[128];
765 	int n, pfd[2];
766 	Ctype *a, *cp;
767 	static Ctype bintype 	= { "application/octet-stream", "bin", 0, 0 };
768 
769 	for(cp = ctype; cp; cp = cp->next)
770 		if(strncmp(cp->type, m->type, strlen(cp->type)) == 0)
771 			return cp;
772 
773 	if(pipe(pfd) < 0)
774 		return &bintype;
775 
776 	*ftype = 0;
777 	switch(fork()){
778 	case -1:
779 		break;
780 	case 0:
781 		close(pfd[1]);
782 		close(0);
783 		dup(pfd[0], 0);
784 		close(1);
785 		dup(pfd[0], 1);
786 		execl(unsharp("#9/bin/file"), "file", "-m", s_to_c(extendpath(m->path, "body")), nil);
787 		threadexits(0);
788 	default:
789 		close(pfd[0]);
790 		n = read(pfd[1], ftype, sizeof(ftype));
791 		if(n > 0)
792 			ftype[n] = 0;
793 		close(pfd[1]);
794 		waitpid();
795 		break;
796 	}
797 
798 	if (*ftype=='\0' || (p = strchr(ftype, '/')) == nil)
799 		return &bintype;
800 	*p++ = 0;
801 
802 	a = mallocz(sizeof(Ctype), 1);
803 	a->type = strdup(ftype);
804 	a->ext = strdup(p);
805 	a->display = 0;
806 	a->plumbdest = strdup(ftype);
807 	for(cp = ctype; cp->next; cp = cp->next)
808 		continue;
809 	cp->next = a;
810 	a->next = nil;
811 	return a;
812 }
813 
814 void
815 mkid(String *s, Message *m)
816 {
817 	char buf[32];
818 
819 	if(m->parent != &top){
820 		mkid(s, m->parent);
821 		s_append(s, ".");
822 	}
823 	sprint(buf, "%d", m->id);
824 	s_append(s, buf);
825 }
826 
827 void
828 snprintheader(char *buf, int len, Message *m)
829 {
830 	char timebuf[32];
831 	String *id;
832 	char *p, *q;;
833 
834 	/* create id */
835 	id = s_new();
836 	mkid(id, m);
837 
838 	if(*m->from == 0){
839 		/* no from */
840 		snprint(buf, len, "%-3s    %s %6d  %s",
841 			s_to_c(id),
842 			m->type,
843 			m->len,
844 			m->filename);
845 	} else if(*m->subject){
846 		q = p = strdup(m->subject);
847 		while(*p == ' ')
848 			p++;
849 		if(strlen(p) > 50)
850 			p[50] = 0;
851 		cracktime(m->date, timebuf, sizeof(timebuf));
852 		snprint(buf, len, "%-3s %c%c%c %6d  %11.11s %-*.*s %s",
853 			s_to_c(id),
854 			m->child ? 'H' : ' ',
855 			m->deleted ? 'd' : ' ',
856 			m->stored ? 's' : ' ',
857 			m->len,
858 			timebuf,
859 			longestfrom, longestfrom, m->from,
860 			p);
861 		free(q);
862 	} else {
863 		cracktime(m->date, timebuf, sizeof(timebuf));
864 		snprint(buf, len, "%-3s %c%c%c %6d  %11.11s %s",
865 			s_to_c(id),
866 			m->child ? 'H' : ' ',
867 			m->deleted ? 'd' : ' ',
868 			m->stored ? 's' : ' ',
869 			m->len,
870 			timebuf,
871 			m->from);
872 	}
873 	s_free(id);
874 }
875 
876 char *spaces = "                                                                    ";
877 
878 void
879 snprintHeader(char *buf, int len, int indent, Message *m)
880 {
881 	String *id;
882 	char typeid[64];
883 	char *p, *e;
884 
885 	/* create id */
886 	id = s_new();
887 	mkid(id, m);
888 
889 	e = buf + len;
890 
891 	snprint(typeid, sizeof typeid, "%s    %s", s_to_c(id), m->type);
892 	if(indent < 6)
893 		p = seprint(buf, e, "%-32s %-6d ", typeid, m->len);
894 	else
895 		p = seprint(buf, e, "%-64s %-6d ", typeid, m->len);
896 	if(m->filename && *m->filename)
897 		p = seprint(p, e, "(file,%s)", m->filename);
898 	if(m->from && *m->from)
899 		p = seprint(p, e, "(from,%s)", m->from);
900 	if(m->subject && *m->subject)
901 		seprint(p, e, "(subj,%s)", m->subject);
902 
903 	s_free(id);
904 }
905 
906 char sstring[256];
907 
908 /*	cmd := range cmd ' ' arg-list ;  */
909 /*	range := address */
910 /*		| address ',' address */
911 /*		| 'g' search ; */
912 /*	address := msgno */
913 /*		| search ; */
914 /*	msgno := number */
915 /*		| number '/' msgno ; */
916 /*	search := '/' string '/' */
917 /*		| '%' string '%' ; */
918 /* */
919 Reprog*
920 parsesearch(char **pp)
921 {
922 	char *p, *np;
923 	int c, n;
924 
925 	p = *pp;
926 	c = *p++;
927 	np = strchr(p, c);
928 	if(np != nil){
929 		*np++ = 0;
930 		*pp = np;
931 	} else {
932 		n = strlen(p);
933 		*pp = p + n;
934 	}
935 	if(*p == 0)
936 		p = sstring;
937 	else{
938 		strncpy(sstring, p, sizeof(sstring));
939 		sstring[sizeof(sstring)-1] = 0;
940 	}
941 	return regcomp(p);
942 }
943 
944 char*
945 parseaddr(char **pp, Message *first, Message *cur, Message *unspec, Message **mp)
946 {
947 	int n;
948 	Message *m;
949 	char *p;
950 	Reprog *prog;
951 	int c, sign;
952 	char buf[256];
953 
954 	*mp = nil;
955 	p = *pp;
956 
957 	if(*p == '+'){
958 		sign = 1;
959 		p++;
960 		*pp = p;
961 	} else if(*p == '-'){
962 		sign = -1;
963 		p++;
964 		*pp = p;
965 	} else
966 		sign = 0;
967 
968 	switch(*p){
969 	default:
970 		if(sign){
971 			n = 1;
972 			goto number;
973 		}
974 		*mp = unspec;
975 		break;	
976 	case '0': case '1': case '2': case '3': case '4':
977 	case '5': case '6': case '7': case '8': case '9':
978 		n = strtoul(p, pp, 10);
979 		if(n == 0){
980 			if(sign)
981 				*mp = cur;
982 			else
983 				*mp = &top;
984 			break;
985 		}
986 	number:
987 		m = nil;
988 		switch(sign){
989 		case 0:
990 			for(m = first; m != nil; m = m->next)
991 				if(m->id == n)
992 					break;
993 			break;
994 		case -1:
995 			if(cur != &top)
996 				for(m = cur; m != nil && n > 0; n--)
997 					m = m->prev;
998 			break;
999 		case 1:
1000 			if(cur == &top){
1001 				n--;
1002 				cur = first;
1003 			}
1004 			for(m = cur; m != nil && n > 0; n--)
1005 				m = m->next;
1006 			break;
1007 		}
1008 		if(m == nil)
1009 			return "address";
1010 		*mp = m;
1011 		break;
1012 	case '%':
1013 	case '/':
1014 	case '?':
1015 		c = *p;
1016 		prog = parsesearch(pp);
1017 		if(prog == nil)
1018 			return "badly formed regular expression";
1019 		m = nil;
1020 		switch(c){
1021 		case '%':
1022 			for(m = cur == &top ? first : cur->next; m != nil; m = m->next){
1023 				if(rawsearch(m, prog))
1024 					break;
1025 			}
1026 			break;
1027 		case '/':
1028 			for(m = cur == &top ? first : cur->next; m != nil; m = m->next){
1029 				snprintheader(buf, sizeof(buf), m);
1030 				if(regexec(prog, buf, nil, 0))
1031 					break;
1032 			}
1033 			break;
1034 		case '?':
1035 			for(m = cur == &top ? nil : cur->prev; m != nil; m = m->prev){
1036 				snprintheader(buf, sizeof(buf), m);
1037 				if(regexec(prog, buf, nil, 0))
1038 					break;
1039 			}
1040 			break;
1041 		}
1042 		if(m == nil)
1043 			return "search";
1044 		*mp = m;
1045 		free(prog);
1046 		break;
1047 	case '$':
1048 		for(m = first; m != nil && m->next != nil; m = m->next)
1049 			;
1050 		*mp = m;
1051 		*pp = p+1;
1052 		break;
1053 	case '.':
1054 		*mp = cur;
1055 		*pp = p+1;
1056 		break;
1057 	case ',':
1058 		*mp = first;
1059 		*pp = p;
1060 		break;
1061 	}
1062 
1063 	if(*mp != nil && **pp == '.'){
1064 		(*pp)++;
1065 		if((*mp)->child == nil)
1066 			return "no sub parts";
1067 		return parseaddr(pp, (*mp)->child, (*mp)->child, (*mp)->child, mp);
1068 	}
1069 	if(**pp == '+' || **pp == '-' || **pp == '/' || **pp == '%')
1070 		return parseaddr(pp, first, *mp, *mp, mp);
1071 
1072 	return nil;
1073 }
1074 
1075 /* */
1076 /*  search a message for a regular expression match */
1077 /* */
1078 int
1079 rawsearch(Message *m, Reprog *prog)
1080 {
1081 	char buf[4096+1];
1082 	int i, rv;
1083 	CFid *fd;
1084 	String *path;
1085 
1086 	path = extendpath(m->path, "raw");
1087 	fd = fsopen(mailfs, s_to_c(path), OREAD);
1088 	if(fd == nil)
1089 		return 0;
1090 
1091 	/* march through raw message 4096 bytes at a time */
1092 	/* with a 128 byte overlap to chain the re search. */
1093 	rv = 0;
1094 	for(;;){
1095 		i = fsread(fd, buf, sizeof(buf)-1);
1096 		if(i <= 0)
1097 			break;
1098 		buf[i] = 0;
1099 		if(regexec(prog, buf, nil, 0)){
1100 			rv = 1;
1101 			break;
1102 		}
1103 		if(i < sizeof(buf)-1)
1104 			break;
1105 		if(fsseek(fd, -128LL, 1) < 0)
1106 			break;
1107 	}
1108 
1109 	fsclose(fd);
1110 	s_free(path);
1111 	return rv;
1112 }
1113 
1114 
1115 char*
1116 parsecmd(char *p, Cmd *cmd, Message *first, Message *cur)
1117 {
1118 	Reprog *prog;
1119 	Message *m, *s, *e, **l, *last;
1120 	char buf[256];
1121 	char *err;
1122 	int i, c;
1123 	char *q;
1124 	static char errbuf[Errlen];
1125 
1126 	cmd->delete = 0;
1127 	l = &cmd->msgs;
1128 	*l = nil;
1129 
1130 	/* eat white space */
1131 	while(*p == ' ')
1132 		p++;
1133 
1134 	/* null command is a special case (advance and print) */
1135 	if(*p == 0){
1136 		if(cur == &top){
1137 			/* special case */
1138 			m = first;
1139 		} else {
1140 			/* walk to the next message even if we have to go up */
1141 			m = cur->next;
1142 			while(m == nil && cur->parent != nil){
1143 				cur = cur->parent;
1144 				m = cur->next;
1145 			}
1146 		}
1147 		if(m == nil)
1148 			return "address";
1149 		*l = m;
1150 		m->cmd = nil;
1151 		cmd->an = 0;
1152 		cmd->f = pcmd;
1153 		return nil;
1154 	}
1155 
1156 	/* global search ? */
1157 	if(*p == 'g'){
1158 		p++;
1159 
1160 		/* no search string means all messages */
1161 		if(*p != '/' && *p != '%'){
1162 			for(m = first; m != nil; m = m->next){
1163 				*l = m;
1164 				l = &m->cmd;
1165 				*l = nil;
1166 			}
1167 		} else {
1168 			/* mark all messages matching this search string */
1169 			c = *p;
1170 			prog = parsesearch(&p);
1171 			if(prog == nil)
1172 				return "badly formed regular expression";
1173 			if(c == '%'){
1174 				for(m = first; m != nil; m = m->next){
1175 					if(rawsearch(m, prog)){
1176 						*l = m;
1177 						l = &m->cmd;
1178 						*l = nil;
1179 					}
1180 				}
1181 			} else {
1182 				for(m = first; m != nil; m = m->next){
1183 					snprintheader(buf, sizeof(buf), m);
1184 					if(regexec(prog, buf, nil, 0)){
1185 						*l = m;
1186 						l = &m->cmd;
1187 						*l = nil;
1188 					}
1189 				}
1190 			}
1191 			free(prog);
1192 		}
1193 	} else {
1194 	
1195 		/* parse an address */
1196 		s = e = nil;
1197 		err = parseaddr(&p, first, cur, cur, &s);
1198 		if(err != nil)
1199 			return err;
1200 		if(*p == ','){
1201 			/* this is an address range */
1202 			if(s == &top)
1203 				s = first;
1204 			p++;
1205 			for(last = s; last != nil && last->next != nil; last = last->next)
1206 				;
1207 			err = parseaddr(&p, first, cur, last, &e);
1208 			if(err != nil)
1209 				return err;
1210 	
1211 			/* select all messages in the range */
1212 			for(; s != nil; s = s->next){
1213 				*l = s;
1214 				l = &s->cmd;
1215 				*l = nil;
1216 				if(s == e)
1217 					break;
1218 			}
1219 			if(s == nil)
1220 				return "null address range";
1221 		} else {
1222 			/* single address */
1223 			if(s != &top){
1224 				*l = s;
1225 				s->cmd = nil;
1226 			}
1227 		}
1228 	}
1229 
1230 	/* insert a space after '!'s and '|'s */
1231 	for(q = p; *q; q++)
1232 		if(*q != '!' && *q != '|')
1233 			break;
1234 	if(q != p && *q != ' '){
1235 		memmove(q+1, q, strlen(q)+1);
1236 		*q = ' ';
1237 	}
1238 
1239 	cmd->an = getfields(p, cmd->av, nelem(cmd->av) - 1, 1, " \t\r\n");
1240 	if(cmd->an == 0 || *cmd->av[0] == 0)
1241 		cmd->f = pcmd;
1242 	else {
1243 		/* hack to allow all messages to start with 'd' */
1244 		if(*(cmd->av[0]) == 'd' && *(cmd->av[0]+1) != 0){
1245 			cmd->delete = 1;
1246 			cmd->av[0]++;
1247 		}
1248 
1249 		/* search command table */
1250 		for(i = 0; cmdtab[i].cmd != nil; i++)
1251 			if(strcmp(cmd->av[0], cmdtab[i].cmd) == 0)
1252 				break;
1253 		if(cmdtab[i].cmd == nil)
1254 			return "illegal command";
1255 		if(cmdtab[i].args == 0 && cmd->an > 1){
1256 			snprint(errbuf, sizeof(errbuf), "%s doesn't take an argument", cmdtab[i].cmd);
1257 			return errbuf;
1258 		}
1259 		cmd->f = cmdtab[i].f;
1260 	}
1261 	return nil; 
1262 }
1263 
1264 /* inefficient read from standard input */
1265 char*
1266 readline(char *prompt, char *line, int len)
1267 {
1268 	char *p, *e;
1269 	int n;
1270 
1271 retry:
1272 	interrupted = 0;
1273 	Bprint(&out, "%s", prompt);
1274 	Bflush(&out);
1275 	e = line + len;
1276 	for(p = line; p < e; p++){
1277 		n = read(0, p, 1);
1278 		if(n < 0){
1279 			if(interrupted)
1280 				goto retry;
1281 			return nil;
1282 		}
1283 		if(n == 0)
1284 			return nil;
1285 		if(*p == '\n')
1286 			break;
1287 	}
1288 	*p = 0;
1289 	return line;
1290 }
1291 
1292 void
1293 messagecount(Message *m)
1294 {
1295 	int i;
1296 
1297 	i = 0;
1298 	for(; m != nil; m = m->next)
1299 		i++;
1300 	Bprint(&out, "%d message%s\n", i, plural(i));
1301 }
1302 
1303 Message*
1304 aichcmd(Message *m, int indent)
1305 {
1306 	char	hdr[256];
1307 
1308 	if(m == &top)
1309 		return nil;
1310 
1311 	snprintHeader(hdr, sizeof(hdr), indent, m);
1312 	Bprint(&out, "%s\n", hdr);
1313 	for(m = m->child; m != nil; m = m->next)
1314 		aichcmd(m, indent+1);
1315 	return nil;
1316 }
1317 
1318 Message*
1319 Hcmd(Cmd *x, Message *m)
1320 {
1321 	USED(x);
1322 
1323 	if(m == &top)
1324 		return nil;
1325 	aichcmd(m, 0);
1326 	return nil;
1327 }
1328 
1329 Message*
1330 hcmd(Cmd *x, Message *m)
1331 {
1332 	char	hdr[256];
1333 
1334 	USED(x);
1335 	if(m == &top)
1336 		return nil;
1337 
1338 	snprintheader(hdr, sizeof(hdr), m);
1339 	Bprint(&out, "%s\n", hdr);
1340 	return nil;
1341 }
1342 
1343 Message*
1344 bcmd(Cmd *x, Message *m)
1345 {
1346 	int i;
1347 	Message *om = m;
1348 
1349 	USED(x);
1350 	if(m == &top)
1351 		m = top.child;
1352 	for(i = 0; i < 10 && m != nil; i++){
1353 		hcmd(nil, m);
1354 		om = m;
1355 		m = m->next;
1356 	}
1357 
1358 	return om;
1359 }
1360 
1361 Message*
1362 ncmd(Cmd *x, Message *m)
1363 {
1364 	USED(x);
1365 	if(m == &top)
1366 		return m->child;
1367 	return m->next;
1368 }
1369 
1370 int
1371 printpart(String *s, char *part)
1372 {
1373 	char buf[4096];
1374 	int n, tot;
1375 	CFid *fd;
1376 	String *path;
1377 
1378 	path = extendpath(s, part);
1379 	fd = fsopen(mailfs, s_to_c(path), OREAD);
1380 	s_free(path);
1381 	if(fd == nil){
1382 		fprint(2, "!message dissappeared\n");
1383 		return 0;
1384 	}
1385 	tot = 0;
1386 	while((n = fsread(fd, buf, sizeof(buf))) > 0){
1387 		if(interrupted)
1388 			break;
1389 		if(Bwrite(&out, buf, n) <= 0)
1390 			break;
1391 		tot += n;
1392 	}
1393 	fsclose(fd);
1394 	return tot;
1395 }
1396 
1397 int
1398 printhtml(Message *m)
1399 {
1400 	Cmd c;
1401 
1402 	c.an = 3;
1403 	c.av[1] = "htmlfmt";
1404 	c.av[2] = "-l 40 -cutf-8";
1405 	Bprint(&out, "!%s\n", c.av[1]);
1406 	Bflush(&out);
1407 	pipecmd(&c, m);
1408 	return 0;
1409 }
1410 
1411 Message*
1412 Pcmd(Cmd *x, Message *m)
1413 {
1414 	USED(x);
1415 	if(m == &top)
1416 		return &top;
1417 	if(m->parent == &top)
1418 		printpart(m->path, "unixheader");
1419 	printpart(m->path, "raw");
1420 	return m;
1421 }
1422 
1423 void
1424 compress(char *p)
1425 {
1426 	char *np;
1427 	int last;
1428 
1429 	last = ' ';
1430 	for(np = p; *p; p++){
1431 		if(*p != ' ' || last != ' '){
1432 			last = *p;
1433 			*np++ = last;
1434 		}
1435 	}
1436 	*np = 0;
1437 }
1438 
1439 Message*
1440 pcmd(Cmd *x, Message *m)
1441 {
1442 	Message *nm;
1443 	Ctype *cp;
1444 	String *s;
1445 	char buf[128];
1446 
1447 	USED(x);
1448 	if(m == &top)
1449 		return &top;
1450 	if(m->parent == &top)
1451 		printpart(m->path, "unixheader");
1452 	if(printpart(m->path, "header") > 0)
1453 		Bprint(&out, "\n");
1454 	cp = findctype(m);
1455 	if(cp->display){
1456 		if(strcmp(m->type, "text/html") == 0)
1457 			printhtml(m);
1458 		else
1459 			printpart(m->path, "body");
1460 	} else if(strcmp(m->type, "multipart/alternative") == 0){
1461 		for(nm = m->child; nm != nil; nm = nm->next){
1462 			cp = findctype(nm);
1463 			if(cp->ext != nil && strncmp(cp->ext, "txt", 3) == 0)
1464 				break;
1465 		}
1466 		if(nm == nil)
1467 			for(nm = m->child; nm != nil; nm = nm->next){
1468 				cp = findctype(nm);
1469 				if(cp->display)
1470 					break;
1471 			}
1472 		if(nm != nil)
1473 			pcmd(nil, nm);
1474 		else
1475 			hcmd(nil, m);
1476 	} else if(strncmp(m->type, "multipart/", 10) == 0){
1477 		nm = m->child;
1478 		if(nm != nil){
1479 			/* always print first part */
1480 			pcmd(nil, nm);
1481 
1482 			for(nm = nm->next; nm != nil; nm = nm->next){
1483 				s = rooted(s_clone(nm->path));
1484 				cp = findctype(nm);
1485 				snprintHeader(buf, sizeof buf, -1, nm);
1486 				compress(buf);
1487 				if(strcmp(nm->disposition, "inline") == 0){
1488 					if(cp->ext != nil)
1489 						Bprint(&out, "\n--- %s %s/body.%s\n\n",
1490 							buf, s_to_c(s), cp->ext);
1491 					else
1492 						Bprint(&out, "\n--- %s %s/body\n\n",
1493 							buf, s_to_c(s));
1494 					pcmd(nil, nm);
1495 				} else {
1496 					if(cp->ext != nil)
1497 						Bprint(&out, "\n!--- %s %s/body.%s\n",
1498 							buf, s_to_c(s), cp->ext);
1499 					else
1500 						Bprint(&out, "\n!--- %s %s/body\n",
1501 							buf, s_to_c(s));
1502 				}
1503 				s_free(s);
1504 			}
1505 		} else {
1506 			hcmd(nil, m);
1507 		}
1508 	} else if(strcmp(m->type, "message/rfc822") == 0){
1509 		pcmd(nil, m->child);
1510 	} else if(plumb(m, cp) >= 0)
1511 		Bprint(&out, "\n!--- using plumber to display message of type %s\n", m->type);
1512 	else
1513 		Bprint(&out, "\n!--- cannot display messages of type %s\n", m->type);
1514 		
1515 	return m;
1516 }
1517 
1518 void
1519 printpartindented(String *s, char *part, char *indent)
1520 {
1521 	int fd;
1522 	char *p;
1523 	String *path;
1524 	Biobuf *b;
1525 
1526 	path = extendpath(s, part);
1527 	fd = fsopenfd(mailfs, s_to_c(path), OREAD);
1528 	s_free(path);
1529 	if(fd < 0){
1530 		fprint(2, "!message disappeared\n");
1531 		return;
1532 	}
1533 	b = Bfdopen(fd, OREAD);
1534 	if(b == 0){
1535 		fprint(2, "out of memory\n");
1536 		close(fd);
1537 		return;
1538 	}
1539 	while((p = Brdline(b, '\n')) != nil){
1540 		if(interrupted)
1541 			break;
1542 		p[Blinelen(b)-1] = 0;
1543 		if(Bprint(&out, "%s%s\n", indent, p) < 0)
1544 			break;
1545 	}
1546 	Bprint(&out, "\n");
1547 	Bterm(b);
1548 }
1549 
1550 Message*
1551 quotecmd(Cmd *x, Message *m)
1552 {
1553 	Message *nm;
1554 	Ctype *cp;
1555 
1556 	USED(x);
1557 	if(m == &top)
1558 		return &top;
1559 	Bprint(&out, "\n");
1560 	if(m->from != nil && *m->from)
1561 		Bprint(&out, "On %s, %s wrote:\n", m->date, m->from);
1562 	cp = findctype(m);
1563 	if(cp->display){
1564 		printpartindented(m->path, "body", "> ");
1565 	} else if(strcmp(m->type, "multipart/alternative") == 0){
1566 		for(nm = m->child; nm != nil; nm = nm->next){
1567 			cp = findctype(nm);
1568 			if(cp->ext != nil && strncmp(cp->ext, "txt", 3) == 0)
1569 				break;
1570 		}
1571 		if(nm == nil)
1572 			for(nm = m->child; nm != nil; nm = nm->next){
1573 				cp = findctype(nm);
1574 				if(cp->display)
1575 					break;
1576 			}
1577 		if(nm != nil)
1578 			quotecmd(nil, nm);
1579 	} else if(strncmp(m->type, "multipart/", 10) == 0){
1580 		nm = m->child;
1581 		if(nm != nil){
1582 			cp = findctype(nm);
1583 			if(cp->display || strncmp(m->type, "multipart/", 10) == 0)
1584 				quotecmd(nil, nm);
1585 		}
1586 	}
1587 	return m;
1588 }
1589 
1590 /* really delete messages */
1591 Message*
1592 flushdeleted(Message *cur)
1593 {
1594 	Message *m, **l;
1595 	char buf[1024], *p, *e, *msg;
1596 	int deld, n;
1597 	CFid *fd;
1598 	int i;
1599 
1600 	doflush = 0;
1601 	deld = 0;
1602 
1603 	snprint(buf, sizeof buf, "%s/ctl", mbname);
1604 	fd = fsopen(mailfs, buf, OWRITE);
1605 	if(fd == nil){
1606 		fprint(2, "!can't delete mail, opening %s: %r\n", buf);
1607 		exitfs(0);
1608 	}
1609 	e = &buf[sizeof(buf)];
1610 	p = seprint(buf, e, "delete");
1611 	n = 0;
1612 	for(l = &top.child; *l != nil;){
1613 		m = *l;
1614 		if(!m->deleted){
1615 			l = &(*l)->next;
1616 			continue;
1617 		}
1618 
1619 		/* don't return a pointer to a deleted message */
1620 		if(m == cur)
1621 			cur = m->next;
1622 
1623 		deld++;
1624 		msg = strrchr(s_to_c(m->path), '/');
1625 		if(msg == nil)
1626 			msg = s_to_c(m->path);
1627 		else
1628 			msg++;
1629 		if(e-p < 10){
1630 			fswrite(fd, buf, p-buf);
1631 			n = 0;
1632 			p = seprint(buf, e, "delete");
1633 		}
1634 		p = seprint(p, e, " %s", msg);
1635 		n++;
1636 
1637 		/* unchain and free */
1638 		*l = m->next;
1639 		if(m->next)
1640 			m->next->prev = m->prev;
1641 		freemessage(m);
1642 	}
1643 	if(n)
1644 		fswrite(fd, buf, p-buf);
1645 
1646 	fsclose(fd);
1647 
1648 	if(deld)
1649 		Bprint(&out, "!%d message%s deleted\n", deld, plural(deld));
1650 
1651 	/* renumber */
1652 	i = 1;
1653 	for(m = top.child; m != nil; m = m->next)
1654 		m->id = natural ? m->fileno : i++;
1655 
1656 	/* if we're out of messages, go back to first */
1657 	/* if no first, return the fake first */
1658 	if(cur == nil){
1659 		if(top.child)
1660 			return top.child;
1661 		else
1662 			return &top;
1663 	}
1664 	return cur;
1665 }
1666 
1667 Message*
1668 qcmd(Cmd *x, Message *m)
1669 {
1670 	USED(x);
1671 	USED(m);
1672 
1673 	flushdeleted(nil);
1674 
1675 	if(didopen)
1676 		closemb();
1677 	Bflush(&out);
1678 
1679 	exitfs(0);
1680 	return nil;	/* not reached */
1681 }
1682 
1683 Message*
1684 ycmd(Cmd *x, Message *m)
1685 {
1686 	USED(x);
1687 	
1688 	doflush = 1;
1689 
1690 	return icmd(nil, m);
1691 }
1692 
1693 Message*
1694 xcmd(Cmd *x, Message *m)
1695 {
1696 	USED(x);
1697 	USED(m);
1698 
1699 	exitfs(0);
1700 	return nil;	/* not reached */
1701 }
1702 
1703 Message*
1704 eqcmd(Cmd *x, Message *m)
1705 {
1706 	USED(x);
1707 
1708 	if(m == &top)
1709 		Bprint(&out, "0\n");
1710 	else
1711 		Bprint(&out, "%d\n", m->id);
1712 	return nil;
1713 }
1714 
1715 Message*
1716 dcmd(Cmd *x, Message *m)
1717 {
1718 	USED(x);
1719 
1720 	if(m == &top){
1721 		Bprint(&out, "!address\n");
1722 		return nil;
1723 	}
1724 	while(m->parent != &top)
1725 		m = m->parent;
1726 	m->deleted = 1;
1727 	return m;
1728 }
1729 
1730 Message*
1731 ucmd(Cmd *x, Message *m)
1732 {
1733 	USED(x);
1734 
1735 	if(m == &top)
1736 		return nil;
1737 	while(m->parent != &top)
1738 		m = m->parent;
1739 	if(m->deleted < 0)
1740 		Bprint(&out, "!can't undelete, already flushed\n");
1741 	m->deleted = 0;
1742 	return m;
1743 }
1744 
1745 
1746 Message*
1747 icmd(Cmd *x, Message *m)
1748 {
1749 	int n;
1750 	char buf[1024];
1751 	CFid *fd;
1752 
1753 	USED(x);
1754 	snprint(buf, sizeof buf, "%s/ctl", mbname);
1755 	fd = fsopen(mailfs, buf, OWRITE);
1756 	if(fd){
1757 		fswrite(fd, "refresh", 7);
1758 		fsclose(fd);
1759 	}
1760 	n = dir2message(&top, reverse);
1761 	if(n > 0)
1762 		Bprint(&out, "%d new message%s\n", n, plural(n));
1763 	return m;
1764 }
1765 
1766 Message*
1767 helpcmd(Cmd *x, Message *m)
1768 {
1769 	int i;
1770 
1771 	USED(x);
1772 	Bprint(&out, "Commands are of the form [<range>] <command> [args]\n");
1773 	Bprint(&out, "<range> := <addr> | <addr>','<addr>| 'g'<search>\n");
1774 	Bprint(&out, "<addr> := '.' | '$' | '^' | <number> | <search> | <addr>'+'<addr> | <addr>'-'<addr>\n");
1775 	Bprint(&out, "<search> := '/'<regexp>'/' | '?'<regexp>'?' | '%%'<regexp>'%%'\n");
1776 	Bprint(&out, "<command> :=\n");
1777 	for(i = 0; cmdtab[i].cmd != nil; i++)
1778 		Bprint(&out, "%s\n", cmdtab[i].help);
1779 	return m;
1780 }
1781 
1782 int
1783 tomailer(char **av)
1784 {
1785 	static char *marshal;
1786 	Waitmsg *w;
1787 	int pid, i;
1788 
1789 	if(marshal == nil)
1790 		marshal = unsharp("#9/bin/upas/marshal");
1791 
1792 	/* start the mailer and get out of the way */
1793 	switch(pid = fork()){
1794 	case -1:
1795 		fprint(2, "can't fork: %r\n");
1796 		return -1;
1797 	case 0:
1798 		Bprint(&out, "!%s", marshal);
1799 		for(i = 1; av[i]; i++){
1800 			if(strchr(av[i], ' ') != nil)
1801 				Bprint(&out, " '%s'", av[i]);
1802 			else
1803 				Bprint(&out, " %s", av[i]);
1804 		}
1805 		Bprint(&out, "\n");
1806 		Bflush(&out);
1807 		av[0] = "marshal";
1808 		chdir(wd);
1809 		exec(marshal, av);
1810 		fprint(2, "couldn't exec %s\n", marshal);
1811 		threadexits(0);
1812 	default:
1813 		w = wait();
1814 		if(w == nil){
1815 			if(interrupted)
1816 				postnote(PNPROC, pid, "die");
1817 			waitpid();
1818 			return -1;
1819 		}
1820 		if(w->msg[0]){
1821 			fprint(2, "mailer failed: %s\n", w->msg);
1822 			free(w);
1823 			return -1;
1824 		}
1825 		free(w);
1826 		Bprint(&out, "!\n");
1827 		break;
1828 	}
1829 	return 0;
1830 }
1831 
1832 /* */
1833 /* like tokenize but obey "" quoting */
1834 /* */
1835 int
1836 tokenize822(char *str, char **args, int max)
1837 {
1838 	int na;
1839 	int intok = 0, inquote = 0;
1840 
1841 	if(max <= 0)
1842 		return 0;	
1843 	for(na=0; ;str++)
1844 		switch(*str) {
1845 		case ' ':
1846 		case '\t':
1847 			if(inquote)
1848 				goto Default;
1849 			/* fall through */
1850 		case '\n':
1851 			*str = 0;
1852 			if(!intok)
1853 				continue;
1854 			intok = 0;
1855 			if(na < max)
1856 				continue;
1857 			/* fall through */
1858 		case 0:
1859 			return na;
1860 		case '"':
1861 			inquote ^= 1;
1862 			/* fall through */
1863 		Default:
1864 		default:
1865 			if(intok)
1866 				continue;
1867 			args[na++] = str;
1868 			intok = 1;
1869 		}
1870 	return 0;	/* can't get here; silence compiler */
1871 }
1872 
1873 Message*
1874 rcmd(Cmd *c, Message *m)
1875 {
1876 	char *av[128];
1877 	int i, ai = 1;
1878 	Message *nm;
1879 	char *addr;
1880 	String *path = nil;
1881 	String *rpath;
1882 	String *subject = nil;
1883 	String *from;
1884 
1885 	if(m == &top){
1886 		Bprint(&out, "!address\n");
1887 		return nil;
1888 	}
1889 
1890 	addr = nil;
1891 	for(nm = m; nm != &top; nm = nm->parent){
1892  		if(*nm->replyto != 0){
1893 			addr = nm->replyto;
1894 			break;
1895 		}
1896 	}
1897 	if(addr == nil){
1898 		Bprint(&out, "!no reply address\n");
1899 		return nil;
1900 	}
1901 
1902 	if(nm == &top){
1903 		print("!noone to reply to\n");
1904 		return nil;
1905 	}
1906 
1907 	for(nm = m; nm != &top; nm = nm->parent){
1908 		if(*nm->subject){
1909 			av[ai++] = "-s";
1910 			subject = addrecolon(nm->subject);
1911 			av[ai++] = s_to_c(subject);;
1912 			break;
1913 		}
1914 	}
1915 
1916 	av[ai++] = "-R";
1917 	rpath = rooted(s_clone(m->path));
1918 	av[ai++] = s_to_c(rpath);
1919 
1920 	if(strchr(c->av[0], 'f') != nil){
1921 		fcmd(c, m);
1922 		av[ai++] = "-F";
1923 	}
1924 
1925 	if(strchr(c->av[0], 'R') != nil){
1926 		av[ai++] = "-t";
1927 		av[ai++] = "message/rfc822";
1928 		av[ai++] = "-A";
1929 		path = rooted(extendpath(m->path, "raw"));
1930 		av[ai++] = s_to_c(path);
1931 	}
1932 
1933 	for(i = 1; i < c->an && ai < nelem(av)-1; i++)
1934 		av[ai++] = c->av[i];
1935 	from = s_copy(addr);
1936 	ai += tokenize822(s_to_c(from), &av[ai], nelem(av) - ai);
1937 	av[ai] = 0;
1938 	if(tomailer(av) < 0)
1939 		m = nil;
1940 	s_free(path);
1941 	s_free(rpath);
1942 	s_free(subject);
1943 	s_free(from);
1944 	return m;
1945 }
1946 
1947 Message*
1948 mcmd(Cmd *c, Message *m)
1949 {
1950 	char **av;
1951 	int i, ai;
1952 	String *path;
1953 
1954 	if(m == &top){
1955 		Bprint(&out, "!address\n");
1956 		return nil;
1957 	}
1958 
1959 	if(c->an < 2){
1960 		fprint(2, "!usage: M list-of addresses\n");
1961 		return nil;
1962 	}
1963 
1964 	ai = 1;
1965 	av = malloc(sizeof(char*)*(c->an + 8));
1966 
1967 	av[ai++] = "-t";
1968 	if(m->parent == &top)
1969 		av[ai++] = "message/rfc822";
1970 	else
1971 		av[ai++] = "mime";
1972 
1973 	av[ai++] = "-A";
1974 	path = rooted(extendpath(m->path, "raw"));
1975 	av[ai++] = s_to_c(path);
1976 
1977 	if(strchr(c->av[0], 'M') == nil)
1978 		av[ai++] = "-n";
1979 
1980 	for(i = 1; i < c->an; i++)
1981 		av[ai++] = c->av[i];
1982 	av[ai] = 0;
1983 
1984 	if(tomailer(av) < 0)
1985 		m = nil;
1986 	if(path != nil)
1987 		s_free(path);
1988 	free(av);
1989 	return m;
1990 }
1991 
1992 Message*
1993 acmd(Cmd *c, Message *m)
1994 {
1995 	char *av[128];
1996 	int i, ai;
1997 	String *from, *to, *cc, *path = nil, *subject = nil;
1998 
1999 	if(m == &top){
2000 		Bprint(&out, "!address\n");
2001 		return nil;
2002 	}
2003 
2004 	ai = 1;
2005 	if(*m->subject){
2006 		av[ai++] = "-s";
2007 		subject = addrecolon(m->subject);
2008 		av[ai++] = s_to_c(subject);
2009 	}
2010 
2011 	if(strchr(c->av[0], 'A') != nil){
2012 		av[ai++] = "-t";
2013 		av[ai++] = "message/rfc822";
2014 		av[ai++] = "-A";
2015 		path = rooted(extendpath(m->path, "raw"));
2016 		av[ai++] = s_to_c(path);
2017 	}
2018 
2019 	for(i = 1; i < c->an && ai < nelem(av)-1; i++)
2020 		av[ai++] = c->av[i];
2021 	from = s_copy(m->from);
2022 	ai += tokenize822(s_to_c(from), &av[ai], nelem(av) - ai);
2023 	to = s_copy(m->to);
2024 	ai += tokenize822(s_to_c(to), &av[ai], nelem(av) - ai);
2025 	cc = s_copy(m->cc);
2026 	ai += tokenize822(s_to_c(cc), &av[ai], nelem(av) - ai);
2027 	av[ai] = 0;
2028 	if(tomailer(av) < 0)
2029 		return nil;
2030 	s_free(from);
2031 	s_free(to);
2032 	s_free(cc);
2033 	s_free(subject);
2034 	s_free(path);
2035 	return m;
2036 }
2037 
2038 String *
2039 relpath(char *path, String *to)
2040 {
2041 	if (*path=='/' || strncmp(path, "./", 2) == 0
2042 			      || strncmp(path, "../", 3) == 0) {
2043 		to = s_append(to, path);
2044 	} else if(mbpath) {
2045 		to = s_append(to, s_to_c(mbpath));
2046 		to->ptr = strrchr(to->base, '/')+1;
2047 		s_append(to, path);
2048 	}
2049 	return to;
2050 }
2051 
2052 int
2053 appendtofile(Message *m, char *part, char *base, int mbox)
2054 {
2055 	String *file, *h;
2056 	int in, out, rv;
2057 
2058 	file = extendpath(m->path, part);
2059 	in = open(s_to_c(file), OREAD);
2060 	if(in < 0){
2061 		fprint(2, "!message disappeared\n");
2062 		return -1;
2063 	}
2064 
2065 	s_reset(file);
2066 
2067 	relpath(base, file);
2068 	if(sysisdir(s_to_c(file))){
2069 		s_append(file, "/");
2070 		if(m->filename && strchr(m->filename, '/') == nil)
2071 			s_append(file, m->filename);
2072 		else {
2073 			s_append(file, "att.XXXXXXXXXXX");
2074 			mktemp(s_to_c(file));
2075 		}
2076 	}
2077 	if(mbox)
2078 		out = open(s_to_c(file), OWRITE);
2079 	else
2080 		out = open(s_to_c(file), OWRITE|OTRUNC);
2081 	if(out < 0){
2082 		out = create(s_to_c(file), OWRITE, 0666);
2083 		if(out < 0){
2084 			fprint(2, "!can't open %s: %r\n", s_to_c(file));
2085 			close(in);
2086 			s_free(file);
2087 			return -1;
2088 		}
2089 	}
2090 	if(mbox)
2091 		seek(out, 0, 2);
2092 
2093 	/* put on a 'From ' line */
2094 	if(mbox){
2095 		while(m->parent != &top)
2096 			m = m->parent;
2097 		h = file2string(m->path, "unixheader");
2098 		fprint(out, "%s", s_to_c(h));
2099 		s_free(h);
2100 	}
2101 
2102 	/* copy the message escaping what we have to ad adding newlines if we have to */
2103 	if(mbox)
2104 		rv = appendfiletombox(in, out);
2105 	else
2106 		rv = appendfiletofile(in, out);
2107 
2108 	close(in);
2109 	close(out);
2110 
2111 	if(rv >= 0)
2112 		print("!saved in %s\n", s_to_c(file));
2113 	s_free(file);
2114 	return rv;
2115 }
2116 
2117 Message*
2118 scmd(Cmd *c, Message *m)
2119 {
2120 	char buf[256];
2121 	CFid *fd;
2122 	char *file, *msg;
2123 
2124 	if(m == &top){
2125 		Bprint(&out, "!address\n");
2126 		return nil;
2127 	}
2128 
2129 	switch(c->an){
2130 	case 1:
2131 		file = "stored";
2132 		break;
2133 	case 2:
2134 		file = c->av[1];
2135 		break;
2136 	default:
2137 		fprint(2, "!usage: s filename\n");
2138 		return nil;
2139 	}
2140 
2141 	if(file[0] == '/' || (file[0]=='.' && file[1]=='/')){
2142 		if(appendtofile(m, "raw", file, 1) < 0)
2143 			return nil;
2144 	}else{
2145 		snprint(buf, sizeof buf, "%s/ctl", mbname);
2146 		if((fd = fsopen(mailfs, buf, OWRITE)) == nil)
2147 			return nil;
2148 		msg = strrchr(s_to_c(m->path), '/');
2149 		if(msg == nil)
2150 			msg = s_to_c(m->path);
2151 		else
2152 			msg++;
2153 		if(fsprint(fd, "save %s %s", file, msg) < 0){
2154 			fsclose(fd);
2155 			return nil;
2156 		}
2157 		fsclose(fd);
2158 	}
2159 	m->stored = 1;
2160 	return m;
2161 }
2162 
2163 Message*
2164 wcmd(Cmd *c, Message *m)
2165 {
2166 	char *file;
2167 
2168 	if(m == &top){
2169 		Bprint(&out, "!address\n");
2170 		return nil;
2171 	}
2172 
2173 	switch(c->an){
2174 	case 2:
2175 		file = c->av[1];
2176 		break;
2177 	case 1:
2178 		if(*m->filename == 0){
2179 			fprint(2, "!usage: w filename\n");
2180 			return nil;
2181 		}
2182 		file = strrchr(m->filename, '/');
2183 		if(file != nil)
2184 			file++;
2185 		else
2186 			file = m->filename;
2187 		break;
2188 	default:
2189 		fprint(2, "!usage: w filename\n");
2190 		return nil;
2191 	}
2192 
2193 	if(appendtofile(m, "body", file, 0) < 0)
2194 		return nil;
2195 	m->stored = 1;
2196 	return m;
2197 }
2198 
2199 char *specialfile[] =
2200 {
2201 	"pipeto",
2202 	"pipefrom",
2203 	"L.mbox",
2204 	"forward",
2205 	"names"
2206 };
2207 
2208 /* return 1 if this is a special file */
2209 static int
2210 special(String *s)
2211 {
2212 	char *p;
2213 	int i;
2214 
2215 	p = strrchr(s_to_c(s), '/');
2216 	if(p == nil)
2217 		p = s_to_c(s);
2218 	else
2219 		p++;
2220 	for(i = 0; i < nelem(specialfile); i++)
2221 		if(strcmp(p, specialfile[i]) == 0)
2222 			return 1;
2223 	return 0;
2224 }
2225 
2226 /* open the folder using the recipients account name */
2227 static String*
2228 foldername(char *rcvr)
2229 {
2230 	char *p;
2231 	int c;
2232 	String *file;
2233 	Dir *d;
2234 	int scarey;
2235 
2236 	file = s_new();
2237 	mboxpath("f", user, file, 0);
2238 	d = dirstat(s_to_c(file));
2239 
2240 	/* if $mail/f exists, store there, otherwise in $mail */
2241 	s_restart(file);
2242 	if(d && d->qid.type == QTDIR){
2243 		scarey = 0;
2244 		s_append(file, "f/");
2245 	} else {
2246 		scarey = 1;
2247 	}
2248 	free(d);
2249 
2250 	p = strrchr(rcvr, '!');
2251 	if(p != nil)
2252 		rcvr = p+1;
2253 
2254 	while(*rcvr && *rcvr != '@'){
2255 		c = *rcvr++;
2256 		if(c == '/')
2257 			c = '_';
2258 		s_putc(file, c);
2259 	}
2260 	s_terminate(file);
2261 
2262 	if(scarey && special(file)){
2263 		fprint(2, "!won't overwrite %s\n", s_to_c(file));
2264 		s_free(file);
2265 		return nil;
2266 	}
2267 
2268 	return file;
2269 }
2270 
2271 Message*
2272 fcmd(Cmd *c, Message *m)
2273 {
2274 	String *folder;
2275 
2276 	if(c->an > 1){
2277 		fprint(2, "!usage: f takes no arguments\n");
2278 		return nil;
2279 	}
2280 
2281 	if(m == &top){
2282 		Bprint(&out, "!address\n");
2283 		return nil;
2284 	}
2285 
2286 	folder = foldername(m->from);
2287 	if(folder == nil)
2288 		return nil;
2289 
2290 	if(appendtofile(m, "raw", s_to_c(folder), 1) < 0){
2291 		s_free(folder);
2292 		return nil;
2293 	}
2294 	s_free(folder);
2295 
2296 	m->stored = 1;
2297 	return m;
2298 }
2299 
2300 void
2301 system(char *cmd, char **av, int in)
2302 {
2303 	int pid;
2304 
2305 	switch(pid=fork()){
2306 	case -1:
2307 		return;
2308 	case 0:
2309 		if(strcmp(cmd, "rc") == 0)
2310 			cmd = unsharp("#9/bin/rc");
2311 		if(in >= 0){
2312 			close(0);
2313 			dup(in, 0);
2314 			close(in);
2315 		}
2316 		if(wd[0] != 0)
2317 			chdir(wd);
2318 		exec(cmd, av);
2319 		fprint(2, "!couldn't exec %s\n", cmd);
2320 		threadexits(0);
2321 	default:
2322 		if(in >= 0)
2323 			close(in);
2324 		while(waitpid() < 0){
2325 			if(!interrupted)
2326 				break;
2327 			postnote(PNPROC, pid, "die");
2328 			continue;
2329 		}
2330 		break;
2331 	}
2332 }
2333 
2334 Message*
2335 bangcmd(Cmd *c, Message *m)
2336 {
2337 	char cmd[4*1024];
2338 	char *p, *e;
2339 	char *av[4];
2340 	int i;
2341 
2342 	cmd[0] = 0;
2343 	p = cmd;
2344 	e = cmd+sizeof(cmd);
2345 	for(i = 1; i < c->an; i++)
2346 		p = seprint(p, e, "%s ", c->av[i]);
2347 	av[0] = "rc";
2348 	av[1] = "-c";
2349 	av[2] = cmd;
2350 	av[3] = 0;
2351 	system("rc", av, -1);
2352 	Bprint(&out, "!\n");
2353 	return m;
2354 }
2355 
2356 Message*
2357 xpipecmd(Cmd *c, Message *m, char *part)
2358 {
2359 	char cmd[128];
2360 	char *p, *e;
2361 	char *av[4];
2362 	String *path;
2363 	int i, fd;
2364 
2365 	if(c->an < 2){
2366 		Bprint(&out, "!usage: | cmd\n");
2367 		return nil;
2368 	}
2369 
2370 	if(m == &top){
2371 		Bprint(&out, "!address\n");
2372 		return nil;
2373 	}
2374 
2375 	path = extendpath(m->path, part);
2376 	fd = fsopenfd(mailfs, s_to_c(path), OREAD);
2377 	s_free(path);
2378 
2379 	if(fd < 0){	/* compatibility with older upas/fs */
2380 		path = extendpath(m->path, "raw");
2381 		fd = fsopenfd(mailfs, s_to_c(path), OREAD);
2382 		s_free(path);
2383 	}
2384 	if(fd < 0){
2385 		fprint(2, "!message disappeared\n");
2386 		return nil;
2387 	}
2388 
2389 	p = cmd;
2390 	e = cmd+sizeof(cmd);
2391 	cmd[0] = 0;
2392 	for(i = 1; i < c->an; i++)
2393 		p = seprint(p, e, "%s ", c->av[i]);
2394 	av[0] = "rc";
2395 	av[1] = "-c";
2396 	av[2] = cmd;
2397 	av[3] = 0;
2398 	system("rc", av, fd);	/* system closes fd */
2399 	Bprint(&out, "!\n");
2400 	return m;
2401 }
2402 
2403 Message*
2404 pipecmd(Cmd *c, Message *m)
2405 {
2406 	return xpipecmd(c, m, "body");
2407 }
2408 
2409 Message*
2410 rpipecmd(Cmd *c, Message *m)
2411 {
2412 	return xpipecmd(c, m, "rawunix");
2413 }
2414 
2415 void
2416 closemb(void)
2417 {
2418 	CFid *fd;
2419 
2420 	fd = fsopen(mailfs, "ctl", OWRITE);
2421 	if(fd == nil)
2422 		sysfatal("can't open ctl: %r");
2423 
2424 	/* close current mailbox */
2425 	if(*mbname && strcmp(mbname, "mbox") != 0)
2426 		fsprint(fd, "close %s", mbname);
2427 
2428 	fsclose(fd);
2429 }
2430 
2431 int
2432 switchmb(char *file, char *singleton)
2433 {
2434 	char *p;
2435 	int n, fd;
2436 	String *path;
2437 	char buf[256];
2438 
2439 	/* if the user didn't say anything and there */
2440 	/* is an mbox mounted already, use that one */
2441 	/* so that the upas/fs -fdefault default is honored. */
2442 	if(0 && (file || (singleton && fsaccess(mailfs, singleton, 0) < 0))){
2443 	/* XXX all wrong */
2444 		fprint(2, "file=%s singleton=%s\n", file, singleton);
2445 		if(file == nil)
2446 			file = "mbox";
2447 
2448 		/* close current mailbox */
2449 		closemb();
2450 		didopen = 1;
2451 
2452 		fd = open("/mail/fs/ctl", ORDWR);
2453 		if(fd < 0)
2454 			sysfatal("can't open /mail/fs/ctl: %r");
2455 	
2456 		path = s_new();
2457 	
2458 		/* get an absolute path to the mail box */
2459 		if(strncmp(file, "./", 2) == 0){
2460 			/* resolve path here since upas/fs doesn't know */
2461 			/* our working directory */
2462 			if(getwd(buf, sizeof(buf)-strlen(file)) == nil){
2463 				fprint(2, "!can't get working directory: %s\n", buf);
2464 				return -1;
2465 			}
2466 			s_append(path, buf);
2467 			s_append(path, file+1);
2468 		} else {
2469 			mboxpath(file, user, path, 0);
2470 		}
2471 	
2472 		/* make up a handle to use when talking to fs */
2473 		p = strrchr(file, '/');
2474 		if(p == nil){
2475 			/* if its in the mailbox directory, just use the name */
2476 			strncpy(mbname, file, sizeof(mbname));
2477 			mbname[sizeof(mbname)-1] = 0;
2478 		} else {
2479 			/* make up a mailbox name */
2480 			p = strrchr(s_to_c(path), '/');
2481 			p++;
2482 			if(*p == 0){
2483 				fprint(2, "!bad mbox name");
2484 				return -1;
2485 			}
2486 			strncpy(mbname, p, sizeof(mbname));
2487 			mbname[sizeof(mbname)-1] = 0;
2488 			n = strlen(mbname);
2489 			if(n > Elemlen-12)
2490 				n = Elemlen-12;
2491 			sprint(mbname+n, "%ld", time(0));
2492 		}
2493 
2494 		if(fprint(fd, "open %s %s", s_to_c(path), mbname) < 0){
2495 			fprint(2, "!can't 'open %s %s': %r\n", file, mbname);
2496 			s_free(path);
2497 			return -1;
2498 		}
2499 		close(fd);
2500 	}else
2501 	if (singleton && fsaccess(mailfs, singleton, 0)==0){
2502 		if ((p = strchr(singleton, '/')) == nil){
2503 			fprint(2, "!bad mbox name");
2504 			return -1;
2505 		}
2506 		n = p-singleton;
2507 		strncpy(mbname, singleton, n);
2508 		mbname[n+1] = 0;
2509 		path = s_reset(nil);
2510 		mboxpath(mbname, user, path, 0);
2511 	}else{
2512 		if(file)
2513 			strecpy(mbname, mbname+sizeof mbname, file);
2514 		else
2515 			strcpy(mbname, "mbox");
2516 		path = s_reset(nil);
2517 		mboxpath(mbname, user, path, 0);
2518 	}
2519 
2520 	snprint(root, sizeof root, "%s", mbname);
2521 	rootlen = strlen(root);
2522 
2523 	if(mbpath != nil)
2524 		s_free(mbpath);
2525 	mbpath = path;
2526 	return 0;
2527 }
2528 
2529 /* like tokenize but for into lines */
2530 int
2531 lineize(char *s, char **f, int n)
2532 {
2533 	int i;
2534 
2535 	for(i = 0; *s && i < n; i++){
2536 		f[i] = s;
2537 		s = strchr(s, '\n');
2538 		if(s == nil)
2539 			break;
2540 		*s++ = 0;
2541 	}
2542 	return i;
2543 }
2544 
2545 
2546 
2547 String*
2548 rooted(String *s)
2549 {
2550 	static char buf[256];
2551 
2552 	if(strcmp(root, ".") != 0)
2553 		return s;
2554 	snprint(buf, sizeof(buf), "/mail/fs/%s/%s", mbname, s_to_c(s));
2555 	s_free(s);
2556 	return s_copy(buf);
2557 }
2558 
2559 int
2560 plumb(Message *m, Ctype *cp)
2561 {
2562 	String *s;
2563 	Plumbmsg *pm;
2564 	static int fd = -2;
2565 
2566 	if(cp->plumbdest == nil)
2567 		return -1;
2568 
2569 	if(fd < -1)
2570 		fd = plumbopen("send", OWRITE);
2571 	if(fd < 0)
2572 		return -1;
2573 
2574 	pm = mallocz(sizeof(Plumbmsg), 1);
2575 	pm->src = strdup("mail");
2576 	if(*cp->plumbdest)
2577 		pm->dst = strdup(cp->plumbdest);
2578 	pm->wdir = nil;
2579 	pm->type = strdup("text");
2580 	pm->ndata = -1;
2581 	s = rooted(extendpath(m->path, "body"));
2582 	if(cp->ext != nil){
2583 		s_append(s, ".");
2584 		s_append(s, cp->ext);
2585 	}
2586 	pm->data = strdup(s_to_c(s));
2587 	s_free(s);
2588 	plumbsend(fd, pm);
2589 	plumbfree(pm);
2590 	return 0;
2591 }
2592 
2593 void
2594 regerror(char *x)
2595 {
2596 	USED(x);
2597 }
2598 
2599 String*
2600 addrecolon(char *s)
2601 {
2602 	String *str;
2603 
2604 	if(cistrncmp(s, "re:", 3) != 0){
2605 		str = s_copy("Re: ");
2606 		s_append(str, s);
2607 	} else
2608 		str = s_copy(s);
2609 	return str;
2610 }
2611 
2612 void
2613 exitfs(char *rv)
2614 {
2615 	threadexitsall(rv);
2616 }