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