1 #include <u.h>
2 #include <libc.h>
3 #include <bio.h>
4 #include <thread.h>
5 #include <ctype.h>
6 #include <plumb.h>
7 #include <9pclient.h> /* jpc */
8 #include "dat.h"
9 
10 extern CFsys *upasfs; /* jpc */
11 
12 enum
13 {
14 	DIRCHUNK = 32*sizeof(Dir)
15 };
16 
17 char	regexchars[] = "\\/[].+?()*^$";
18 char	deleted[] = "(deleted)-";
19 char	deletedrx[] = "\\(deleted\\)-";
20 char	deletedrx01[] = "(\\(deleted\\)-)?";
21 char	deletedaddr[] = "-#0;/^\\(deleted\\)-/";
22 
23 struct{
24 	char	*type;
25 	char	*port;
26 	char *suffix;
27 } ports[] = {
28 	"text/",			"edit",	".txt", /* must be first for plumbport() */
29 	"image/gif",		"image",	".gif",
30 	"image/jpeg",		"image",	".jpg",
31 	"image/jpeg",		"image",	".jpeg",
32 	"image/png",		"image",	".png",
33 	"application/postscript",	"postscript",	".ps",
34 	"application/pdf",	"postscript",	".pdf",
35 	"application/msword",	"msword",	".doc",
36 	"application/rtf",	"msword",	".rtf",
37 	nil,	nil
38 };
39 
40 char *goodtypes[] = {
41 	"text",
42 	"text/plain",
43 	"message/rfc822",
44 	"text/richtext",
45 	"text/tab-separated-values",
46 	"application/octet-stream",
47 	nil,
48 };
49 
50 struct{
51 	char *type;
52 	char	*ext;
53 } exts[] = {
54 	"image/gif",	".gif",
55 	"image/jpeg",	".jpg",
56 	nil, nil
57 };
58 
59 char *okheaders[] =
60 {
61 	"From:",
62 	"Date:",
63 	"To:",
64 	"CC:",
65 	"Subject:",
66 	nil
67 };
68 
69 char *extraheaders[] =
70 {
71 	"Resent-From:",
72 	"Resent-To:",
73 	"Sort:",
74 	nil,
75 };
76 
77 char*
78 line(char *data, char **pp)
79 {
80 	char *p, *q;
81 
82 	for(p=data; *p!='\0' && *p!='\n'; p++)
83 		;
84 	if(*p == '\n')
85 		*pp = p+1;
86 	else
87 		*pp = p;
88 	q = emalloc(p-data + 1);
89 	memmove(q, data, p-data);
90 	return q;
91 }
92 
93 void
94 scanheaders(Message *m, char *dir)
95 {
96 	char *s, *t, *u, *f;
97 
98 	s = f = readfile(dir, "header", nil);
99 	if(s != nil)
100 		while(*s){
101 			t = line(s, &s);
102 			if(strncmp(t, "From: ", 6) == 0){
103 				m->fromcolon = estrdup(t+6);
104 				/* remove all quotes; they're ugly and irregular */
105 				for(u=m->fromcolon; *u; u++)
106 					if(*u == '"')
107 						memmove(u, u+1, strlen(u));
108 			}
109 			if(strncmp(t, "Subject: ", 9) == 0)
110 				m->subject = estrdup(t+9);
111 			free(t);
112 		}
113 	if(m->fromcolon == nil)
114 		m->fromcolon = estrdup(m->from);
115 	free(f);
116 }
117 
118 int
119 loadinfo(Message *m, char *dir)
120 {
121 	int n;
122 	char *data, *p, *s;
123 
124 	data = readfile(dir, "info", &n);
125 	if(data == nil)
126 		return 0;
127 	m->from = line(data, &p);
128 	scanheaders(m, dir);	/* depends on m->from being set */
129 	m->to = line(p, &p);
130 	m->cc = line(p, &p);
131 	m->replyto = line(p, &p);
132 	m->date = line(p, &p);
133 	s = line(p, &p);
134 	if(m->subject == nil)
135 		m->subject = s;
136 	else
137 		free(s);
138 	m->type = line(p, &p);
139 	m->disposition = line(p, &p);
140 	m->filename = line(p, &p);
141 	m->digest = line(p, &p);
142 	free(data);
143 	return 1;
144 }
145 
146 int
147 isnumeric(char *s)
148 {
149 	while(*s){
150 		if(!isdigit(*s))
151 			return 0;
152 		s++;
153 	}
154 	return 1;
155 }
156 
157 Dir*
158 loaddir(char *name, int *np)
159 {
160 	CFid *fid;
161 	Dir *dp;
162 	char *tmp;
163 
164 	if (strncmp(name,"/mail/fs/",strlen("/mail/fs/"))==0) {
165 		tmp = name+strlen("/mail/fs/");
166 	}
167 	fid = fsopen(upasfs,tmp,OREAD);
168 	if(fid == nil)
169 		return nil;
170 	*np = fsdirreadall(fid, &dp);
171 	fsclose(fid);
172 
173 	return dp;
174 }
175 
176 void
177 readmbox(Message *mbox, char *dir, char *subdir)
178 {
179 	char *name;
180 	Dir *d, *dirp;
181 	int i, n;
182 
183 	name = estrstrdup(dir, subdir);
184 	dirp = loaddir(name, &n);
185 	mbox->recursed = 1;
186 	if(dirp)
187 		for(i=0; i<n; i++){
188 			d = &dirp[i];
189 			if(isnumeric(d->name))
190 				mesgadd(mbox, name, d, nil);
191 		}
192 	free(dirp);
193 	free(name);
194 }
195 
196 /* add message to box, in increasing numerical order */
197 int
198 mesgadd(Message *mbox, char *dir, Dir *d, char *digest)
199 {
200 	Message *m;
201 	char *name;
202 	int loaded;
203 
204 	m = emalloc(sizeof(Message));
205 	m->name = estrstrdup(d->name, "/");
206 	m->next = nil;
207 	m->prev = mbox->tail;
208 	m->level= mbox->level+1;
209 	m->recursed = 0;
210 	name = estrstrdup(dir, m->name);
211 	loaded = loadinfo(m, name);
212 	free(name);
213 	/* if two upas/fs are running, we can get misled, so check digest before accepting message */
214 	if(loaded==0 || (digest!=nil && m->digest!=nil && strcmp(digest, m->digest)!=0)){
215 		mesgfreeparts(m);
216 		free(m);
217 		return 0;
218 	}
219 	if(mbox->tail != nil)
220 		mbox->tail->next = m;
221 	mbox->tail = m;
222 	if(mbox->head == nil)
223 		mbox->head = m;
224 
225 	if (m->level != 1){
226 		m->recursed = 1;
227 		readmbox(m, dir, m->name); 
228 	}
229 	return 1;
230 }
231 
232 int
233 thisyear(char *year)
234 {
235 	static char now[10];
236 	char *s;
237 
238 	if(now[0] == '\0'){
239 		s = ctime(time(nil));
240 		strcpy(now, s+24);
241 	}
242 	return strncmp(year, now, 4) == 0;
243 }
244 
245 char*
246 stripdate(char *as)
247 {
248 	int n;
249 	char *s, *fld[10];
250 
251 	as = estrdup(as);
252 	s = estrdup(as);
253 	n = tokenize(s, fld, 10);
254 	if(n > 5){
255 		sprint(as, "%.3s ", fld[0]);	/* day */
256 		/* some dates have 19 Apr, some Apr 19 */
257 		if(strlen(fld[1])<4 && isnumeric(fld[1]))
258 			sprint(as+strlen(as), "%.3s %.3s ", fld[1], fld[2]);	/* date, month */
259 		else
260 			sprint(as+strlen(as), "%.3s %.3s ", fld[2], fld[1]);	/* date, month */
261 		/* do we use time or year?  depends on whether year matches this one */
262 		if(thisyear(fld[5])){
263 			if(strchr(fld[3], ':') != nil)
264 				sprint(as+strlen(as), "%.5s ", fld[3]);	/* time */
265 			else if(strchr(fld[4], ':') != nil)
266 				sprint(as+strlen(as), "%.5s ", fld[4]);	/* time */
267 		}else
268 			sprint(as+strlen(as), "%.4s ", fld[5]);	/* year */
269 	}
270 	free(s);
271 	return as;
272 }
273 
274 char*
275 readfile(char *dir, char *name, int *np)
276 {
277 	char *file, *data;
278 /*	int fd, len;	jpc */
279 	int len;
280 	Dir *d;
281 	CFid *fid;
282 	char *tmp;
283 
284 	if(np != nil)
285 		*np = 0;
286 	file = estrstrdup(dir, name);
287 /*	fd = open(file, OREAD);
288 	if(fd < 0)
289 		return nil;
290 	d = dirfstat(fd); jpc */
291 	if (strncmp(file,"/mail/fs/",strlen("/mail/fs/"))==0) {
292 		tmp = file+strlen("/mail/fs/");
293 	}
294 	fid = fsopen(upasfs,tmp, OREAD);
295 	if(fid == nil)
296 		return nil;
297 	d = fsdirfstat(fid);
298 /* jpc end */
299 	free(file);
300 	len = 0;
301 	if(d != nil)
302 		len = d->length;
303 	free(d);
304 	data = emalloc(len+1);
305 /*	read(fd, data, len);
306 	close(fd);	jpc */
307 	fsread(fid, data, len);
308 	fsclose(fid);
309 /*	jpc */
310 	if(np != nil)
311 		*np = len;
312 	return data;
313 }
314 
315 char*
316 info(Message *m, int ind, int ogf)
317 {
318 	char *i;
319 	int j, len, lens;
320 	char *p;
321 	char fmt[80], s[80];
322 
323 	if (ogf)
324 		p=m->to;
325 	else
326 		p=m->fromcolon;
327 
328 	if(ind==0 && shortmenu){
329 		len = 30;
330 		lens = 30;
331 		if(shortmenu > 1){
332 			len = 10;
333 			lens = 25;
334 		}
335 		if(ind==0 && m->subject[0]=='\0'){
336 			snprint(fmt, sizeof fmt, " %%-%d.%ds", len, len);
337 			snprint(s, sizeof s, fmt, p);
338 		}else{
339 			snprint(fmt, sizeof fmt, " %%-%d.%ds  %%-%d.%ds", len, len, lens, lens);
340 			snprint(s, sizeof s, fmt, p, m->subject);
341 		}
342 		i = estrdup(s);
343 
344 		return i;
345 	} 
346 
347 	i = estrdup("");
348 	i = eappend(i, "\t", p);
349 	i = egrow(i, "\t", stripdate(m->date));
350 	if(ind == 0){
351 		if(strcmp(m->type, "text")!=0 && strncmp(m->type, "text/", 5)!=0 && 
352 		   strncmp(m->type, "multipart/", 10)!=0)
353 			i = egrow(i, "\t(", estrstrdup(m->type, ")"));
354 	}else if(strncmp(m->type, "multipart/", 10) != 0)
355 		i = egrow(i, "\t(", estrstrdup(m->type, ")"));
356 	if(m->subject[0] != '\0'){
357 		i = eappend(i, "\n", nil);
358 		for(j=0; j<ind; j++)
359 			i = eappend(i, "\t", nil);
360 		i = eappend(i, "\t", m->subject);
361 	}
362 	return i;
363 }
364 
365 #if 0 /* jpc */
366 void
367 mesgmenu0(Window *w, Message *mbox, char *realdir, char *dir, int ind, Biobuf *fd, int onlyone, int dotail)
368 {
369 	int i;
370 	Message *m;
371 	char *name, *tmp;
372 	int ogf=0;
373 
374 	if(strstr(realdir, "outgoing") != nil)
375 		ogf=1;
376 
377 	/* show mail box in reverse order, pieces in forward order */
378 	if(ind > 0)
379 		m = mbox->head;
380 	else
381 		m = mbox->tail;
382 	while(m != nil){
383 		for(i=0; i<ind; i++)
384 			Bprint(fd, "\t");
385 		if(ind != 0)
386 			Bprint(fd, "  ");
387 		name = estrstrdup(dir, m->name);
388 		tmp = info(m, ind, ogf);
389 		Bprint(fd, "%s%s\n", name, tmp);
390 		free(tmp);
391 		if(dotail && m->tail)
392 			mesgmenu0(w, m, realdir, name, ind+1, fd, 0, dotail);
393 		free(name);
394 		if(ind)
395 			m = m->next;
396 		else
397 			m = m->prev;
398 		if(onlyone)
399 			m = nil;
400 	}
401 }
402 #endif
403 
404 void
405 mesgmenu0(Window *w, Message *mbox, char *realdir, char *dir, int ind, CFid *fd, int onlyone, int dotail)
406 {
407 	int i;
408 	Message *m;
409 	char *name, *tmp;
410 	//1 char ntmp[250];
411 	int ogf=0;
412 
413 	if(strstr(realdir, "outgoing") != nil)
414 		ogf=1;
415 
416 	/* show mail box in reverse order, pieces in forward order */
417 	if(ind > 0)
418 		m = mbox->head;
419 	else
420 		m = mbox->tail;
421 	while(m != nil){
422 		for(i=0; i<ind; i++)
423 			fswrite(fd, "\t", strlen("\t"));
424 			/* Bprint(fd, "\t"); jpc */
425 		if(ind != 0)
426 			fswrite(fd, "  ", strlen("  "));
427 			/* Bprint(fd, "  "); jpc */
428 		name = estrstrdup(dir, m->name);
429 		tmp = info(m, ind, ogf);
430 		/* Bprint(fd, "%s%s\n", name, tmp); jpc */
431 		// snprint(ntmp,250, "%s%s\n", name, tmp);
432 		// fswrite(fd, ntmp, strlen(ntmp));
433 		fsprint(fd, "%s%s\n", name, tmp);
434 		free(tmp);
435 		if(dotail && m->tail)
436 			mesgmenu0(w, m, realdir, name, ind+1, fd, 0, dotail);
437 		free(name);
438 		if(ind)
439 			m = m->next;
440 		else
441 			m = m->prev;
442 		if(onlyone)
443 			m = nil;
444 	}
445 }
446 
447 void
448 mesgmenu(Window *w, Message *mbox)
449 {
450 	winopenbody(w, OWRITE);
451 	mesgmenu0(w, mbox, mbox->name, "", 0, w->body, 0, !shortmenu);
452 	winclosebody(w);
453 }
454 
455 /* one new message has arrived, as mbox->tail */
456 void
457 mesgmenunew(Window *w, Message *mbox)
458 {
459 	Biobuf *b;
460 
461 	winselect(w, "0", 0);
462 	w->data = winopenfid(w, "data");
463 	b = emalloc(sizeof(Biobuf));
464 /*	Binit(b, w->data, OWRITE);
465 	mesgmenu0(w, mbox, mbox->name, "", 0, b, 1, !shortmenu);
466 	Bterm(b);
467 jpc */
468 	mesgmenu0(w, mbox, mbox->name, "", 0, w->data, 1, !shortmenu);
469 	free(b);
470 	if(!mbox->dirty)
471 		winclean(w);
472 	/* select tag line plus following indented lines, but not final newline (it's distinctive) */
473 	winselect(w, "0/.*\\n((\t.*\\n)*\t.*)?/", 1);
474 	fsclose(w->addr);
475 	fsclose(w->data);
476 	w->addr = nil;
477 	w->data = nil;
478 }
479 
480 char*
481 name2regexp(char *prefix, char *s)
482 {
483 	char *buf, *p, *q;
484 
485 	buf = emalloc(strlen(prefix)+2*strlen(s)+50);	/* leave room to append more */
486 	p = buf;
487 	*p++ = '0';
488 	*p++ = '/';
489 	*p++ = '^';
490 	strcpy(p, prefix);
491 	p += strlen(prefix);
492 	for(q=s; *q!='\0'; q++){
493 		if(strchr(regexchars, *q) != nil)
494 			*p++ = '\\';
495 		*p++ = *q;
496 	}
497 	*p++ = '/';
498 	*p = '\0';
499 	return buf;
500 }
501 
502 void
503 mesgmenumarkdel(Window *w, Message *mbox, Message *m, int writeback)
504 {
505 	char *buf;
506 
507 
508 	if(m->deleted)
509 		return;
510 	m->writebackdel = writeback;
511 	if(w->data == nil)
512 		w->data = winopenfid(w, "data");
513 	buf = name2regexp("", m->name);
514 	strcat(buf, "-#0");
515 	if(winselect(w, buf, 1)) {
516 		fswrite(w->data, deleted, 10);
517 	}
518 	free(buf);
519 	fsclose(w->data);
520 	fsclose(w->addr);
521 	w->addr = nil;
522 	w->data = nil;
523 	mbox->dirty = 1;
524 	m->deleted = 1;
525 }
526 
527 void
528 mesgmenumarkundel(Window *w, Message* v, Message *m)
529 {
530 	char *buf;
531 
532 	if(m->deleted == 0)
533 		return;
534 	if(w->data == nil)
535 		w->data = winopenfid(w, "data");
536 	buf = name2regexp(deletedrx, m->name);
537 	if(winselect(w, buf, 1)) {
538 		if(winsetaddr(w, deletedaddr, 1)) {
539 			fswrite(w->data, "", 0);
540 			// fsync(w->data);
541 		}
542 	}
543 	free(buf);
544 	fsclose(w->data);
545 	fsclose(w->addr);
546 	w->addr = nil;
547 	w->data = nil;
548 	m->deleted = 0;
549 }
550 
551 void
552 mesgmenudel(Window *w, Message *mbox, Message *m)
553 {
554 	char *buf;
555 
556 	if(w->data ==nil)
557 		w->data = winopenfid(w, "data");
558 	buf = name2regexp(deletedrx, m->name);
559 	if(winsetaddr(w, buf, 1) && winsetaddr(w, ".,./.*\\n(\t.*\\n)*/", 1)) {
560 		fswrite(w->data, "", 0);
561 		// fsync(w->data);
562 	}
563 	free(buf);
564 	fsclose(w->data);
565 	fsclose(w->addr);
566 	w->addr = nil;
567 	w->data = nil;
568 	mbox->dirty = 1;
569 	m->deleted = 1;
570 }
571 
572 void
573 mesgmenumark(Window *w, char *which, char *mark)
574 {
575 	char *buf;
576 
577 	if(w->data == nil)
578 		w->data = winopenfid(w, "data");
579 	buf = name2regexp(deletedrx01, which);
580 	if(winsetaddr(w, buf, 1) && winsetaddr(w, "+0-#1", 1)) {	/* go to end of line */
581 		fswrite(w->data, mark, strlen(mark));
582 		// fsync(w->data);
583 	}
584 	free(buf);
585 	fsclose(w->data);
586 	fsclose(w->addr);
587 	w->addr = nil;
588 	w->data = nil;
589 	if(!mbox.dirty)
590 		winclean(w);
591 }
592 
593 void
594 mesgfreeparts(Message *m)
595 {
596 	free(m->name);
597 	free(m->replyname);
598 	free(m->fromcolon);
599 	free(m->from);
600 	free(m->to);
601 	free(m->cc);
602 	free(m->replyto);
603 	free(m->date);
604 	free(m->subject);
605 	free(m->type);
606 	free(m->disposition);
607 	free(m->filename);
608 	free(m->digest);
609 }
610 
611 void
612 mesgdel(Message *mbox, Message *m)
613 {
614 	Message *n, *next;
615 
616 	if(m->opened)
617 		error("internal error: deleted message still open in mesgdel\n");
618 	/* delete subparts */
619 	for(n=m->head; n!=nil; n=next){
620 		next = n->next;
621 		mesgdel(m, n);
622 	}
623 	/* remove this message from list */
624 	if(m->next)
625 		m->next->prev = m->prev;
626 	else
627 		mbox->tail = m->prev;
628 	if(m->prev)
629 		m->prev->next = m->next;
630 	else
631 		mbox->head = m->next;
632 
633 	mesgfreeparts(m);
634 }
635 
636 int
637 mesgsave(Message *m, char *s)
638 {
639 	int ofd, n, k, ret;
640 	char *t, *raw, *unixheader, *all;
641 
642 	t = estrstrdup(mbox.name, m->name);
643 	raw = readfile(t, "raw", &n);
644 	unixheader = readfile(t, "unixheader", &k);
645 	if(raw==nil || unixheader==nil){
646 		fprint(2, "Mail: can't read %s: %r\n", t);
647 		free(t);
648 		return 0;
649 	}
650 	free(t);
651 
652 	all = emalloc(n+k+1);
653 	memmove(all, unixheader, k);
654 	memmove(all+k, raw, n);
655 	memmove(all+k+n, "\n", 1);
656 	n = k+n+1;
657 	free(unixheader);
658 	free(raw);
659 	ret = 1;
660 	s = estrdup(s);
661 	if(s[0] != '/')
662 		s = egrow(estrdup(mailboxdir), "/", s);
663 	ofd = open(s, OWRITE);
664 	if(ofd < 0){
665 		fprint(2, "Mail: can't open %s: %r\n", s);
666 		ret = 0;
667 	}else if(seek(ofd, 0LL, 2)<0 || write(ofd, all, n)!=n){
668 		fprint(2, "Mail: save failed: can't write %s: %r\n", s);
669 		ret = 0;
670 	}
671 	free(all);
672 	close(ofd);
673 	free(s);
674 	return ret;
675 }
676 
677 int
678 mesgcommand(Message *m, char *cmd)
679 {
680 	char *s;
681 	char *args[10];
682 	int ok, ret, nargs;
683 
684 	s = cmd;
685 	ret = 1;
686 	nargs = tokenize(s, args, nelem(args));
687 	if(nargs == 0)
688 		return 0;
689 	if(strcmp(args[0], "Post") == 0){
690 		mesgsend(m);
691 		goto Return;
692 	}
693 	if(strncmp(args[0], "Save", 4) == 0){
694 		if(m->isreply)
695 			goto Return;
696 		s = estrdup("\t[saved");
697 		if(nargs==1 || strcmp(args[1], "")==0){
698 			ok = mesgsave(m, "stored");
699 		}else{
700 			ok = mesgsave(m, args[1]);
701 			s = eappend(s, " ", args[1]);
702 		}
703 		if(ok){
704 			s = egrow(s, "]", nil);
705 			mesgmenumark(mbox.w, m->name, s);
706 		}
707 		free(s);
708 		goto Return;
709 	}
710 	if(strcmp(args[0], "Reply")==0){
711 		if(nargs>=2 && strcmp(args[1], "all")==0)
712 			mkreply(m, "Replyall", nil, nil, nil);
713 		else
714 			mkreply(m, "Reply", nil, nil, nil);
715 		goto Return;
716 	}
717 	if(strcmp(args[0], "Q") == 0){
718 		s = winselection(m->w);	/* will be freed by mkreply */
719 		if(nargs>=3 && strcmp(args[1], "Reply")==0 && strcmp(args[2], "all")==0)
720 			mkreply(m, "QReplyall", nil, nil, s);
721 		else
722 			mkreply(m, "QReply", nil, nil, s);
723 		goto Return;
724 	}
725 	if(strcmp(args[0], "Del") == 0){
726 		if(windel(m->w, 0)){
727 			chanfree(m->w->cevent);
728 			free(m->w);
729 			m->w = nil;
730 			if(m->isreply)
731 				delreply(m);
732 			else{
733 				m->opened = 0;
734 				m->tagposted = 0;
735 			}
736 			free(cmd);
737 			threadexits(nil);
738 		}
739 		goto Return;
740 	}
741 	if(strcmp(args[0], "Delmesg") == 0){
742 		if(!m->isreply){
743 			mesgmenumarkdel(wbox, &mbox, m, 1);
744 			free(cmd);	/* mesgcommand might not return */
745 			mesgcommand(m, estrdup("Del"));
746 			return 1;
747 		}
748 		goto Return;
749 	}
750 	if(strcmp(args[0], "UnDelmesg") == 0){
751 		if(!m->isreply && m->deleted)
752 			mesgmenumarkundel(wbox, &mbox, m);
753 		goto Return;
754 	}
755 //	if(strcmp(args[0], "Headers") == 0){
756 //		m->showheaders();
757 //		return True;
758 //	}
759 
760 	ret = 0;
761 
762     Return:
763 	free(cmd);
764 	return ret;
765 }
766 
767 void
768 mesgtagpost(Message *m)
769 {
770 	if(m->tagposted)
771 		return;
772 	wintagwrite(m->w, " Post", 5);
773 	m->tagposted = 1;
774 }
775 
776 /* need to expand selection more than default word */
777 #pragma varargck argpos eval 2
778 
779 long
780 eval(Window *w, char *s, ...)
781 {
782 	char buf[64];
783 	va_list arg;
784 
785 	va_start(arg, s);
786 	vsnprint(buf, sizeof buf, s, arg);
787 	va_end(arg);
788 
789 	if(winsetaddr(w, buf, 1)==0)
790 		return -1;
791 
792 //	if(pread(w->addr, buf, 24, 0) != 24)
793 	if(fspread(w->addr, buf, 24, 0) != 24)
794 		return -1;
795 	return strtol(buf, 0, 10);
796 }
797 
798 int
799 isemail(char *s)
800 {
801 	int nat;
802 
803 	nat = 0;
804 	for(; *s; s++)
805 		if(*s == '@')
806 			nat++;
807 		else if(!isalpha(*s) && !isdigit(*s) && !strchr("_.-+/", *s))
808 			return 0;
809 	return nat==1;
810 }
811 
812 char addrdelim[] =  "/[ \t\\n<>()\\[\\]]/";
813 char*
814 expandaddr(Window *w, Event *e)
815 {
816 	char *s;
817 	long q0, q1;
818 
819 	if(e->q0 != e->q1)	/* cannot happen */
820 		return nil;
821 
822 	q0 = eval(w, "#%d-%s", e->q0, addrdelim);
823 	if(q0 == -1)	/* bad char not found */
824 		q0 = 0;
825 	else			/* increment past bad char */
826 		q0++;
827 
828 	q1 = eval(w, "#%d+%s", e->q0, addrdelim);
829 	if(q1 < 0){
830 		q1 = eval(w, "$");
831 		if(q1 < 0)
832 			return nil;
833 	}
834 	if(q0 >= q1)
835 		return nil;
836 	s = emalloc((q1-q0)*UTFmax+1);
837 	winread(w, q0, q1, s);
838 	return s;
839 }
840 
841 int
842 replytoaddr(Window *w, Message *m, Event *e, char *s)
843 {
844 	int did;
845 	char *buf;
846 	Plumbmsg *pm;
847 
848 	buf = nil;
849 	did = 0;
850 	if(e->flag & 2){
851 		/* autoexpanded; use our own bigger expansion */
852 		buf = expandaddr(w, e);
853 		if(buf == nil)
854 			return 0;
855 		s = buf;
856 	}
857 	if(isemail(s)){
858 		did = 1;
859 		pm = emalloc(sizeof(Plumbmsg));
860 		pm->src = estrdup("Mail");
861 		pm->dst = estrdup("sendmail");
862 		pm->data = estrdup(s);
863 		pm->ndata = -1;
864 		if(m->subject && m->subject[0]){
865 			pm->attr = emalloc(sizeof(Plumbattr));
866 			pm->attr->name = estrdup("Subject");
867 			if(tolower(m->subject[0]) != 'r' || tolower(m->subject[1]) != 'e' || m->subject[2] != ':')
868 				pm->attr->value = estrstrdup("Re: ", m->subject);
869 			else
870 				pm->attr->value = estrdup(m->subject);
871 			pm->attr->next = nil;
872 		}
873 		if(plumbsend(plumbsendfd, pm) < 0)
874 			fprint(2, "error writing plumb message: %r\n");
875 		plumbfree(pm);
876 	}
877 	free(buf);
878 	return did;
879 }
880 
881 
882 void
883 mesgctl(void *v)
884 {
885 	Message *m;
886 	Window *w;
887 	Event *e, *eq, *e2, *ea;
888 	int na, nopen, i, j;
889 	char *os, *s, *t, *buf;
890 
891 	m = v;
892 	w = m->w;
893 	threadsetname("mesgctl");
894 	proccreate(wineventproc, w, STACK);
895 	for(;;){
896 		e = recvp(w->cevent);
897 		switch(e->c1){
898 		default:
899 		Unk:
900 			print("unknown message %c%c\n", e->c1, e->c2);
901 			break;
902 
903 		case 'E':	/* write to body; can't affect us */
904 			break;
905 
906 		case 'F':	/* generated by our actions; ignore */
907 			break;
908 
909 		case 'K':	/* type away; we don't care */
910 		case 'M':
911 			switch(e->c2){
912 			case 'x':	/* mouse only */
913 			case 'X':
914 				ea = nil;
915 				eq = e;
916 				if(e->flag & 2){
917 					e2 = recvp(w->cevent);
918 					eq = e2;
919 				}
920 				if(e->flag & 8){
921 					ea = recvp(w->cevent);
922 					recvp(w->cevent);
923 					na = ea->nb;
924 				}else
925 					na = 0;
926 				if(eq->q1>eq->q0 && eq->nb==0){
927 					s = emalloc((eq->q1-eq->q0)*UTFmax+1);
928 					winread(w, eq->q0, eq->q1, s);
929 				}else
930 					s = estrdup(eq->b);
931 				if(na){
932 					t = emalloc(strlen(s)+1+na+1);
933 					sprint(t, "%s %s", s, ea->b);
934 					free(s);
935 					s = t;
936 				}
937 				if(!mesgcommand(m, s))	/* send it back */
938 					winwriteevent(w, e);
939 				break;
940 
941 			case 'l':	/* mouse only */
942 			case 'L':
943 				buf = nil;
944 				eq = e;
945 				if(e->flag & 2){
946 					e2 = recvp(w->cevent);
947 					eq = e2;
948 				}
949 				s = eq->b;
950 				if(eq->q1>eq->q0 && eq->nb==0){
951 					buf = emalloc((eq->q1-eq->q0)*UTFmax+1);
952 					winread(w, eq->q0, eq->q1, buf);
953 					s = buf;
954 				}
955 				os = s;
956 				nopen = 0;
957 				do{
958 					/* skip mail box name if present */
959 					if(strncmp(s, mbox.name, strlen(mbox.name)) == 0)
960 						s += strlen(mbox.name);
961 					if(strstr(s, "body") != nil){
962 						/* strip any known extensions */
963 						for(i=0; exts[i].ext!=nil; i++){
964 							j = strlen(exts[i].ext);
965 							if(strlen(s)>j && strcmp(s+strlen(s)-j, exts[i].ext)==0){
966 								s[strlen(s)-j] = '\0';
967 								break;
968 							}
969 						}
970 						if(strlen(s)>5 && strcmp(s+strlen(s)-5, "/body")==0)
971 							s[strlen(s)-4] = '\0';	/* leave / in place */
972 					}
973 					nopen += mesgopen(&mbox, mbox.name, s, m, 0, nil);
974 					while(*s!=0 && *s++!='\n')
975 						;
976 				}while(*s);
977 				if(nopen == 0 && e->c1 == 'L')
978 					nopen += replytoaddr(w, m, e, os);
979 				if(nopen == 0)
980 					winwriteevent(w, e);
981 				free(buf);
982 				break;
983 
984 			case 'I':	/* modify away; we don't care */
985 			case 'D':
986 				mesgtagpost(m);
987 				/* fall through */
988 			case 'd':
989 			case 'i':
990 				break;
991 
992 			default:
993 				goto Unk;
994 			}
995 		}
996 	}
997 }
998 
999 void
1000 mesgline(Message *m, char *header, char *value)
1001 {
1002 	//1 char *tmp;
1003 	//1 tmp = emalloc(strlen(header)+2+strlen(value)+1);
1004 
1005 	if(strlen(value) > 0) {
1006 		// jpc Bprint(m->w->body, "%s: %s\n", header, value);
1007 		fsprint(m->w->body, "%s: %s\n", header, value);
1008 	}
1009 }
1010 
1011 int
1012 isprintable(char *type)
1013 {
1014 	int i;
1015 
1016 	for(i=0; goodtypes[i]!=nil; i++)
1017 		if(strcmp(type, goodtypes[i])==0)
1018 			return 1;
1019 	return 0;
1020 }
1021 
1022 char*
1023 ext(char *type)
1024 {
1025 	int i;
1026 
1027 	for(i=0; exts[i].type!=nil; i++)
1028 		if(strcmp(type, exts[i].type)==0)
1029 			return exts[i].ext;
1030 	return "";
1031 }
1032 
1033 void
1034 mimedisplay(Message *m, char *name, char *rootdir, Window *w, int fileonly)
1035 {
1036 	char *dest;
1037 	char* tmp;
1038 
1039 	if(strcmp(m->disposition, "file")==0 || strlen(m->filename)!=0){
1040 		if(strlen(m->filename) == 0){
1041 			dest = estrdup(m->name);
1042 			dest[strlen(dest)-1] = '\0';
1043 		}else
1044 			dest = estrdup(m->filename);
1045 		if(m->filename[0] != '/')
1046 			dest = egrow(estrdup(home), "/", dest);
1047 		// jpc Bprint(w->body, "\tcp %s%sbody%s %q\n", rootdir, name, ext(m->type), dest);
1048 		if( strncmp(rootdir,"/mail/fs/",strlen("/mail/fs/"))==0) {
1049 			tmp = rootdir+strlen("/mail/fs/");
1050 		}
1051 		fsprint(w->body, "\t9p read upasfs/%s%sbody%s > %s\n", tmp, name, ext(m->type), dest);
1052 		free(dest);
1053 	}else if(!fileonly) {
1054 		// jpc Bprint(w->body, "\tfile is %s%sbody%s\n", rootdir, name, ext(m->type));
1055 		fsprint(w->body, "\tfile is %s%sbody%s\n", rootdir, name, ext(m->type));
1056 	}
1057 }
1058 
1059 #if 0 /* jpc */
1060 void
1061 printheader(char *dir, Biobuf *b, char **okheaders)
1062 {
1063 	char *s;
1064 	char *lines[100];
1065 	int i, j, n;
1066 
1067 	s = readfile(dir, "header", nil);
1068 	if(s == nil)
1069 		return;
1070 	n = getfields(s, lines, nelem(lines), 0, "\n");
1071 	for(i=0; i<n; i++)
1072 		for(j=0; okheaders[j]; j++)
1073 			if(cistrncmp(lines[i], okheaders[j], strlen(okheaders[j])) == 0)
1074 				Bprint(b, "%s\n", lines[i]);
1075 	free(s);
1076 }
1077 #endif
1078 
1079 void
1080 printheader(char *dir, CFid *fid, char **okheaders)
1081 {
1082 	char *s;
1083 	char *lines[100];
1084 	int i, j, n;
1085 
1086 	s = readfile(dir, "header", nil);
1087 	if(s == nil)
1088 		return;
1089 	n = getfields(s, lines, nelem(lines), 0, "\n");
1090 	for(i=0; i<n; i++)
1091 		for(j=0; okheaders[j]; j++)
1092 			if(cistrncmp(lines[i], okheaders[j], strlen(okheaders[j])) == 0) {
1093 				// jpc Bprint(b, "%s\n", lines[i]);
1094 				fswrite(fid,lines[i],strlen(lines[i]));
1095 				fswrite(fid,"\n",strlen("\n"));
1096 			}
1097 	free(s);
1098 }
1099 
1100 void
1101 mesgload(Message *m, char *rootdir, char *file, Window *w)
1102 {
1103 	char *s, *subdir, *name, *dir;
1104 	Message *mp, *thisone;
1105 	int n;
1106 
1107 	dir = estrstrdup(rootdir, file);
1108 
1109 	if(strcmp(m->type, "message/rfc822") != 0){	/* suppress headers of envelopes */
1110 		if(strlen(m->from) > 0){
1111 			// Bprint(w->body, "From: %s\n", m->from);
1112 			fsprint(w->body, "From: %s\n", m->from);
1113 			mesgline(m, "Date", m->date);
1114 			mesgline(m, "To", m->to);
1115 			mesgline(m, "CC", m->cc);
1116 			mesgline(m, "Subject", m->subject);
1117 			printheader(dir, w->body, extraheaders);
1118 		}else{
1119 			printheader(dir, w->body, okheaders);
1120 			printheader(dir, w->body, extraheaders);
1121 		}
1122 		// Bprint(w->body, "\n");
1123 		fswrite(w->body,"\n",strlen("\n"));
1124 	}
1125 
1126 	if(m->level == 1 && m->recursed == 0){
1127 		m->recursed = 1;
1128 		readmbox(m, rootdir, m->name);
1129 	}
1130 	if(m->head == nil){	/* single part message */
1131 		if(strcmp(m->type, "text")==0 || strncmp(m->type, "text/", 5)==0){
1132 			mimedisplay(m, m->name, rootdir, w, 1);
1133 			s = readbody(m->type, dir, &n);
1134 			winwritebody(w, s, n);
1135 			free(s);
1136 		}else{
1137 			mimedisplay(m, m->name, rootdir, w, 0);
1138 		}
1139 	}else{
1140 		/* multi-part message, either multipart/* or message/rfc822 */
1141 		thisone = nil;
1142 		if(strcmp(m->type, "multipart/alternative") == 0){
1143 			thisone = m->head;	/* in case we can't find a good one */
1144 			for(mp=m->head; mp!=nil; mp=mp->next)
1145 				if(isprintable(mp->type)){
1146 					thisone = mp;
1147 					break;
1148 				}
1149 		}
1150 		for(mp=m->head; mp!=nil; mp=mp->next){
1151 			if(thisone!=nil && mp!=thisone)
1152 				continue;
1153 			subdir = estrstrdup(dir, mp->name);
1154 			name = estrstrdup(file, mp->name);
1155 			/* skip first element in name because it's already in window name */
1156 			if(mp != m->head) {
1157 				// jpc Bprint(w->body, "\n===> %s (%s) [%s]\n", strchr(name, '/')+1, mp->type, mp->disposition);
1158 				fsprint(w->body, "\n===> %s (%s) [%s]\n", strchr(name, '/')+1, mp->type, mp->disposition);
1159 			}
1160 			if(strcmp(mp->type, "text")==0 || strncmp(mp->type, "text/", 5)==0){
1161 				mimedisplay(mp, name, rootdir, w, 1);
1162 				printheader(subdir, w->body, okheaders);
1163 				printheader(subdir, w->body, extraheaders);
1164 				winwritebody(w, "\n", 1);
1165 				s = readbody(mp->type, subdir, &n);
1166 				winwritebody(w, s, n);
1167 				free(s);
1168 			}else{
1169 				if(strncmp(mp->type, "multipart/", 10)==0 || strcmp(mp->type, "message/rfc822")==0){
1170 					mp->w = w;
1171 					mesgload(mp, rootdir, name, w);
1172 					mp->w = nil;
1173 				}else
1174 					mimedisplay(mp, name, rootdir, w, 0);
1175 			}
1176 			free(name);
1177 			free(subdir);
1178 		}
1179 	}
1180 	free(dir);
1181 }
1182 
1183 int
1184 tokenizec(char *str, char **args, int max, char *splitc)
1185 {
1186 	int na;
1187 	int intok = 0;
1188 
1189 	if(max <= 0)
1190 		return 0;	
1191 	for(na=0; *str != '\0';str++){
1192 		if(strchr(splitc, *str) == nil){
1193 			if(intok)
1194 				continue;
1195 			args[na++] = str;
1196 			intok = 1;
1197 		}else{
1198 			/* it's a separator/skip character */
1199 			*str = '\0';
1200 			if(intok){
1201 				intok = 0;
1202 				if(na >= max)
1203 					break;
1204 			}
1205 		}
1206 	}
1207 	return na;
1208 }
1209 
1210 Message*
1211 mesglookup(Message *mbox, char *name, char *digest)
1212 {
1213 	int n;
1214 	Message *m;
1215 	char *t;
1216 
1217 	if(digest){
1218 		/* can find exactly */
1219 		for(m=mbox->head; m!=nil; m=m->next)
1220 			if(strcmp(digest, m->digest) == 0)
1221 				break;
1222 		return m;
1223 	}
1224 
1225 	n = strlen(name);
1226 	if(n == 0)
1227 		return nil;
1228 	if(name[n-1] == '/')
1229 		t = estrdup(name);
1230 	else
1231 		t = estrstrdup(name, "/");
1232 	for(m=mbox->head; m!=nil; m=m->next)
1233 		if(strcmp(t, m->name) == 0)
1234 			break;
1235 	free(t);
1236 	return m;
1237 }
1238 
1239 /*
1240  * Find plumb port, knowing type is text, given file name (by extension)
1241  */
1242 int
1243 plumbportbysuffix(char *file)
1244 {
1245 	char *suf;
1246 	int i, nsuf, nfile;
1247 
1248 	nfile = strlen(file);
1249 	for(i=0; ports[i].type!=nil; i++){
1250 		suf = ports[i].suffix;
1251 		nsuf = strlen(suf);
1252 		if(nfile > nsuf)
1253 			if(cistrncmp(file+nfile-nsuf, suf, nsuf) == 0)
1254 				return i;
1255 	}
1256 	return 0;
1257 }
1258 
1259 /*
1260  * Find plumb port using type and file name (by extension)
1261  */
1262 int
1263 plumbport(char *type, char *file)
1264 {
1265 	int i;
1266 
1267 	for(i=0; ports[i].type!=nil; i++)
1268 		if(strncmp(type, ports[i].type, strlen(ports[i].type)) == 0)
1269 			return i;
1270 	/* see if it's a text type */
1271 	for(i=0; goodtypes[i]!=nil; i++)
1272 		if(strncmp(type, goodtypes[i], strlen(goodtypes[i])) == 0)
1273 			return plumbportbysuffix(file);
1274 	return -1;
1275 }
1276 
1277 void
1278 plumb(Message *m, char *dir)
1279 {
1280 	int i;
1281 	char *port;
1282 	Plumbmsg *pm;
1283 
1284 	if(strlen(m->type) == 0)
1285 		return;
1286 	i = plumbport(m->type, m->filename);
1287 	if(i < 0)
1288 		fprint(2, "can't find destination for message subpart\n");
1289 	else{
1290 		port = ports[i].port;
1291 		pm = emalloc(sizeof(Plumbmsg));
1292 		pm->src = estrdup("Mail");
1293 		if(port)
1294 			pm->dst = estrdup(port);
1295 		else
1296 			pm->dst = nil;
1297 		pm->wdir = nil;
1298 		pm->type = estrdup("text");
1299 		pm->ndata = -1;
1300 		pm->data = estrstrdup(dir, "body");
1301 		pm->data = eappend(pm->data, "", ports[i].suffix);
1302 		if(plumbsend(plumbsendfd, pm) < 0)
1303 			fprint(2, "error writing plumb message: %r\n");
1304 		plumbfree(pm);
1305 	}
1306 }
1307 
1308 int
1309 mesgopen(Message *mbox, char *dir, char *s, Message *mesg, int plumbed, char *digest)
1310 {
1311 	char *t, *u, *v;
1312 	Message *m;
1313 	char *direlem[10];
1314 	int i, ndirelem, reuse;
1315 
1316 	/* find white-space-delimited first word */
1317 	for(t=s; *t!='\0' && !isspace(*t); t++)
1318 		;
1319 	u = emalloc(t-s+1);
1320 	memmove(u, s, t-s);
1321 	/* separate it on slashes */
1322 	ndirelem = tokenizec(u, direlem, nelem(direlem), "/");
1323 	if(ndirelem <= 0){
1324     Error:
1325 		free(u);
1326 		return 0;
1327 	}
1328 	if(plumbed){
1329 		fprint(2,"mesg.c:1229 fixme\n");
1330 		write(wctlfd, "top", 3);
1331 		write(wctlfd, "current", 7);
1332 	}
1333 	/* open window for message */
1334 	m = mesglookup(mbox, direlem[0], digest);
1335 	if(m == nil)
1336 		goto Error;
1337 	if(mesg!=nil && m!=mesg)	/* string looked like subpart but isn't part of this message */
1338 		goto Error;
1339 	if(m->opened == 0){
1340 		if(m->w == nil){
1341 			reuse = 0;
1342 			m->w = newwindow();
1343 		}else{
1344 			reuse = 1;
1345 			/* re-use existing window */
1346 			if(winsetaddr(m->w, "0,$", 1)){
1347 				if(m->w->data == nil)
1348 					m->w->data = winopenfid(m->w, "data");
1349 				fswrite(m->w->data, "", 0);
1350 				// fsync(m->w->data);
1351 			}
1352 		}
1353 		v = estrstrdup(mbox->name, m->name);
1354 		winname(m->w, v);
1355 		free(v);
1356 		if(!reuse){
1357 			if(m->deleted)
1358 				wintagwrite(m->w, "Q Reply all UnDelmesg Save ", 2+6+4+10+5);
1359 			else
1360 				wintagwrite(m->w, "Q Reply all Delmesg Save ", 2+6+4+8+5);
1361 		}
1362 		threadcreate(mesgctl, m, STACK);
1363 		winopenbody(m->w, OWRITE);
1364 		mesgload(m, dir, m->name, m->w);
1365 		winclosebody(m->w);
1366 		// sleep(100);
1367 		winclean(m->w);
1368 		m->opened = 1;
1369 		if(ndirelem == 1){
1370 			free(u);
1371 			return 1;
1372 		}
1373 	}
1374 	if(ndirelem == 1 && plumbport(m->type, m->filename) <= 0){
1375 		/* make sure dot is visible */
1376 		ctlprint(m->w->ctl, "show\n");
1377 		return 0;
1378 	}
1379 	/* walk to subpart */
1380 	dir = estrstrdup(dir, m->name);
1381 	for(i=1; i<ndirelem; i++){
1382 		m = mesglookup(m, direlem[i], digest);
1383 		if(m == nil)
1384 			break;
1385 		dir = egrow(dir, m->name, nil);
1386 	}
1387 	if(m != nil && plumbport(m->type, m->filename) > 0)
1388 		plumb(m, dir);
1389 	free(dir);
1390 	free(u);
1391 	return 1;
1392 }
1393 
1394 void
1395 rewritembox(Window *w, Message *mbox)
1396 {
1397 	Message *m, *next;
1398 	char *deletestr, *t;
1399 	int nopen;
1400 
1401 	deletestr = estrstrdup("delete ", fsname);
1402 
1403 	nopen = 0;
1404 	for(m=mbox->head; m!=nil; m=next){
1405 		next = m->next;
1406 		if(m->deleted == 0)
1407 			continue;
1408 		if(m->opened){
1409 			nopen++;
1410 			continue;
1411 		}
1412 		if(m->writebackdel){
1413 			/* messages deleted by plumb message are not removed again */
1414 			t = estrdup(m->name);
1415 			if(strlen(t) > 0)
1416 				t[strlen(t)-1] = '\0';
1417 			deletestr = egrow(deletestr, " ", t);
1418 		}
1419 		mesgmenudel(w, mbox, m);
1420 		mesgdel(mbox, m);
1421 	}
1422 	if(write(mbox->ctlfd, deletestr, strlen(deletestr)) < 0)
1423 		fprint(2, "Mail: warning: error removing mail message files: %r\n");
1424 	free(deletestr);
1425 	winselect(w, "0", 0);
1426 	if(nopen == 0)
1427 		winclean(w);
1428 	mbox->dirty = 0;
1429 }
1430 
1431 /* name is a full file name, but it might not belong to us */
1432 Message*
1433 mesglookupfile(Message *mbox, char *name, char *digest)
1434 {
1435 	int k, n;
1436 
1437 	k = strlen(name);
1438 	n = strlen(mbox->name);
1439 	if(k==0 || strncmp(name, mbox->name, n) != 0){
1440 //		fprint(2, "Mail: message %s not in this mailbox\n", name);
1441 		return nil;
1442 	}
1443 	return mesglookup(mbox, name+n, digest);
1444 }