op public repos

Blob

Date:: Sat Apr 1 19:24:03 2006 UTC
Message:: Use gcc -ansi -pedantic in 9c. Fix many non-C89-isms.
Actions:: History | Blame | Raw File
1 #include "common.h"
2 #include <ctype.h>
3 #include <plumb.h>
4 #include <libsec.h>
5 #include <auth.h>
6 #include "dat.h"
7 
8 #pragma varargck argpos imap4cmd 2
9 #pragma varargck	type	"Z"	char*
10 
11 int	doublequote(Fmt*);
12 int	pipeline = 1;
13 
14 /* static char Eio[] = "i/o error"; jpc */
15 
16 typedef struct Imap Imap;
17 struct Imap {
18 	char *freep;	/* free this to free the strings below */
19 
20 	char *host;
21 	char *user;
22 	char *mbox;
23 
24 	int mustssl;
25 	int refreshtime;
26 	int debug;
27 
28 	ulong tag;
29 	ulong validity;
30 	int nmsg;
31 	int size;
32 	char *base;
33 	char *data;
34 
35 	vlong *uid;
36 	int nuid;
37 	int muid;
38 
39 	Thumbprint *thumb;
40 
41 	/* open network connection */
42 	Biobuf bin;
43 	Biobuf bout;
44 	int fd;
45 };
46 
47 static char*
48 removecr(char *s)
49 {
50 	char *r, *w;
51 
52 	for(r=w=s; *r; r++)
53 		if(*r != '\r')
54 			*w++ = *r;
55 	*w = '\0';
56 	return s;
57 }
58 
59 /* */
60 /* send imap4 command */
61 /* */
62 static void
63 imap4cmd(Imap *imap, char *fmt, ...)
64 {
65 	char buf[128], *p;
66 	va_list va;
67 
68 	va_start(va, fmt);
69 	p = buf+sprint(buf, "9X%lud ", imap->tag);
70 	vseprint(p, buf+sizeof(buf), fmt, va);
71 	va_end(va);
72 
73 	p = buf+strlen(buf);
74 	if(p > (buf+sizeof(buf)-3))
75 		sysfatal("imap4 command too long");
76 
77 	if(imap->debug)
78 		fprint(2, "-> %s\n", buf);
79 	strcpy(p, "\r\n");
80 	Bwrite(&imap->bout, buf, strlen(buf));
81 	Bflush(&imap->bout);
82 }
83 
84 enum {
85 	OK,
86 	NO,
87 	BAD,
88 	BYE,
89 	EXISTS,
90 	STATUS,
91 	FETCH,
92 	UNKNOWN
93 };
94 
95 static char *verblist[] = {
96 [OK]		"OK",
97 [NO]		"NO",
98 [BAD]	"BAD",
99 [BYE]	"BYE",
100 [EXISTS]	"EXISTS",
101 [STATUS]	"STATUS",
102 [FETCH]	"FETCH"
103 };
104 
105 static int
106 verbcode(char *verb)
107 {
108 	int i;
109 	char *q;
110 
111 	if(q = strchr(verb, ' '))
112 		*q = '\0';
113 
114 	for(i=0; i<nelem(verblist); i++)
115 		if(verblist[i] && strcmp(verblist[i], verb)==0){
116 			if(q)
117 				*q = ' ';
118 			return i;
119 		}
120 	if(q)
121 		*q = ' ';
122 	return UNKNOWN;
123 }
124 
125 static void
126 strupr(char *s)
127 {
128 	for(; *s; s++)
129 		if('a' <= *s && *s <= 'z')
130 			*s += 'A'-'a';
131 }
132 
133 static void
134 imapgrow(Imap *imap, int n)
135 {
136 	int i;
137 
138 	if(imap->data == nil){
139 		imap->base = emalloc(n+1);	
140 		imap->data = imap->base;
141 		imap->size = n+1;
142 	}
143 	if(n >= imap->size){
144 		/* friggin microsoft - reallocate */
145 		i = imap->data - imap->base;
146 		imap->base = erealloc(imap->base, i+n+1);
147 		imap->data = imap->base + i;
148 		imap->size = n+1;
149 	}
150 }
151 
152 
153 /* */
154 /* get imap4 response line.  there might be various  */
155 /* data or other informational lines mixed in. */
156 /* */
157 static char*
158 imap4resp(Imap *imap)
159 {
160 	char *line, *p, *ep, *op, *q, *r, *en, *verb;
161 	int i, n;
162 	static char error[256];
163 
164 	while(p = Brdline(&imap->bin, '\n')){
165 		ep = p+Blinelen(&imap->bin);
166 		while(ep > p && (ep[-1]=='\n' || ep[-1]=='\r'))
167 			*--ep = '\0';
168 		
169 		if(imap->debug)
170 			fprint(2, "<- %s\n", p);
171 		strupr(p);
172 
173 		switch(p[0]){
174 		case '+':
175 			if(imap->tag == 0)
176 				fprint(2, "unexpected: %s\n", p);
177 			break;
178 
179 		/* ``unsolicited'' information; everything happens here. */
180 		case '*':
181 			if(p[1]!=' ')
182 				continue;
183 			p += 2;
184 			line = p;
185 			n = strtol(p, &p, 10);
186 			if(*p==' ')
187 				p++;
188 			verb = p;
189 			
190 			if(p = strchr(verb, ' '))
191 				p++;
192 			else
193 				p = verb+strlen(verb);
194 
195 			switch(verbcode(verb)){
196 			case OK:
197 			case NO:
198 			case BAD:
199 				/* human readable text at p; */
200 				break;
201 			case BYE:
202 				/* early disconnect */
203 				/* human readable text at p; */
204 				break;
205 
206 			/* * 32 EXISTS */
207 			case EXISTS:
208 				imap->nmsg = n;
209 				break;
210 
211 			/* * STATUS Inbox (MESSAGES 2 UIDVALIDITY 960164964) */
212 			case STATUS:
213 				if(q = strstr(p, "MESSAGES"))
214 					imap->nmsg = atoi(q+8);
215 				if(q = strstr(p, "UIDVALIDITY"))
216 					imap->validity = strtoul(q+11, 0, 10);
217 				break;
218 
219 			case FETCH:
220 				/* * 1 FETCH (uid 8889 RFC822.SIZE 3031 body[] {3031} */
221 				/* <3031 bytes of data> */
222  				/* ) */
223 				if(strstr(p, "RFC822.SIZE") && strstr(p, "BODY[]")){
224 					if((q = strchr(p, '{')) 
225 					&& (n=strtol(q+1, &en, 0), *en=='}')){
226 						if(imap->data == nil || n >= imap->size)
227 							imapgrow(imap, n);
228 						if((i = Bread(&imap->bin, imap->data, n)) != n){
229 							snprint(error, sizeof error,
230 								"short read %d != %d: %r\n",
231 								i, n);
232 							return error;
233 						}
234 						if(imap->debug)
235 							fprint(2, "<- read %d bytes\n", n);
236 						imap->data[n] = '\0';
237 						if(imap->debug)
238 							fprint(2, "<- %s\n", imap->data);
239 						imap->data += n;
240 						imap->size -= n;
241 						p = Brdline(&imap->bin, '\n');
242 						if(imap->debug)
243 							fprint(2, "<- ignoring %.*s\n",
244 								Blinelen(&imap->bin), p);
245 					}else if((q = strchr(p, '"')) && (r = strchr(q+1, '"'))){
246 						*r = '\0';
247 						q++;
248 						n = r-q;
249 						if(imap->data == nil || n >= imap->size)
250 							imapgrow(imap, n);
251 						memmove(imap->data, q, n);
252 						imap->data[n] = '\0';
253 						imap->data += n;
254 						imap->size -= n;
255 					}else
256 						return "confused about FETCH response";
257 					break;
258 				}
259 
260 				/* * 1 FETCH (UID 1 RFC822.SIZE 511) */
261 				if(q=strstr(p, "RFC822.SIZE")){
262 					imap->size = atoi(q+11);
263 					break;
264 				}
265 
266 				/* * 1 FETCH (UID 1 RFC822.HEADER {496} */
267 				/* <496 bytes of data> */
268  				/* ) */
269 				/* * 1 FETCH (UID 1 RFC822.HEADER "data") */
270 				if(strstr(p, "RFC822.HEADER") || strstr(p, "RFC822.TEXT")){
271 					if((q = strchr(p, '{')) 
272 					&& (n=strtol(q+1, &en, 0), *en=='}')){
273 						if(imap->data == nil || n >= imap->size)
274 							imapgrow(imap, n);
275 						if((i = Bread(&imap->bin, imap->data, n)) != n){
276 							snprint(error, sizeof error,
277 								"short read %d != %d: %r\n",
278 								i, n);
279 							return error;
280 						}
281 						if(imap->debug)
282 							fprint(2, "<- read %d bytes\n", n);
283 						imap->data[n] = '\0';
284 						if(imap->debug)
285 							fprint(2, "<- %s\n", imap->data);
286 						imap->data += n;
287 						imap->size -= n;
288 						p = Brdline(&imap->bin, '\n');
289 						if(imap->debug)
290 							fprint(2, "<- ignoring %.*s\n",
291 								Blinelen(&imap->bin), p);
292 					}else if((q = strchr(p, '"')) && (r = strchr(q+1, '"'))){
293 						*r = '\0';
294 						q++;
295 						n = r-q;
296 						if(imap->data == nil || n >= imap->size)
297 							imapgrow(imap, n);
298 						memmove(imap->data, q, n);
299 						imap->data[n] = '\0';
300 						imap->data += n;
301 						imap->size -= n;
302 					}else
303 						return "confused about FETCH response";
304 					break;
305 				}
306 
307 				/* * 1 FETCH (UID 1) */
308 				/* * 2 FETCH (UID 6) */
309 				if(q = strstr(p, "UID")){
310 					if(imap->nuid < imap->muid)
311 						imap->uid[imap->nuid++] = ((vlong)imap->validity<<32)|strtoul(q+3, nil, 10);
312 					break;
313 				}
314 			}
315 
316 			if(imap->tag == 0)
317 				return line;
318 			break;
319 
320 		case '9':		/* response to our message */
321 			op = p;
322 			if(p[1]=='X' && strtoul(p+2, &p, 10)==imap->tag){
323 				while(*p==' ')
324 					p++;
325 				imap->tag++;
326 				return p;
327 			}
328 			fprint(2, "expected %lud; got %s\n", imap->tag, op);
329 			break;
330 
331 		default:
332 			if(imap->debug || *p)
333 				fprint(2, "unexpected line: %s\n", p);
334 		}
335 	}
336 	snprint(error, sizeof error, "i/o error: %r\n");
337 	return error;
338 }
339 
340 static int
341 isokay(char *resp)
342 {
343 	return strncmp(resp, "OK", 2)==0;
344 }
345 
346 /* */
347 /* log in to IMAP4 server, select mailbox, no SSL at the moment */
348 /* */
349 static char*
350 imap4login(Imap *imap)
351 {
352 	char *s;
353 	UserPasswd *up;
354 
355 	imap->tag = 0;
356 	s = imap4resp(imap);
357 	if(!isokay(s))
358 		return "error in initial IMAP handshake";
359 
360 	if(imap->user != nil)
361 		up = auth_getuserpasswd(auth_getkey, "proto=pass role=client service=imap server=%q user=%q", imap->host, imap->user);
362 	else
363 		up = auth_getuserpasswd(auth_getkey, "proto=pass role=client service=imap server=%q", imap->host);
364 	if(up == nil)
365 		return "cannot find IMAP password";
366 
367 	imap->tag = 1;
368 	imap4cmd(imap, "LOGIN %Z %Z", up->user, up->passwd);
369 	free(up);
370 	if(!isokay(s = imap4resp(imap)))
371 		return s;
372 
373 	imap4cmd(imap, "SELECT %Z", imap->mbox);
374 	if(!isokay(s = imap4resp(imap)))
375 		return s;
376 
377 	return nil;
378 }
379 
380 /* */
381 /* push tls onto a connection */
382 /* */
383 int
384 mypushtls(int fd)
385 {
386 	int p[2];
387 	char buf[10];
388 
389 	if(pipe(p) < 0)
390 		return -1;
391 
392 	switch(fork()){
393 	case -1:
394 		close(p[0]);
395 		close(p[1]);
396 		return -1;
397 	case 0:
398 		close(p[1]);
399 		dup(p[0], 0);
400 		dup(p[0], 1);
401 		sprint(buf, "/fd/%d", fd);
402 		execl("/bin/tlsrelay", "tlsrelay", "-f", buf, nil);
403 		_exits(nil);
404 	default:
405 		break;
406 	}
407 	close(fd);
408 	close(p[0]);
409 	return p[1];
410 }
411 
412 /* */
413 /* dial and handshake with the imap server */
414 /* */
415 static char*
416 imap4dial(Imap *imap)
417 {
418 	char *err, *port;
419 	uchar digest[SHA1dlen];
420 	int sfd;
421 	TLSconn conn;
422 
423 	if(imap->fd >= 0){
424 		imap4cmd(imap, "noop");
425 		if(isokay(imap4resp(imap)))
426 			return nil;
427 		close(imap->fd);
428 		imap->fd = -1;
429 	}
430 
431 	if(imap->mustssl)
432 		port = "imaps";
433 	else
434 		port = "imap";
435 
436 	if((imap->fd = dial(netmkaddr(imap->host, "net", port), 0, 0, 0)) < 0)
437 		return geterrstr();
438 
439 	if(imap->mustssl){
440 		memset(&conn, 0, sizeof conn);
441 		sfd = tlsClient(imap->fd, &conn);
442 		if(sfd < 0)
443 			sysfatal("tlsClient: %r");
444 		if(conn.cert==nil || conn.certlen <= 0)
445 			sysfatal("server did not provide TLS certificate");
446 		sha1(conn.cert, conn.certlen, digest, nil);
447 		if(!imap->thumb || !okThumbprint(digest, imap->thumb)){
448 			fmtinstall('H', encodefmt);
449 			sysfatal("server certificate %.*H not recognized", SHA1dlen, digest);
450 		}
451 		free(conn.cert);
452 		close(imap->fd);
453 		imap->fd = sfd;
454 
455 		if(imap->debug){
456 			char fn[128];
457 			int fd;
458 
459 			snprint(fn, sizeof fn, "%s/ctl", conn.dir);
460 			fd = open(fn, ORDWR);
461 			if(fd < 0)
462 				fprint(2, "opening ctl: %r\n");
463 			if(fprint(fd, "debug") < 0)
464 				fprint(2, "writing ctl: %r\n");
465 			close(fd);
466 		}
467 	}
468 	Binit(&imap->bin, imap->fd, OREAD);
469 	Binit(&imap->bout, imap->fd, OWRITE);
470 
471 	if(err = imap4login(imap)) {
472 		close(imap->fd);
473 		return err;
474 	}
475 
476 	return nil;
477 }
478 
479 /* */
480 /* close connection */
481 /* */
482 #if 0  /* jpc */
483 static void
484 imap4hangup(Imap *imap)
485 {
486 	imap4cmd(imap, "LOGOUT");
487 	imap4resp(imap);
488 	close(imap->fd);
489 }
490 #endif
491 
492 /* */
493 /* download a single message */
494 /* */
495 static char*
496 imap4fetch(Mailbox *mb, Message *m)
497 {
498 	int i;
499 	char *p, *s, sdigest[2*SHA1dlen+1];
500 	Imap *imap;
501 
502 	imap = mb->aux;
503 
504 	imap->size = 0;
505 
506 	if(!isokay(s = imap4resp(imap)))
507 		return s;
508 
509 	p = imap->base;
510 	if(p == nil)
511 		return "did not get message body";
512 
513 	removecr(p);
514 	free(m->start);
515 	m->start = p;
516 	m->end = p+strlen(p);
517 	m->bend = m->rbend = m->end;
518 	m->header = m->start;
519 
520 	imap->base = nil;
521 	imap->data = nil;
522 
523 	parse(m, 0, mb, 1);
524 
525 	/* digest headers */
526 	sha1((uchar*)m->start, m->end - m->start, m->digest, nil);
527 	for(i = 0; i < SHA1dlen; i++)
528 		sprint(sdigest+2*i, "%2.2ux", m->digest[i]);
529 	m->sdigest = s_copy(sdigest);
530 
531 	return nil;
532 }
533 
534 /* */
535 /* check for new messages on imap4 server */
536 /* download new messages, mark deleted messages */
537 /* */
538 static char*
539 imap4read(Imap *imap, Mailbox *mb, int doplumb)
540 {
541 	char *s;
542 	int i, ignore, nnew, t;
543 	Message *m, *next, **l;
544 
545 	imap4cmd(imap, "STATUS %Z (MESSAGES UIDVALIDITY)", imap->mbox);
546 	if(!isokay(s = imap4resp(imap)))
547 		return s;
548 
549 	imap->nuid = 0;
550 	imap->uid = erealloc(imap->uid, imap->nmsg*sizeof(imap->uid[0]));
551 	imap->muid = imap->nmsg;
552 
553 	if(imap->nmsg > 0){
554 		imap4cmd(imap, "UID FETCH 1:* UID");
555 		if(!isokay(s = imap4resp(imap)))
556 			return s;
557 	}
558 
559 	l = &mb->root->part;
560 	for(i=0; i<imap->nuid; i++){
561 		ignore = 0;
562 		while(*l != nil){
563 			if((*l)->imapuid == imap->uid[i]){
564 				ignore = 1;
565 				l = &(*l)->next;
566 				break;
567 			}else{
568 				/* old mail, we don't have it anymore */
569 				if(doplumb)
570 					mailplumb(mb, *l, 1);
571 				(*l)->inmbox = 0;
572 				(*l)->deleted = 1;
573 				l = &(*l)->next;
574 			}
575 		}
576 		if(ignore)
577 			continue;
578 
579 		/* new message */
580 		m = newmessage(mb->root);
581 		m->mallocd = 1;
582 		m->inmbox = 1;
583 		m->imapuid = imap->uid[i];
584 
585 		/* add to chain, will download soon */
586 		*l = m;
587 		l = &m->next;
588 	}
589 
590 	/* whatever is left at the end of the chain is gone */
591 	while(*l != nil){
592 		if(doplumb)
593 			mailplumb(mb, *l, 1);
594 		(*l)->inmbox = 0;
595 		(*l)->deleted = 1;
596 		l = &(*l)->next;
597 	}
598 
599 	/* download new messages */
600 	t = imap->tag;
601 	if(pipeline)
602 	switch(rfork(RFPROC|RFMEM)){
603 	case -1:
604 		sysfatal("rfork: %r");
605 	default:
606 		break;
607 	case 0:
608 		for(m = mb->root->part; m != nil; m = m->next){
609 			if(m->start != nil)
610 				continue;
611 			if(imap->debug)
612 				fprint(2, "9X%d UID FETCH %lud (UID RFC822.SIZE BODY[])\r\n",
613 					t, (ulong)m->imapuid);
614 			Bprint(&imap->bout, "9X%d UID FETCH %lud (UID RFC822.SIZE BODY[])\r\n",
615 				t++, (ulong)m->imapuid);
616 		}
617 		Bflush(&imap->bout);
618 		_exits(nil);
619 	}
620 
621 	nnew = 0;
622 	for(m=mb->root->part; m!=nil; m=next){
623 		next = m->next;
624 		if(m->start != nil)
625 			continue;
626 
627 		if(!pipeline){
628 			Bprint(&imap->bout, "9X%lud UID FETCH %lud (UID RFC822.SIZE BODY[])\r\n",
629 				(ulong)imap->tag, (ulong)m->imapuid);
630 			Bflush(&imap->bout);
631 		}
632 
633 		if(s = imap4fetch(mb, m)){
634 			/* message disappeared?  unchain */
635 			fprint(2, "download %lud: %s\n", (ulong)m->imapuid, s);
636 			delmessage(mb, m);
637 			mb->root->subname--;
638 			continue;
639 		}
640 		nnew++;
641 		if(doplumb)
642 			mailplumb(mb, m, 0);
643 	}
644 	if(pipeline)
645 		waitpid();
646 
647 	if(nnew || mb->vers == 0){
648 		mb->vers++;
649 		henter(PATH(0, Qtop), mb->name,
650 			(Qid){PATH(mb->id, Qmbox), mb->vers, QTDIR}, nil, mb);
651 	}
652 	return nil;
653 }
654 
655 /* */
656 /* sync mailbox */
657 /* */
658 static void
659 imap4purge(Imap *imap, Mailbox *mb)
660 {
661 	int ndel;
662 	Message *m, *next;
663 
664 	ndel = 0;
665 	for(m=mb->root->part; m!=nil; m=next){
666 		next = m->next;
667 		if(m->deleted && m->refs==0){
668 			if(m->inmbox && (ulong)(m->imapuid>>32)==imap->validity){
669 				imap4cmd(imap, "UID STORE %lud +FLAGS (\\Deleted)", (ulong)m->imapuid);
670 				if(isokay(imap4resp(imap))){
671 					ndel++;
672 					delmessage(mb, m);
673 				}
674 			}else
675 				delmessage(mb, m);
676 		}
677 	}
678 
679 	if(ndel){
680 		imap4cmd(imap, "EXPUNGE");
681 		imap4resp(imap);
682 	}
683 }
684 
685 /* */
686 /* connect to imap4 server, sync mailbox */
687 /* */
688 static char*
689 imap4sync(Mailbox *mb, int doplumb)
690 {
691 	char *err;
692 	Imap *imap;
693 
694 	imap = mb->aux;
695 
696 	if(err = imap4dial(imap)){
697 		mb->waketime = time(0) + imap->refreshtime;
698 		return err;
699 	}
700 
701 	if((err = imap4read(imap, mb, doplumb)) == nil){
702 		imap4purge(imap, mb);
703 		mb->d->atime = mb->d->mtime = time(0);
704 	}
705 	/*
706 	 * don't hang up; leave connection open for next time.
707 	 */
708 	/* imap4hangup(imap); */
709 	mb->waketime = time(0) + imap->refreshtime;
710 	return err;
711 }
712 
713 static char Eimap4ctl[] = "bad imap4 control message";
714 
715 static char*
716 imap4ctl(Mailbox *mb, int argc, char **argv)
717 {
718 	int n;
719 	Imap *imap;
720 
721 	imap = mb->aux;
722 	if(argc < 1)
723 		return Eimap4ctl;
724 
725 	if(argc==1 && strcmp(argv[0], "debug")==0){
726 		imap->debug = 1;
727 		return nil;
728 	}
729 
730 	if(argc==1 && strcmp(argv[0], "nodebug")==0){
731 		imap->debug = 0;
732 		return nil;
733 	}
734 
735 	if(argc==1 && strcmp(argv[0], "thumbprint")==0){
736 		if(imap->thumb)
737 			freeThumbprints(imap->thumb);
738 		imap->thumb = initThumbprints("/sys/lib/tls/mail", "/sys/lib/tls/mail.exclude");
739 	}
740 	if(strcmp(argv[0], "refresh")==0){
741 		if(argc==1){
742 			imap->refreshtime = 60;
743 			return nil;
744 		}
745 		if(argc==2){
746 			n = atoi(argv[1]);
747 			if(n < 15)
748 				return Eimap4ctl;
749 			imap->refreshtime = n;
750 			return nil;
751 		}
752 	}
753 
754 	return Eimap4ctl;
755 }
756 
757 /* */
758 /* free extra memory associated with mb */
759 /* */
760 static void
761 imap4close(Mailbox *mb)
762 {
763 	Imap *imap;
764 
765 	imap = mb->aux;
766 	free(imap->freep);
767 	free(imap->base);
768 	free(imap->uid);
769 	if(imap->fd >= 0)
770 		close(imap->fd);
771 	free(imap);
772 }
773 
774 /* */
775 /* open mailboxes of the form /imap/host/user */
776 /* */
777 char*
778 imap4mbox(Mailbox *mb, char *path)
779 {
780 	char *f[10];
781 	int mustssl, nf;
782 	Imap *imap;
783 
784 	quotefmtinstall();
785 	fmtinstall('Z', doublequote);
786 	if(strncmp(path, "/imap/", 6) != 0 && strncmp(path, "/imaps/", 7) != 0)
787 		return Enotme;
788 	mustssl = (strncmp(path, "/imaps/", 7) == 0);
789 
790 	path = strdup(path);
791 	if(path == nil)
792 		return "out of memory";
793 
794 	nf = getfields(path, f, 5, 0, "/");
795 	if(nf < 3){
796 		free(path);
797 		return "bad imap path syntax /imap[s]/system[/user[/mailbox]]";
798 	}
799 
800 	imap = emalloc(sizeof(*imap));
801 	imap->fd = -1;
802 	imap->debug = debug;
803 	imap->freep = path;
804 	imap->mustssl = mustssl;
805 	imap->host = f[2];
806 	if(nf < 4)
807 		imap->user = nil;
808 	else
809 		imap->user = f[3];
810 	if(nf < 5)
811 		imap->mbox = "Inbox";
812 	else
813 		imap->mbox = f[4];
814 	imap->thumb = initThumbprints("/sys/lib/tls/mail", "/sys/lib/tls/mail.exclude");
815 
816 	mb->aux = imap;
817 	mb->sync = imap4sync;
818 	mb->close = imap4close;
819 	mb->ctl = imap4ctl;
820 	mb->d = emalloc(sizeof(*mb->d));
821 	/*mb->fetch = imap4fetch; */
822 
823 	return nil;
824 }
825 
826 /* */
827 /* Formatter for %" */
828 /* Use double quotes to protect white space, frogs, \ and " */
829 /* */
830 enum
831 {
832 	Qok = 0,
833 	Qquote,
834 	Qbackslash
835 };
836 
837 static int
838 needtoquote(Rune r)
839 {
840 	if(r >= Runeself)
841 		return Qquote;
842 	if(r <= ' ')
843 		return Qquote;
844 	if(r=='\\' || r=='"')
845 		return Qbackslash;
846 	return Qok;
847 }
848 
849 int
850 doublequote(Fmt *f)
851 {
852 	char *s, *t;
853 	int w, quotes;
854 	Rune r;
855 
856 	s = va_arg(f->args, char*);
857 	if(s == nil || *s == '\0')
858 		return fmtstrcpy(f, "\"\"");
859 
860 	quotes = 0;
861 	for(t=s; *t; t+=w){
862 		w = chartorune(&r, t);
863 		quotes |= needtoquote(r);
864 	}
865 	if(quotes == 0)
866 		return fmtstrcpy(f, s);
867 
868 	fmtrune(f, '"');
869 	for(t=s; *t; t+=w){
870 		w = chartorune(&r, t);
871 		if(needtoquote(r) == Qbackslash)
872 			fmtrune(f, '\\');
873 		fmtrune(f, r);
874 	}
875 	return fmtrune(f, '"');
876 }