op public repos

Blob

Date:: Fri Jan 10 14:54:30 2020 UTC
Message:: Trivial changes: whitespace and modes. Remote whitespace at the ends of lines. Remove blank lines from the ends of files. Change modes on source files so that they are not executable. Signed-off-by: Dan Cross <cross@gajendra.net>
Actions:: History | Blame | Raw File
1 /*
2  * Locking here is not quite right.
3  * Calling qlock(&z->lk) can block the proc,
4  * and when it comes back, boxes and msgs might have been freed
5  * (if the refresh proc was holding the lock and in the middle of a
6  * redial).  I've tried to be careful about not assuming boxes continue
7  * to exist across imap commands, but maybe this isn't really tenable.
8  * Maybe instead we should ref count the boxes and messages.
9  */
10 
11 #include "a.h"
12 #include <libsec.h>
13 
14 struct Imap
15 {
16 	int		connected;
17 	int		autoreconnect;
18 	int		ticks;	/* until boom! */
19 	char*	server;
20 	char*	root;
21 	char*	user;
22 	int		mode;
23 	int		fd;
24 	Biobuf	b;
25 	Ioproc*	io;
26 	QLock	lk;
27 	QLock	rlk;
28 	Rendez	r;
29 
30 	Box*		inbox;
31 	Box*		box;
32 	Box*		nextbox;
33 
34 	/* SEARCH results */
35 	uint		*uid;
36 	uint		nuid;
37 
38 	uint		reply;
39 };
40 
41 static struct {
42 	char *name;
43 	int flag;
44 } flagstab[] =
45 {
46 	"Junk",	FlagJunk,
47 	"NonJunk",	FlagNonJunk,
48 	"\\Answered",	FlagReplied,
49 	"\\Flagged",	FlagFlagged,
50 	"\\Deleted",	FlagDeleted,
51 	"\\Draft",		FlagDraft,
52 	"\\Recent",	FlagRecent,
53 	"\\Seen",		FlagSeen,
54 	"\\NoInferiors",	FlagNoInferiors,
55 	"\\NoSelect",	FlagNoSelect,
56 	"\\Marked",	FlagMarked,
57 	"\\UnMarked",	FlagUnMarked
58 };
59 
60 int			chattyimap;
61 
62 static char	*tag = "#";
63 
64 static void	checkbox(Imap*, Box*);
65 static char*	copyaddrs(Sx*);
66 static void	freeup(UserPasswd*);
67 static int		getbox(Imap*, Box*);
68 static int		getboxes(Imap*);
69 static char*	gsub(char*, char*, char*);
70 static int		imapcmd(Imap*, Box*, char*, ...);
71 static Sx*		imapcmdsxlit(Imap*, Box*, char*, ...);
72 static Sx*		imapcmdsx(Imap*, Box*, char*, ...);
73 static Sx*		imapcmdsx0(Imap*, char*, ...);
74 static Sx*		imapvcmdsx(Imap*, Box*, char*, va_list, int);
75 static Sx*		imapvcmdsx0(Imap*, char*, va_list, int);
76 static int		imapdial(char*, int);
77 static int		imaplogin(Imap*);
78 static int		imapquote(Fmt*);
79 static int		imapreconnect(Imap*);
80 static void	imaprefreshthread(void*);
81 static void	imaptimerproc(void*);
82 static Sx*		imapwaitsx(Imap*);
83 static int		isatom(Sx *v, char *name);
84 static int		islist(Sx *v);
85 static int		isnil(Sx *v);
86 static int		isnumber(Sx *sx);
87 static int		isstring(Sx *sx);
88 static int		ioimapdial(Ioproc*, char*, int);
89 static char*	nstring(Sx*);
90 static void	unexpected(Imap*, Sx*);
91 static Sx*		zBrdsx(Imap*);
92 
93 /*
94  * Imap connection maintenance and login.
95  */
96 
97 Imap*
98 imapconnect(char *server, int mode, char *root, char *user)
99 {
100 	Imap *z;
101 
102 	fmtinstall('H', encodefmt);
103 	fmtinstall('Z', imapquote);
104 
105 	z = emalloc(sizeof *z);
106 	z->server = estrdup(server);
107 	z->mode = mode;
108 	z->user = user;
109 	if(root)
110 		if(root[0] != 0 && root[strlen(root)-1] != '/')
111 			z->root = smprint("%s/", root);
112 		else
113 			z->root = root;
114 	else
115 		z->root = "";
116 	z->fd = -1;
117 	z->autoreconnect = 0;
118 	z->io = ioproc();
119 
120 	qlock(&z->lk);
121 	if(imapreconnect(z) < 0){
122 		free(z);
123 		return nil;
124 	}
125 
126 	z->r.l = &z->rlk;
127 	z->autoreconnect = 1;
128 	qunlock(&z->lk);
129 
130 	proccreate(imaptimerproc, z, STACK);
131 	mailthread(imaprefreshthread, z);
132 
133 	return z;
134 }
135 
136 void
137 imaphangup(Imap *z, int ticks)
138 {
139 	z->ticks = ticks;
140 	if(ticks == 0){
141 		close(z->fd);
142 		z->fd = -1;
143 	}
144 }
145 
146 static int
147 imapreconnect(Imap *z)
148 {
149 	Sx *sx;
150 
151 	z->autoreconnect = 0;
152 	z->box = nil;
153 	z->inbox = nil;
154 
155 	if(z->fd >= 0){
156 		close(z->fd);
157 		z->fd = -1;
158 	}
159 
160 	if(chattyimap)
161 		fprint(2, "dial %s...\n", z->server);
162 	if((z->fd = ioimapdial(z->io, z->server, z->mode)) < 0)
163 		return -1;
164 	z->connected = 1;
165 	Binit(&z->b, z->fd, OREAD);
166 	if((sx = zBrdsx(z)) == nil){
167 		werrstr("no greeting");
168 		goto err;
169 	}
170 	if(chattyimap)
171 		fprint(2, "<I %#$\n", sx);
172 	if(sx->nsx >= 2 && isatom(sx->sx[0], "*") && isatom(sx->sx[1], "PREAUTH")){
173 		freesx(sx);
174 		goto preauth;
175 	}
176 	if(!oksx(sx)){
177 		werrstr("bad greeting - %#$", sx);
178 		goto err;
179 	}
180 	freesx(sx);
181 	sx = nil;
182 	if(imaplogin(z) < 0)
183 		goto err;
184 preauth:
185 	if(getboxes(z) < 0 || getbox(z, z->inbox) < 0)
186 		goto err;
187 	z->autoreconnect = 1;
188 	return 0;
189 
190 err:
191 	if(z->fd >= 0){
192 		close(z->fd);
193 		z->fd = -1;
194 	}
195 	if(sx)
196 		freesx(sx);
197 	z->autoreconnect = 1;
198 	z->connected = 0;
199 	return -1;
200 }
201 
202 static int
203 imaplogin(Imap *z)
204 {
205 	Sx *sx;
206 	UserPasswd *up;
207 
208 	if(z->user != nil)
209 		up = auth_getuserpasswd(auth_getkey, "proto=pass role=client service=imap server=%q user=%q", z->server, z->user);
210 	else
211 		up = auth_getuserpasswd(auth_getkey, "proto=pass role=client service=imap server=%q", z->server);
212 	if(up == nil){
213 		werrstr("getuserpasswd - %r");
214 		return -1;
215 	}
216 
217 	sx = imapcmdsx(z, nil, "LOGIN %#Z %#Z", up->user, up->passwd);
218 	freeup(up);
219 	if(sx == nil)
220 		return -1;
221 	if(!oksx(sx)){
222 		freesx(sx);
223 		werrstr("login rejected - %#$", sx);
224 		return -1;
225 	}
226 	return 0;
227 }
228 
229 static int
230 getboxes(Imap *z)
231 {
232 	int i;
233 	Box **r, **w, **e;
234 
235 	for(i=0; i<nboxes; i++){
236 		boxes[i]->mark = 1;
237 		boxes[i]->exists = 0;
238 		boxes[i]->maxseen = 0;
239 	}
240 	if(imapcmd(z, nil, "LIST %Z *", z->root) < 0)
241 		return -1;
242 	if(z->root != nil && imapcmd(z, nil, "LIST %Z INBOX", "") < 0)
243 		return -1;
244 	if(z->nextbox && z->nextbox->mark)
245 		z->nextbox = nil;
246 	for(r=boxes, w=boxes, e=boxes+nboxes; r<e; r++){
247 		if((*r)->mark)
248 {fprint(2, "*** free box %s %s\n", (*r)->name, (*r)->imapname);
249 			boxfree(*r);
250 }
251 		else
252 			*w++ = *r;
253 	}
254 	nboxes = w - boxes;
255 	return 0;
256 }
257 
258 static int
259 getbox(Imap *z, Box *b)
260 {
261 	int i;
262 	Msg **r, **w, **e;
263 
264 	if(b == nil)
265 		return 0;
266 
267 	for(i=0; i<b->nmsg; i++)
268 		b->msg[i]->imapid = 0;
269 	if(imapcmd(z, b, "UID FETCH 1:* FLAGS") < 0)
270 		return -1;
271 	for(r=b->msg, w=b->msg, e=b->msg+b->nmsg; r<e; r++){
272 		if((*r)->imapid == 0)
273 			msgfree(*r);
274 		else{
275 			(*r)->ix = w-b->msg;
276 			*w++ = *r;
277 		}
278 	}
279 	b->nmsg = w - b->msg;
280 	b->imapinit = 1;
281 	checkbox(z, b);
282 	return 0;
283 }
284 
285 static void
286 freeup(UserPasswd *up)
287 {
288 	memset(up->user, 0, strlen(up->user));
289 	memset(up->passwd, 0, strlen(up->passwd));
290 	free(up);
291 }
292 
293 static void
294 imaptimerproc(void *v)
295 {
296 	Imap *z;
297 
298 	z = v;
299 	for(;;){
300 		sleep(60*1000);
301 		qlock(z->r.l);
302 		rwakeup(&z->r);
303 		qunlock(z->r.l);
304 	}
305 }
306 
307 static void
308 checkbox(Imap *z, Box *b)
309 {
310 	if(imapcmd(z, b, "NOOP") >= 0){
311 		if(!b->imapinit)
312 			getbox(z, b);
313 		if(!b->imapinit)
314 			return;
315 		if(b==z->box && b->exists > b->maxseen){
316 			imapcmd(z, b, "UID FETCH %d:* FULL",
317 				b->uidnext);
318 		}
319 	}
320 }
321 
322 static void
323 imaprefreshthread(void *v)
324 {
325 	Imap *z;
326 
327 	z = v;
328 	for(;;){
329 		qlock(z->r.l);
330 		rsleep(&z->r);
331 		qunlock(z->r.l);
332 
333 		qlock(&z->lk);
334 		if(z->inbox)
335 			checkbox(z, z->inbox);
336 		qunlock(&z->lk);
337 	}
338 }
339 
340 /*
341  * Run a single command and return the Sx.  Does NOT redial.
342  */
343 static Sx*
344 imapvcmdsx0(Imap *z, char *fmt, va_list arg, int dotag)
345 {
346 	char *s;
347 	Fmt f;
348 	int len;
349 	Sx *sx;
350 
351 	if(canqlock(&z->lk))
352 		abort();
353 
354 	if(z->fd < 0 || !z->connected)
355 		return nil;
356 
357 	fmtstrinit(&f);
358 	if(dotag)
359 		fmtprint(&f, "%s ", tag);
360 	fmtvprint(&f, fmt, arg);
361 	fmtprint(&f, "\r\n");
362 	s = fmtstrflush(&f);
363 	len = strlen(s);
364 	s[len-2] = 0;
365 	if(chattyimap)
366 		fprint(2, "I> %s\n", s);
367 	s[len-2] = '\r';
368 	if(iowrite(z->io, z->fd, s, len) < 0){
369 		z->connected = 0;
370 		free(s);
371 		return nil;
372 	}
373 	sx = imapwaitsx(z);
374 	free(s);
375 	return sx;
376 }
377 
378 static Sx*
379 imapcmdsx0(Imap *z, char *fmt, ...)
380 {
381 	va_list arg;
382 	Sx *sx;
383 
384 	va_start(arg, fmt);
385 	sx = imapvcmdsx0(z, fmt, arg, 1);
386 	va_end(arg);
387 	return sx;
388 }
389 
390 /*
391  * Run a single command on box b.  Does redial.
392  */
393 static Sx*
394 imapvcmdsx(Imap *z, Box *b, char *fmt, va_list arg, int dotag)
395 {
396 	int tries;
397 	Sx *sx;
398 
399 	tries = 0;
400 	z->nextbox = b;
401 
402 	if(z->fd < 0 || !z->connected){
403 reconnect:
404 		if(!z->autoreconnect)
405 			return nil;
406 		if(imapreconnect(z) < 0)
407 			return nil;
408 		if(b && z->nextbox == nil)	/* box disappeared on reconnect */
409 			return nil;
410 	}
411 
412 	if(b && b != z->box){
413 		if(z->box)
414 			z->box->imapinit = 0;
415 		z->box = b;
416 		if((sx=imapcmdsx0(z, "SELECT %Z", b->imapname)) == nil){
417 			z->box = nil;
418 			if(tries++ == 0 && (z->fd < 0 || !z->connected))
419 				goto reconnect;
420 			return nil;
421 		}
422 		freesx(sx);
423 	}
424 
425 	if((sx=imapvcmdsx0(z, fmt, arg, dotag)) == nil){
426 		if(tries++ == 0 && (z->fd < 0 || !z->connected))
427 			goto reconnect;
428 		return nil;
429 	}
430 	return sx;
431 }
432 
433 static int
434 imapcmd(Imap *z, Box *b, char *fmt, ...)
435 {
436 	Sx *sx;
437 	va_list arg;
438 
439 	va_start(arg, fmt);
440 	sx = imapvcmdsx(z, b, fmt, arg, 1);
441 	va_end(arg);
442 	if(sx == nil)
443 		return -1;
444 	if(sx->nsx < 2 || !isatom(sx->sx[1], "OK")){
445 		werrstr("%$", sx);
446 		freesx(sx);
447 		return -1;
448 	}
449 	freesx(sx);
450 	return 0;
451 }
452 
453 static Sx*
454 imapcmdsx(Imap *z, Box *b, char *fmt, ...)
455 {
456 	Sx *sx;
457 	va_list arg;
458 
459 	va_start(arg, fmt);
460 	sx = imapvcmdsx(z, b, fmt, arg, 1);
461 	va_end(arg);
462 	return sx;
463 }
464 
465 static Sx*
466 imapcmdsxlit(Imap *z, Box *b, char *fmt, ...)
467 {
468 	Sx *sx;
469 	va_list arg;
470 
471 	va_start(arg, fmt);
472 	sx = imapvcmdsx(z, b, fmt, arg, 0);
473 	va_end(arg);
474 	return sx;
475 }
476 
477 static Sx*
478 imapwaitsx(Imap *z)
479 {
480 	Sx *sx;
481 
482 	while((sx = zBrdsx(z)) != nil){
483 		if(chattyimap)
484 			fprint(2, "<| %#$\n", sx);
485 		if(sx->nsx >= 1 && sx->sx[0]->type == SxAtom && cistrcmp(sx->sx[0]->data, tag) == 0)
486 			return sx;
487 		if(sx->nsx >= 1 && sx->sx[0]->type == SxAtom && cistrcmp(sx->sx[0]->data, "+") == 0){
488 			z->reply = 1;
489 			return sx;
490 		}
491 		if(sx->nsx >= 1 && sx->sx[0]->type == SxAtom && strcmp(sx->sx[0]->data, "*") == 0)
492 			unexpected(z, sx);
493 		if(sx->type == SxList && sx->nsx == 0){
494 			freesx(sx);
495 			break;
496 		}
497 		freesx(sx);
498 	}
499 	z->connected = 0;
500 	return nil;
501 }
502 
503 /*
504  * Imap interface to mail file system.
505  */
506 
507 static void
508 _bodyname(char *buf, char *ebuf, Part *p, char *extra)
509 {
510 	if(buf >= ebuf){
511 		fprint(2, "***** BUFFER TOO SMALL\n");
512 		return;
513 	}
514 	*buf = 0;
515 	if(p->parent){
516 		_bodyname(buf, ebuf, p->parent, "");
517 		buf += strlen(buf);
518 		seprint(buf, ebuf, ".%d", p->pix+1);
519 	}
520 	buf += strlen(buf);
521 	seprint(buf, ebuf, "%s", extra);
522 }
523 
524 static char*
525 bodyname(Part *p, char *extra)
526 {
527 	static char buf[256];
528 	memset(buf, 0, sizeof buf);	/* can't see why this is necessary, but it is */
529 	_bodyname(buf, buf+sizeof buf, p, extra);
530 	return buf+1;	/* buf[0] == '.' */
531 }
532 
533 static void
534 fetch1(Imap *z, Part *p, char *s)
535 {
536 	qlock(&z->lk);
537 	imapcmd(z, p->msg->box, "UID FETCH %d BODY[%s]",
538 		p->msg->imapuid, bodyname(p, s));
539 	qunlock(&z->lk);
540 }
541 
542 void
543 imapfetchrawheader(Imap *z, Part *p)
544 {
545 	fetch1(z, p, ".HEADER");
546 }
547 
548 void
549 imapfetchrawmime(Imap *z, Part *p)
550 {
551 	fetch1(z, p, ".MIME");
552 }
553 
554 void
555 imapfetchrawbody(Imap *z, Part *p)
556 {
557 	fetch1(z, p, ".TEXT");
558 }
559 
560 void
561 imapfetchraw(Imap *z, Part *p)
562 {
563 	fetch1(z, p, "");
564 }
565 
566 static int
567 imaplistcmd(Imap *z, Box *box, char *before, Msg **m, uint nm, char *after)
568 {
569 	int i, r;
570 	char *cmd;
571 	Fmt fmt;
572 
573 	if(nm == 0)
574 		return 0;
575 
576 	fmtstrinit(&fmt);
577 	fmtprint(&fmt, "%s ", before);
578 	for(i=0; i<nm; i++){
579 		if(i > 0)
580 			fmtrune(&fmt, ',');
581 		fmtprint(&fmt, "%ud", m[i]->imapuid);
582 	}
583 	fmtprint(&fmt, " %s", after);
584 	cmd = fmtstrflush(&fmt);
585 
586 	r = 0;
587 	if(imapcmd(z, box, "%s", cmd) < 0)
588 		 r = -1;
589 	free(cmd);
590 	return r;
591 }
592 
593 int
594 imapcopylist(Imap *z, char *nbox, Msg **m, uint nm)
595 {
596 	int rv;
597 	char *name, *p;
598 
599 	if(nm == 0)
600 		return 0;
601 
602 	qlock(&z->lk);
603 	if(strcmp(nbox, "mbox") == 0)
604 		name = estrdup("INBOX");
605 	else{
606 		p = esmprint("%s%s", z->root, nbox);
607 		name = esmprint("%Z", p);
608 		free(p);
609 	}
610 	rv = imaplistcmd(z, m[0]->box, "UID COPY", m, nm, name);
611 	free(name);
612 	qunlock(&z->lk);
613 	return rv;
614 }
615 
616 int
617 imapremovelist(Imap *z, Msg **m, uint nm)
618 {
619 	int rv;
620 
621 	if(nm == 0)
622 		return 0;
623 
624 	qlock(&z->lk);
625 	rv = imaplistcmd(z, m[0]->box, "UID STORE", m, nm, "+FLAGS.SILENT (\\Deleted)");
626 	/* careful - box might be gone; use z->box instead */
627 	if(rv == 0 && z->box)
628 		rv = imapcmd(z, z->box, "EXPUNGE");
629 	qunlock(&z->lk);
630 	return rv;
631 }
632 
633 int
634 imapflaglist(Imap *z, int op, int flag, Msg **m, uint nm)
635 {
636 	char *mod, *s, *sep;
637 	int i, rv;
638 	Fmt fmt;
639 
640 	if(op > 0)
641 		mod = "+";
642 	else if(op == 0)
643 		mod = "";
644 	else
645 		mod = "-";
646 
647 	fmtstrinit(&fmt);
648 	fmtprint(&fmt, "%sFLAGS (", mod);
649 	sep = "";
650 	for(i=0; i<nelem(flagstab); i++){
651 		if(flagstab[i].flag & flag){
652 			fmtprint(&fmt, "%s%s", sep, flagstab[i].name);
653 			sep = " ";
654 		}
655 	}
656 	fmtprint(&fmt, ")");
657 	s = fmtstrflush(&fmt);
658 
659 	qlock(&z->lk);
660 	rv = imaplistcmd(z, m[0]->box, "UID STORE", m, nm, s);
661 	qunlock(&z->lk);
662 	free(s);
663 	return rv;
664 }
665 
666 int
667 imapsearchbox(Imap *z, Box *b, char *search, Msg ***mm)
668 {
669 	uint *uid;
670 	int i, nuid;
671 	Msg **m;
672 	int nm;
673 	Sx *sx;
674 
675 	qlock(&z->lk);
676 	sx = imapcmdsx(z, b, "UID SEARCH CHARSET UTF-8 TEXT {%d}", strlen(search));
677 	freesx(sx);
678 	if(!z->reply){
679 		qunlock(&z->lk);
680 		return -1;
681 	}
682 	if((sx = imapcmdsxlit(z, b, "%s", search)) == nil){
683 		qunlock(&z->lk);
684 		return -1;
685 	}
686 	if(sx->nsx < 2 || !isatom(sx->sx[1], "OK")){
687 		werrstr("%$", sx);
688 		freesx(sx);
689 		qunlock(&z->lk);
690 		return -1;
691 	}
692 	freesx(sx);
693 
694 	uid = z->uid;
695 	nuid = z->nuid;
696 	z->uid = nil;
697 	z->nuid = 0;
698 	z->reply = 0;
699 	qunlock(&z->lk);
700 
701 	m = emalloc(nuid*sizeof m[0]);
702 	nm = 0;
703 	for(i=0; i<nuid; i++)
704 		if((m[nm] = msgbyimapuid(b, uid[i], 0)) != nil)
705 			nm++;
706 	*mm = m;
707 	free(uid);
708 	return nm;
709 }
710 
711 void
712 imapcheckbox(Imap *z, Box *b)
713 {
714 	if(b == nil)
715 		return;
716 	qlock(&z->lk);
717 	checkbox(z, b);
718 	qunlock(&z->lk);
719 }
720 
721 /*
722  * Imap utility routines
723  */
724 static long
725 _ioimapdial(va_list *arg)
726 {
727 	char *server;
728 	int mode;
729 
730 	server = va_arg(*arg, char*);
731 	mode = va_arg(*arg, int);
732 	return imapdial(server, mode);
733 }
734 static int
735 ioimapdial(Ioproc *io, char *server, int mode)
736 {
737 	return iocall(io, _ioimapdial, server, mode);
738 }
739 
740 static long
741 _ioBrdsx(va_list *arg)
742 {
743 	Biobuf *b;
744 	Sx **sx;
745 
746 	b = va_arg(*arg, Biobuf*);
747 	sx = va_arg(*arg, Sx**);
748 	*sx = Brdsx(b);
749 	if((*sx) && (*sx)->type == SxList && (*sx)->nsx == 0){
750 		freesx(*sx);
751 		*sx = nil;
752 	}
753 	return 0;
754 }
755 static Sx*
756 ioBrdsx(Ioproc *io, Biobuf *b)
757 {
758 	Sx *sx;
759 
760 	iocall(io, _ioBrdsx, b, &sx);
761 	return sx;
762 }
763 
764 static Sx*
765 zBrdsx(Imap *z)
766 {
767 	if(z->ticks && --z->ticks==0){
768 		close(z->fd);
769 		z->fd = -1;
770 		return nil;
771 	}
772 	return ioBrdsx(z->io, &z->b);
773 }
774 
775 static int
776 imapdial(char *server, int mode)
777 {
778 	int p[2];
779 	int fd[3];
780 	char *tmp;
781 	char *fpath;
782 
783 	switch(mode){
784 	default:
785 	case Unencrypted:
786 		return dial(netmkaddr(server, "tcp", "143"), nil, nil, nil);
787 
788 	case Starttls:
789 		werrstr("starttls not supported");
790 		return -1;
791 
792 	case Tls:
793 		if(pipe(p) < 0)
794 			return -1;
795 		fd[0] = dup(p[0], -1);
796 		fd[1] = dup(p[0], -1);
797 		fd[2] = dup(2, -1);
798 #ifdef PLAN9PORT
799 		tmp = esmprint("%s:993", server);
800 		fpath = searchpath("stunnel3");
801 		if (!fpath) {
802 			werrstr("stunnel not found. it is required for tls support.");
803 			return -1;
804 		}
805 		if(threadspawnl(fd, fpath, "stunnel", "-c", "-r", tmp, nil) < 0) {
806 #else
807 		tmp = esmprint("tcp!%s!993", server);
808 		if(threadspawnl(fd, "/bin/tlsclient", "tlsclient", tmp, nil) < 0){
809 #endif
810 			free(tmp);
811 			close(p[0]);
812 			close(p[1]);
813 			close(fd[0]);
814 			close(fd[1]);
815 			close(fd[2]);
816 			return -1;
817 		}
818 		free(tmp);
819 		close(p[0]);
820 		return p[1];
821 
822 	case Cmd:
823 		if(pipe(p) < 0)
824 			return -1;
825 		fd[0] = dup(p[0], -1);
826 		fd[1] = dup(p[0], -1);
827 		fd[2] = dup(2, -1);
828 		if(threadspawnl(fd, "/usr/local/plan9/bin/rc", "rc", "-c", server, nil) < 0){
829 			close(p[0]);
830 			close(p[1]);
831 			close(fd[0]);
832 			close(fd[1]);
833 			close(fd[2]);
834 			return -1;
835 		}
836 		close(p[0]);
837 		return p[1];
838 	}
839 }
840 
841 enum
842 {
843 	Qok = 0,
844 	Qquote,
845 	Qbackslash
846 };
847 
848 static int
849 needtoquote(Rune r)
850 {
851 	if(r >= Runeself)
852 		return Qquote;
853 	if(r <= ' ')
854 		return Qquote;
855 	if(r=='\\' || r=='"')
856 		return Qbackslash;
857 	return Qok;
858 }
859 
860 static int
861 imapquote(Fmt *f)
862 {
863 	char *s, *t;
864 	int w, quotes;
865 	Rune r;
866 
867 	s = va_arg(f->args, char*);
868 	if(s == nil || *s == '\0')
869 		return fmtstrcpy(f, "\"\"");
870 
871 	quotes = 0;
872 	if(f->flags&FmtSharp)
873 		quotes = 1;
874 	for(t=s; *t; t+=w){
875 		w = chartorune(&r, t);
876 		quotes |= needtoquote(r);
877 	}
878 	if(quotes == 0)
879 		return fmtstrcpy(f, s);
880 
881 	fmtrune(f, '"');
882 	for(t=s; *t; t+=w){
883 		w = chartorune(&r, t);
884 		if(needtoquote(r) == Qbackslash)
885 			fmtrune(f, '\\');
886 		fmtrune(f, r);
887 	}
888 	return fmtrune(f, '"');
889 }
890 
891 static int
892 fmttype(char c)
893 {
894 	switch(c){
895 	case 'A':
896 		return SxAtom;
897 	case 'L':
898 		return SxList;
899 	case 'N':
900 		return SxNumber;
901 	case 'S':
902 		return SxString;
903 	default:
904 		return -1;
905 	}
906 }
907 
908 /*
909  * Check S expression against format string.
910  */
911 static int
912 sxmatch(Sx *sx, char *fmt)
913 {
914 	int i;
915 
916 	for(i=0; fmt[i]; i++){
917 		if(fmt[i] == '*')
918 			fmt--;	/* like i-- but better */
919 		if(i == sx->nsx && fmt[i+1] == '*')
920 			return 1;
921 		if(i >= sx->nsx)
922 			return 0;
923 		if(sx->sx[i] == nil)
924 			return 0;
925 		if(sx->sx[i]->type == SxAtom && strcmp(sx->sx[i]->data, "NIL") == 0){
926 			if(fmt[i] == 'L'){
927 				free(sx->sx[i]->data);
928 				sx->sx[i]->data = nil;
929 				sx->sx[i]->type = SxList;
930 				sx->sx[i]->sx = nil;
931 				sx->sx[i]->nsx = 0;
932 			}
933 			else if(fmt[i] == 'S'){
934 				free(sx->sx[i]->data);
935 				sx->sx[i]->data = nil;
936 				sx->sx[i]->type = SxString;
937 			}
938 		}
939 		if(sx->sx[i]->type == SxAtom && fmt[i]=='S')
940 			sx->sx[i]->type = SxString;
941 		if(sx->sx[i]->type != fmttype(fmt[i])){
942 			fprint(2, "sxmatch: %$ not %c\n", sx->sx[i], fmt[i]);
943 			return 0;
944 		}
945 	}
946 	if(i != sx->nsx)
947 		return 0;
948 	return 1;
949 }
950 
951 /*
952  * Check string against format string.
953  */
954 static int
955 stringmatch(char *fmt, char *s)
956 {
957 	for(; *fmt && *s; fmt++, s++){
958 		switch(*fmt){
959 		case '0':
960 			if(*s == ' ')
961 				break;
962 			/* fall through */
963 		case '1':
964 			if(*s < '0' || *s > '9')
965 				return 0;
966 			break;
967 		case 'A':
968 			if(*s < 'A' || *s > 'Z')
969 				return 0;
970 			break;
971 		case 'a':
972 			if(*s < 'a' || *s > 'z')
973 				return 0;
974 			break;
975 		case '+':
976 			if(*s != '-' && *s != '+')
977 				return 0;
978 			break;
979 		default:
980 			if(*s != *fmt)
981 				return 0;
982 			break;
983 		}
984 	}
985 	if(*fmt || *s)
986 		return 0;
987 	return 1;
988 }
989 
990 /*
991  * Parse simple S expressions and IMAP elements.
992  */
993 static int
994 isatom(Sx *v, char *name)
995 {
996 	int n;
997 
998 	if(v == nil || v->type != SxAtom)
999 		return 0;
1000 	n = strlen(name);
1001 	if(cistrncmp(v->data, name, n) == 0)
1002 		if(v->data[n] == 0 || (n>0 && v->data[n-1] == '['))
1003 			return 1;
1004 	return 0;
1005 }
1006 
1007 static int
1008 isstring(Sx *sx)
1009 {
1010 	if(sx->type == SxAtom)
1011 		sx->type = SxString;
1012 	return sx->type == SxString;
1013 }
1014 
1015 static int
1016 isnumber(Sx *sx)
1017 {
1018 	return sx->type == SxNumber;
1019 }
1020 
1021 static int
1022 isnil(Sx *v)
1023 {
1024 	return v == nil ||
1025 		(v->type==SxList && v->nsx == 0) ||
1026 		(v->type==SxAtom && strcmp(v->data, "NIL") == 0);
1027 }
1028 
1029 static int
1030 islist(Sx *v)
1031 {
1032 	return isnil(v) || v->type==SxList;
1033 }
1034 
1035 static uint
1036 parseflags(Sx *v)
1037 {
1038 	int f, i, j;
1039 
1040 	if(v->type != SxList){
1041 		warn("malformed flags: %$", v);
1042 		return 0;
1043 	}
1044 	f = 0;
1045 	for(i=0; i<v->nsx; i++){
1046 		if(v->sx[i]->type != SxAtom)
1047 			continue;
1048 		for(j=0; j<nelem(flagstab); j++)
1049 			if(cistrcmp(v->sx[i]->data, flagstab[j].name) == 0)
1050 				f |= flagstab[j].flag;
1051 	}
1052 	return f;
1053 }
1054 
1055 static char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
1056 static int
1057 parsemon(char *s)
1058 {
1059 	int i;
1060 
1061 	for(i=0; months[i]; i+=3)
1062 		if(memcmp(s, months+i, 3) == 0)
1063 			return i/3;
1064 	return -1;
1065 }
1066 
1067 static uint
1068 parsedate(Sx *v)
1069 {
1070 	Tm tm;
1071 	uint t;
1072 	int delta;
1073 	char *p;
1074 
1075 	if(v->type != SxString || !stringmatch("01-Aaa-1111 01:11:11 +1111", v->data)){
1076 	bad:
1077 		warn("bad date: %$", v);
1078 		return 0;
1079 	}
1080 
1081 	/* cannot use atoi because 09 is malformed octal! */
1082 	memset(&tm, 0, sizeof tm);
1083 	p = v->data;
1084 	tm.mday = strtol(p, 0, 10);
1085 	tm.mon = parsemon(p+3);
1086 	if(tm.mon == -1)
1087 		goto bad;
1088 	tm.year = strtol(p+7, 0, 10) - 1900;
1089 	tm.hour = strtol(p+12, 0, 10);
1090 	tm.min = strtol(p+15, 0, 10);
1091 	tm.sec = strtol(p+18, 0, 10);
1092 	strcpy(tm.zone, "GMT");
1093 
1094 	t = tm2sec(&tm);
1095 	delta = ((p[22]-'0')*10+p[23]-'0')*3600 + ((p[24]-'0')*10+p[25]-'0')*60;
1096 	if(p[21] == '-')
1097 		delta = -delta;
1098 
1099 	t -= delta;
1100 	return t;
1101 }
1102 
1103 static uint
1104 parsenumber(Sx *v)
1105 {
1106 	if(v->type != SxNumber)
1107 		return 0;
1108 	return v->number;
1109 }
1110 
1111 static void
1112 hash(DigestState *ds, char *tag, char *val)
1113 {
1114 	if(val == nil)
1115 		val = "";
1116 	md5((uchar*)tag, strlen(tag)+1, nil, ds);
1117 	md5((uchar*)val, strlen(val)+1, nil, ds);
1118 }
1119 
1120 static Hdr*
1121 parseenvelope(Sx *v)
1122 {
1123 	Hdr *hdr;
1124 	uchar digest[16];
1125 	DigestState ds;
1126 
1127 	if(v->type != SxList || !sxmatch(v, "SSLLLLLLSS")){
1128 		warn("bad envelope: %$", v);
1129 		return nil;
1130 	}
1131 
1132 	hdr = emalloc(sizeof *hdr);
1133 	hdr->date = nstring(v->sx[0]);
1134 	hdr->subject = unrfc2047(nstring(v->sx[1]));
1135 	hdr->from = copyaddrs(v->sx[2]);
1136 	hdr->sender = copyaddrs(v->sx[3]);
1137 	hdr->replyto = copyaddrs(v->sx[4]);
1138 	hdr->to = copyaddrs(v->sx[5]);
1139 	hdr->cc = copyaddrs(v->sx[6]);
1140 	hdr->bcc = copyaddrs(v->sx[7]);
1141 	hdr->inreplyto = unrfc2047(nstring(v->sx[8]));
1142 	hdr->messageid = unrfc2047(nstring(v->sx[9]));
1143 
1144 	memset(&ds, 0, sizeof ds);
1145 	hash(&ds, "date", hdr->date);
1146 	hash(&ds, "subject", hdr->subject);
1147 	hash(&ds, "from", hdr->from);
1148 	hash(&ds, "sender", hdr->sender);
1149 	hash(&ds, "replyto", hdr->replyto);
1150 	hash(&ds, "to", hdr->to);
1151 	hash(&ds, "cc", hdr->cc);
1152 	hash(&ds, "bcc", hdr->bcc);
1153 	hash(&ds, "inreplyto", hdr->inreplyto);
1154 	hash(&ds, "messageid", hdr->messageid);
1155 	md5(0, 0, digest, &ds);
1156 	hdr->digest = esmprint("%.16H", digest);
1157 
1158 	return hdr;
1159 }
1160 
1161 static void
1162 strlwr(char *s)
1163 {
1164 	char *t;
1165 
1166 	if(s == nil)
1167 		return;
1168 	for(t=s; *t; t++)
1169 		if('A' <= *t && *t <= 'Z')
1170 			*t += 'a' - 'A';
1171 }
1172 
1173 static void
1174 nocr(char *s)
1175 {
1176 	char *r, *w;
1177 
1178 	if(s == nil)
1179 		return;
1180 	for(r=w=s; *r; r++)
1181 		if(*r != '\r')
1182 			*w++ = *r;
1183 	*w = 0;
1184 }
1185 
1186 /*
1187  * substitute all occurrences of a with b in s.
1188  */
1189 static char*
1190 gsub(char *s, char *a, char *b)
1191 {
1192 	char *p, *t, *w, *last;
1193 	int n;
1194 
1195 	n = 0;
1196 	for(p=s; (p=strstr(p, a)) != nil; p+=strlen(a))
1197 		n++;
1198 	if(n == 0)
1199 		return s;
1200 	t = emalloc(strlen(s)+n*strlen(b)+1);
1201 	w = t;
1202 	for(p=s; last=p, (p=strstr(p, a)) != nil; p+=strlen(a)){
1203 		memmove(w, last, p-last);
1204 		w += p-last;
1205 		memmove(w, b, strlen(b));
1206 		w += strlen(b);
1207 	}
1208 	strcpy(w, last);
1209 	free(s);
1210 	return t;
1211 }
1212 
1213 /*
1214  * Table-driven IMAP "unexpected response" parser.
1215  * All the interesting data is in the unexpected responses.
1216  */
1217 static void xlist(Imap*, Sx*);
1218 static void xrecent(Imap*, Sx*);
1219 static void xexists(Imap*, Sx*);
1220 static void xok(Imap*, Sx*);
1221 static void xflags(Imap*, Sx*);
1222 static void xfetch(Imap*, Sx*);
1223 static void xexpunge(Imap*, Sx*);
1224 static void xbye(Imap*, Sx*);
1225 static void xsearch(Imap*, Sx*);
1226 
1227 static struct {
1228 	int		num;
1229 	char		*name;
1230 	char		*fmt;
1231 	void		(*fn)(Imap*, Sx*);
1232 } unextab[] = {
1233 	0,	"BYE",		nil,			xbye,
1234 	0,	"FLAGS",		"AAL",		xflags,
1235 	0,	"LIST",		"AALSS",		xlist,
1236 	0,	"OK",		nil,			xok,
1237 	0,	"SEARCH",	"AAN*",		xsearch,
1238 
1239 	1,	"EXISTS",		"ANA",		xexists,
1240 	1,	"EXPUNGE",	"ANA",		xexpunge,
1241 	1,	"FETCH",		"ANAL",		xfetch,
1242 	1,	"RECENT",	"ANA",		xrecent
1243 };
1244 
1245 static void
1246 unexpected(Imap *z, Sx *sx)
1247 {
1248 	int i, num;
1249 	char *name;
1250 
1251 	if(sx->nsx >= 3 && sx->sx[1]->type == SxNumber && sx->sx[2]->type == SxAtom){
1252 		num = 1;
1253 		name = sx->sx[2]->data;
1254 	}else if(sx->nsx >= 2 && sx->sx[1]->type == SxAtom){
1255 		num = 0;
1256 		name = sx->sx[1]->data;
1257 	}else
1258 		return;
1259 
1260 	for(i=0; i<nelem(unextab); i++){
1261 		if(unextab[i].num == num && cistrcmp(unextab[i].name, name) == 0){
1262 			if(unextab[i].fmt && !sxmatch(sx, unextab[i].fmt)){
1263 				warn("malformed %s: %$", name, sx);
1264 				continue;
1265 			}
1266 			unextab[i].fn(z, sx);
1267 		}
1268 	}
1269 }
1270 
1271 static int
1272 alldollars(char *s)
1273 {
1274 	for(; *s; s++)
1275 		if(*s != '$')
1276 			return 0;
1277 	return 1;
1278 }
1279 
1280 static void
1281 xlist(Imap *z, Sx *sx)
1282 {
1283 	int inbox;
1284 	char *s, *t;
1285 	Box *box;
1286 
1287 	s = estrdup(sx->sx[4]->data);
1288 	if(sx->sx[3]->data && strcmp(sx->sx[3]->data, "/") != 0){
1289 		s = gsub(s, "/", "_");
1290 		s = gsub(s, sx->sx[3]->data, "/");
1291 	}
1292 
1293 	/*
1294 	 * INBOX is the special imap name for the main mailbox.
1295 	 * All other mailbox names have the root prefix removed, if applicable.
1296 	 */
1297 	inbox = 0;
1298 	if(cistrcmp(s, "INBOX") == 0){
1299 		inbox = 1;
1300 		free(s);
1301 		s = estrdup("mbox");
1302 	} else if(z->root && strstr(s, z->root) == s) {
1303 		t = estrdup(s+strlen(z->root));
1304 		free(s);
1305 		s = t;
1306 	}
1307 
1308 	/*
1309 	 * Plan 9 calls the main mailbox mbox.
1310 	 * Rename any existing mbox by appending a $.
1311 	 */
1312 	if(!inbox && strncmp(s, "mbox", 4) == 0 && alldollars(s+4)){
1313 		t = emalloc(strlen(s)+2);
1314 		strcpy(t, s);
1315 		strcat(t, "$");
1316 		free(s);
1317 		s = t;
1318 	}
1319 
1320 	box = boxcreate(s);
1321 	if(box == nil)
1322 		return;
1323 	box->imapname = estrdup(sx->sx[4]->data);
1324 	if(inbox)
1325 		z->inbox = box;
1326 	box->mark = 0;
1327 	box->flags = parseflags(sx->sx[2]);
1328 }
1329 
1330 static void
1331 xrecent(Imap *z, Sx *sx)
1332 {
1333 	if(z->box)
1334 		z->box->recent = sx->sx[1]->number;
1335 }
1336 
1337 static void
1338 xexists(Imap *z, Sx *sx)
1339 {
1340 	if(z->box){
1341 		z->box->exists = sx->sx[1]->number;
1342 		if(z->box->exists < z->box->maxseen)
1343 			z->box->maxseen = z->box->exists;
1344 	}
1345 }
1346 
1347 static void
1348 xflags(Imap *z, Sx *sx)
1349 {
1350 	USED(z);
1351 	USED(sx);
1352 	/*
1353 	 * This response contains in sx->sx[2] the list of flags
1354 	 * that can be validly attached to messages in z->box.
1355 	 * We don't have any use for this list, since we
1356 	 * use only the standard flags.
1357 	 */
1358 }
1359 
1360 static void
1361 xbye(Imap *z, Sx *sx)
1362 {
1363 	USED(sx);
1364 	close(z->fd);
1365 	z->fd = -1;
1366 	z->connected = 0;
1367 }
1368 
1369 static void
1370 xexpunge(Imap *z, Sx *sx)
1371 {
1372 	int i, n;
1373 	Box *b;
1374 
1375 	if((b=z->box) == nil)
1376 		return;
1377 	n = sx->sx[1]->number;
1378 	for(i=0; i<b->nmsg; i++){
1379 		if(b->msg[i]->imapid == n){
1380 			msgplumb(b->msg[i], 1);
1381 			msgfree(b->msg[i]);
1382 			b->nmsg--;
1383 			memmove(b->msg+i, b->msg+i+1, (b->nmsg-i)*sizeof b->msg[0]);
1384 			i--;
1385 			b->maxseen--;
1386 			b->exists--;
1387 			continue;
1388 		}
1389 		if(b->msg[i]->imapid > n)
1390 			b->msg[i]->imapid--;
1391 		b->msg[i]->ix = i;
1392 	}
1393 }
1394 
1395 static void
1396 xsearch(Imap *z, Sx *sx)
1397 {
1398 	int i;
1399 
1400 	free(z->uid);
1401 	z->uid = emalloc((sx->nsx-2)*sizeof z->uid[0]);
1402 	z->nuid = sx->nsx-2;
1403 	for(i=0; i<z->nuid; i++)
1404 		z->uid[i] = sx->sx[i+2]->number;
1405 }
1406 
1407 /*
1408  * Table-driven FETCH message info parser.
1409  */
1410 static void xmsgflags(Msg*, Sx*, Sx*);
1411 static void xmsgdate(Msg*, Sx*, Sx*);
1412 static void xmsgrfc822size(Msg*, Sx*, Sx*);
1413 static void xmsgenvelope(Msg*, Sx*, Sx*);
1414 static void xmsgbody(Msg*, Sx*, Sx*);
1415 static void xmsgbodydata(Msg*, Sx*, Sx*);
1416 
1417 static struct {
1418 	char *name;
1419 	void (*fn)(Msg*, Sx*, Sx*);
1420 } msgtab[] = {
1421 	"FLAGS", xmsgflags,
1422 	"INTERNALDATE", xmsgdate,
1423 	"RFC822.SIZE", xmsgrfc822size,
1424 	"ENVELOPE", xmsgenvelope,
1425 	"BODY", xmsgbody,
1426 	"BODY[", xmsgbodydata
1427 };
1428 
1429 static void
1430 xfetch(Imap *z, Sx *sx)
1431 {
1432 	int i, j, n, uid;
1433 	Msg *msg;
1434 
1435 	if(z->box == nil){
1436 		warn("FETCH but no open box: %$", sx);
1437 		return;
1438 	}
1439 
1440 	/* * 152 FETCH (UID 185 FLAGS () ...) */
1441 	if(sx->sx[3]->nsx%2){
1442 		warn("malformed FETCH: %$", sx);
1443 		return;
1444 	}
1445 
1446 	n = sx->sx[1]->number;
1447 	sx = sx->sx[3];
1448 	for(i=0; i<sx->nsx; i+=2){
1449 		if(isatom(sx->sx[i], "UID")){
1450 			if(sx->sx[i+1]->type == SxNumber){
1451 				uid = sx->sx[i+1]->number;
1452 				goto haveuid;
1453 			}
1454 		}
1455 	}
1456 /* This happens: too bad.
1457 	warn("FETCH without UID: %$", sx);
1458 */
1459 	return;
1460 
1461 haveuid:
1462 	msg = msgbyimapuid(z->box, uid, 1);
1463 	if(msg->imapid && msg->imapid != n)
1464 		warn("msg id mismatch: want %d have %d", msg->id, n);
1465 	msg->imapid = n;
1466 	for(i=0; i<sx->nsx; i+=2){
1467 		for(j=0; j<nelem(msgtab); j++)
1468 			if(isatom(sx->sx[i], msgtab[j].name))
1469 				msgtab[j].fn(msg, sx->sx[i], sx->sx[i+1]);
1470 	}
1471 	msgplumb(msg, 0);
1472 }
1473 
1474 static void
1475 xmsgflags(Msg *msg, Sx *k, Sx *v)
1476 {
1477 	USED(k);
1478 	msg->flags = parseflags(v);
1479 }
1480 
1481 static void
1482 xmsgdate(Msg *msg, Sx *k, Sx *v)
1483 {
1484 	USED(k);
1485 	msg->date = parsedate(v);
1486 }
1487 
1488 static void
1489 xmsgrfc822size(Msg *msg, Sx *k, Sx *v)
1490 {
1491 	USED(k);
1492 	msg->size = parsenumber(v);
1493 }
1494 
1495 static char*
1496 nstring(Sx *v)
1497 {
1498 	char *p;
1499 
1500 	if(isnil(v))
1501 		return estrdup("");
1502 	p = v->data;
1503 	v->data = nil;
1504 	return p;
1505 }
1506 
1507 static char*
1508 copyaddrs(Sx *v)
1509 {
1510 	char *s, *sep;
1511 	char *name, *email, *host, *mbox;
1512 	int i;
1513 	Fmt fmt;
1514 
1515 	if(v->nsx == 0)
1516 		return nil;
1517 
1518 	fmtstrinit(&fmt);
1519 	sep = "";
1520 	for(i=0; i<v->nsx; i++){
1521 		if(!sxmatch(v->sx[i], "SSSS"))
1522 			warn("bad address: %$", v->sx[i]);
1523 		name = unrfc2047(nstring(v->sx[i]->sx[0]));
1524 		/* ignore sx[1] - route */
1525 		mbox = unrfc2047(nstring(v->sx[i]->sx[2]));
1526 		host = unrfc2047(nstring(v->sx[i]->sx[3]));
1527 		if(mbox == nil || host == nil){	/* rfc822 group syntax */
1528 			free(name);
1529 			free(mbox);
1530 			free(host);
1531 			continue;
1532 		}
1533 		email = esmprint("%s@%s", mbox, host);
1534 		free(mbox);
1535 		free(host);
1536 		fmtprint(&fmt, "%s%q %q", sep, name ? name : "", email ? email : "");
1537 		free(name);
1538 		free(email);
1539 		sep = " ";
1540 	}
1541 	s = fmtstrflush(&fmt);
1542 	if(s == nil)
1543 		sysfatal("out of memory");
1544 	return s;
1545 }
1546 
1547 static void
1548 xmsgenvelope(Msg *msg, Sx *k, Sx *v)
1549 {
1550 	USED(k);
1551 	hdrfree(msg->part[0]->hdr);
1552 	msg->part[0]->hdr = parseenvelope(v);
1553 }
1554 
1555 static struct {
1556 	char *name;
1557 	int offset;
1558 } paramtab[] = {
1559 	"charset",	offsetof(Part, charset),
1560 	"name",		offsetof(Part, filename)
1561 };
1562 
1563 static void
1564 parseparams(Part *part, Sx *v)
1565 {
1566 	int i, j;
1567 	char *s, *t, **p;
1568 
1569 	if(isnil(v))
1570 		return;
1571 	if(v->nsx%2){
1572 		warn("bad message params: %$", v);
1573 		return;
1574 	}
1575 	for(i=0; i<v->nsx; i+=2){
1576 		s = nstring(v->sx[i]);
1577 		t = nstring(v->sx[i+1]);
1578 		for(j=0; j<nelem(paramtab); j++){
1579 			if(cistrcmp(paramtab[j].name, s) == 0){
1580 				p = (char**)((char*)part+paramtab[j].offset);
1581 				free(*p);
1582 				*p = t;
1583 				t = nil;
1584 				break;
1585 			}
1586 		}
1587 		free(s);
1588 		free(t);
1589 	}
1590 }
1591 
1592 static void
1593 parsestructure(Part *part, Sx *v)
1594 {
1595 	int i;
1596 	char *s, *t;
1597 
1598 	if(isnil(v))
1599 		return;
1600 	if(v->type != SxList){
1601 	bad:
1602 		warn("bad structure: %$", v);
1603 		return;
1604 	}
1605 	if(islist(v->sx[0])){
1606 		/* multipart */
1607 		for(i=0; i<v->nsx && islist(v->sx[i]); i++)
1608 			parsestructure(partcreate(part->msg, part), v->sx[i]);
1609 		free(part->type);
1610 		if(i != v->nsx-1 || !isstring(v->sx[i])){
1611 			warn("bad multipart structure: %$", v);
1612 			part->type = estrdup("multipart/mixed");
1613 			return;
1614 		}
1615 		s = nstring(v->sx[i]);
1616 		strlwr(s);
1617 		part->type = esmprint("multipart/%s", s);
1618 		free(s);
1619 		return;
1620 	}
1621 	/* single part */
1622 	if(!isstring(v->sx[0]) || v->nsx < 2)
1623 		goto bad;
1624 	s = nstring(v->sx[0]);
1625 	t = nstring(v->sx[1]);
1626 	strlwr(s);
1627 	strlwr(t);
1628 	free(part->type);
1629 	part->type = esmprint("%s/%s", s, t);
1630 	if(v->nsx < 7 || !islist(v->sx[2]) || !isstring(v->sx[3])
1631 	|| !isstring(v->sx[4]) || !isstring(v->sx[5]) || !isnumber(v->sx[6]))
1632 		goto bad;
1633 	parseparams(part, v->sx[2]);
1634 	part->idstr = nstring(v->sx[3]);
1635 	part->desc = nstring(v->sx[4]);
1636 	part->encoding = nstring(v->sx[5]);
1637 	part->size = v->sx[6]->number;
1638 	if(strcmp(s, "message") == 0 && strcmp(t, "rfc822") == 0){
1639 		if(v->nsx < 10 || !islist(v->sx[7]) || !islist(v->sx[8]) || !isnumber(v->sx[9]))
1640 			goto bad;
1641 		part->hdr = parseenvelope(v->sx[7]);
1642 		parsestructure(partcreate(part->msg, part), v->sx[8]);
1643 		part->lines = v->sx[9]->number;
1644 	}
1645 	if(strcmp(s, "text") == 0){
1646 		if(v->nsx < 8 || !isnumber(v->sx[7]))
1647 			goto bad;
1648 		part->lines = v->sx[7]->number;
1649 	}
1650 }
1651 
1652 static void
1653 xmsgbody(Msg *msg, Sx *k, Sx *v)
1654 {
1655 	USED(k);
1656 	if(v->type != SxList){
1657 		warn("bad body: %$", v);
1658 		return;
1659 	}
1660 	/*
1661 	 * To follow the structure exactly we should
1662 	 * be doing this to partcreate(msg, msg->part[0]),
1663 	 * and we should leave msg->part[0] with type message/rfc822,
1664 	 * but the extra layer is redundant - what else would be in a mailbox?
1665 	 */
1666 	parsestructure(msg->part[0], v);
1667 	if(msg->box->maxseen < msg->imapid)
1668 		msg->box->maxseen = msg->imapid;
1669 	if(msg->imapuid >= msg->box->uidnext)
1670 		msg->box->uidnext = msg->imapuid+1;
1671 }
1672 
1673 static void
1674 xmsgbodydata(Msg *msg, Sx *k, Sx *v)
1675 {
1676 	int i;
1677 	char *name, *p;
1678 	Part *part;
1679 
1680 	name = k->data;
1681 	name += 5;	/* body[ */
1682 	p = strchr(name, ']');
1683 	if(p)
1684 		*p = 0;
1685 
1686 	/* now name is something like 1 or 3.2.MIME - walk down parts from root */
1687 	part = msg->part[0];
1688 
1689 
1690 	while('1' <= name[0] && name[0] <= '9'){
1691 		i = strtol(name, &p, 10);
1692 		if(*p == '.')
1693 			p++;
1694 		else if(*p != 0){
1695 			warn("bad body name: %$", k);
1696 			return;
1697 		}
1698 		if((part = subpart(part, i-1)) == nil){
1699 			warn("unknown body part: %$", k);
1700 			return;
1701 		}
1702 		name = p;
1703 	}
1704 
1705 
1706 	if(cistrcmp(name, "") == 0){
1707 		free(part->raw);
1708 		part->raw = nstring(v);
1709 		nocr(part->raw);
1710 	}else if(cistrcmp(name, "HEADER") == 0){
1711 		free(part->rawheader);
1712 		part->rawheader = nstring(v);
1713 		nocr(part->rawheader);
1714 	}else if(cistrcmp(name, "MIME") == 0){
1715 		free(part->mimeheader);
1716 		part->mimeheader = nstring(v);
1717 		nocr(part->mimeheader);
1718 	}else if(cistrcmp(name, "TEXT") == 0){
1719 		free(part->rawbody);
1720 		part->rawbody = nstring(v);
1721 		nocr(part->rawbody);
1722 	}
1723 }
1724 
1725 /*
1726  * Table-driven OK info parser.
1727  */
1728 static void xokuidvalidity(Imap*, Sx*);
1729 static void xokpermflags(Imap*, Sx*);
1730 static void xokunseen(Imap*, Sx*);
1731 static void xokreadwrite(Imap*, Sx*);
1732 static void xokreadonly(Imap*, Sx*);
1733 
1734 struct {
1735 	char *name;
1736 	char fmt;
1737 	void (*fn)(Imap*, Sx*);
1738 } oktab[] = {
1739 	"UIDVALIDITY", 'N',	xokuidvalidity,
1740 	"PERMANENTFLAGS", 'L',	xokpermflags,
1741 	"UNSEEN", 'N',	xokunseen,
1742 	"READ-WRITE", 0,	xokreadwrite,
1743 	"READ-ONLY",	0, xokreadonly
1744 };
1745 
1746 static void
1747 xok(Imap *z, Sx *sx)
1748 {
1749 	int i;
1750 	char *name;
1751 	Sx *arg;
1752 
1753 	if(sx->nsx >= 4 && sx->sx[2]->type == SxAtom && sx->sx[2]->data[0] == '['){
1754 		if(sx->sx[3]->type == SxAtom && sx->sx[3]->data[0] == ']')
1755 			arg = nil;
1756 		else if(sx->sx[4]->type == SxAtom && sx->sx[4]->data[0] == ']')
1757 			arg = sx->sx[3];
1758 		else{
1759 			warn("cannot parse OK: %$", sx);
1760 			return;
1761 		}
1762 		name = sx->sx[2]->data+1;
1763 		for(i=0; i<nelem(oktab); i++){
1764 			if(cistrcmp(name, oktab[i].name) == 0){
1765 				if(oktab[i].fmt && (arg==nil || arg->type != fmttype(oktab[i].fmt))){
1766 					warn("malformed %s: %$", name, arg);
1767 					continue;
1768 				}
1769 				oktab[i].fn(z, arg);
1770 			}
1771 		}
1772 	}
1773 }
1774 
1775 static void
1776 xokuidvalidity(Imap *z, Sx *sx)
1777 {
1778 	int i;
1779 	Box *b;
1780 
1781 	if((b=z->box) == nil)
1782 		return;
1783 	if(b->validity != sx->number){
1784 		b->validity = sx->number;
1785 		b->uidnext = 1;
1786 		for(i=0; i<b->nmsg; i++)
1787 			msgfree(b->msg[i]);
1788 		free(b->msg);
1789 		b->msg = nil;
1790 		b->nmsg = 0;
1791 	}
1792 }
1793 
1794 static void
1795 xokpermflags(Imap *z, Sx *sx)
1796 {
1797 	USED(z);
1798 	USED(sx);
1799 /*	z->permflags = parseflags(sx); */
1800 }
1801 
1802 static void
1803 xokunseen(Imap *z, Sx *sx)
1804 {
1805 	USED(z);
1806 	USED(sx);
1807 /*	z->unseen = sx->number; */
1808 }
1809 
1810 static void
1811 xokreadwrite(Imap *z, Sx *sx)
1812 {
1813 	USED(z);
1814 	USED(sx);
1815 /*	z->boxmode = ORDWR; */
1816 }
1817 
1818 static void
1819 xokreadonly(Imap *z, Sx *sx)
1820 {
1821 	USED(z);
1822 	USED(sx);
1823 /*	z->boxmode = OREAD; */
1824 }