plan9port

mbox.c (29364B)

---

 #include "common.h"
 #include <ctype.h>
 #include <plumb.h>
 #include <libsec.h>
 #include <thread.h>
 #include "dat.h"
 
 extern char* dirtab[]; /* jpc */
 
 typedef struct Header Header;
 
 struct Header {
 	char *type;
 	void (*f)(Message*, Header*, char*);
 	int len;
 };
 
 /* headers */
 static	void	ctype(Message*, Header*, char*);
 static	void	cencoding(Message*, Header*, char*);
 static	void	cdisposition(Message*, Header*, char*);
 static	void	date822(Message*, Header*, char*);
 static	void	from822(Message*, Header*, char*);
 static	void	to822(Message*, Header*, char*);
 static	void	sender822(Message*, Header*, char*);
 static	void	replyto822(Message*, Header*, char*);
 static	void	subject822(Message*, Header*, char*);
 static	void	inreplyto822(Message*, Header*, char*);
 static	void	cc822(Message*, Header*, char*);
 static	void	bcc822(Message*, Header*, char*);
 static	void	messageid822(Message*, Header*, char*);
 static	void	mimeversion(Message*, Header*, char*);
 static	void	nullsqueeze(Message*);
 enum
 {
 	Mhead=	11,	/* offset of first mime header */
 };
 
 Header head[] =
 {
 	{ "date:", date822, },
 	{ "from:", from822, },
 	{ "to:", to822, },
 	{ "sender:", sender822, },
 	{ "reply-to:", replyto822, },
 	{ "subject:", subject822, },
 	{ "cc:", cc822, },
 	{ "bcc:", bcc822, },
 	{ "in-reply-to:", inreplyto822, },
 	{ "mime-version:", mimeversion, },
 	{ "message-id:", messageid822, },
 
 [Mhead]	{ "content-type:", ctype, },
 	{ "content-transfer-encoding:", cencoding, },
 	{ "content-disposition:", cdisposition, },
 	{ 0, }
 };
 
 /* static	void	fatal(char *fmt, ...); jpc */
 static	void	initquoted(void);
 /* static	void	startheader(Message*);
 static	void	startbody(Message*); jpc */
 static	char*	skipwhite(char*);
 static	char*	skiptosemi(char*);
 static	char*	getstring(char*, String*, int);
 static	void	setfilename(Message*, char*);
 /* static	char*	lowercase(char*); jpc */
 static	int	is8bit(Message*);
 static	int	headerline(char**, String*);
 static	void	initheaders(void);
 static void	parseattachments(Message*, Mailbox*);
 
 int		debug;
 
 char *Enotme = "path not served by this file server";
 
 enum
 {
 	Chunksize = 1024
 };
 
 Mailboxinit *boxinit[] = {
 	imap4mbox,
 	pop3mbox,
 	plan9mbox
 };
 
 char*
 syncmbox(Mailbox *mb, int doplumb)
 {
 	return (*mb->sync)(mb, doplumb);
 }
 
 /* create a new mailbox */
 char*
 newmbox(char *path, char *name, int std)
 {
 	Mailbox *mb, **l;
 	char *p, *rv;
 	int i;
 
 	initheaders();
 
 	mb = emalloc(sizeof(*mb));
 	strncpy(mb->path, path, sizeof(mb->path)-1);
 	if(name == nil){
 		p = strrchr(path, '/');
 		if(p == nil)
 			p = path;
 		else
 			p++;
 		if(*p == 0){
 			free(mb);
 			return "bad mbox name";
 		}
 		strncpy(mb->name, p, sizeof(mb->name)-1);
 	} else {
 		strncpy(mb->name, name, sizeof(mb->name)-1);
 	}
 
 	rv = nil;
 	/* check for a mailbox type */
 	for(i=0; i<nelem(boxinit); i++)
 		if((rv = (*boxinit[i])(mb, path)) != Enotme)
 			break;
 	if(i == nelem(boxinit)){
 		free(mb);
 		return "bad path";
 	}
 
 	/* on error, give up */
 	if(rv){
 		free(mb);
 		return rv;
 	}
 
 	/* make sure name isn't taken */
 	qlock(&mbllock);
 	for(l = &mbl; *l != nil; l = &(*l)->next){
 		if(strcmp((*l)->name, mb->name) == 0){
 			if(strcmp(path, (*l)->path) == 0)
 				rv = nil;
 			else
 				rv = "mbox name in use";
 			if(mb->close)
 				(*mb->close)(mb);
 			free(mb);
 			qunlock(&mbllock);
 			return rv;
 		}
 	}
 
 	/* always try locking */
 	mb->dolock = 1;
 
 	mb->refs = 1;
 	mb->next = nil;
 	mb->id = newid();
 	mb->root = newmessage(nil);
 	mb->std = std;
 	*l = mb;
 	qunlock(&mbllock);
 
 	qlock(&mb->ql);
 	if(mb->ctl){
 		henter(PATH(mb->id, Qmbox), "ctl",
 			(Qid){PATH(mb->id, Qmboxctl), 0, QTFILE}, nil, mb);
 	}
 	rv = syncmbox(mb, 0);
 	qunlock(&mb->ql);
 
 	return rv;
 }
 
 /* close the named mailbox */
 void
 freembox(char *name)
 {
 	Mailbox **l, *mb;
 
 	qlock(&mbllock);
 	for(l=&mbl; *l != nil; l=&(*l)->next){
 		if(strcmp(name, (*l)->name) == 0){
 			mb = *l;
 			*l = mb->next;
 			mboxdecref(mb);
 			break;
 		}
 	}
 	hfree(PATH(0, Qtop), name);
 	qunlock(&mbllock);
 }
 
 static void
 initheaders(void)
 {
 	Header *h;
 	static int already;
 
 	if(already)
 		return;
 	already = 1;
 
 	for(h = head; h->type != nil; h++)
 		h->len = strlen(h->type);
 }
 
 /*
  *  parse a Unix style header
  */
 void
 parseunix(Message *m)
 {
 	char *p;
 	String *h;
 
 	h = s_new();
 	for(p = m->start + 5; *p && *p != '\r' && *p != '\n'; p++)
 		s_putc(h, *p);
 	s_terminate(h);
 	s_restart(h);
 
 	m->unixfrom = s_parse(h, s_reset(m->unixfrom));
 	m->unixdate = s_append(s_reset(m->unixdate), h->ptr);
 
 	s_free(h);
 }
 
 /*
  *  parse a message
  */
 void
 parseheaders(Message *m, int justmime, Mailbox *mb, int addfrom)
 {
 	String *hl;
 	Header *h;
 	char *p, *q;
 	int i;
 
 	if(m->whole == m->whole->whole){
 		henter(PATH(mb->id, Qmbox), m->name,
 			(Qid){PATH(m->id, Qdir), 0, QTDIR}, m, mb);
 	} else {
 		henter(PATH(m->whole->id, Qdir), m->name,
 			(Qid){PATH(m->id, Qdir), 0, QTDIR}, m, mb);
 	}
 	for(i = 0; i < Qmax; i++)
 		henter(PATH(m->id, Qdir), dirtab[i],
 			(Qid){PATH(m->id, i), 0, QTFILE}, m, mb);
 
 	/* parse mime headers */
 	p = m->header;
 	hl = s_new();
 	while(headerline(&p, hl)){
 		if(justmime)
 			h = &head[Mhead];
 		else
 			h = head;
 		for(; h->type; h++){
 			if(cistrncmp(s_to_c(hl), h->type, h->len) == 0){
 				(*h->f)(m, h, s_to_c(hl));
 				break;
 			}
 		}
 		s_reset(hl);
 	}
 	s_free(hl);
 
 	/* the blank line isn't really part of the body or header */
 	if(justmime){
 		m->mhend = p;
 		m->hend = m->header;
 	} else {
 		m->hend = p;
 	}
 	if(*p == '\n')
 		p++;
 	m->rbody = m->body = p;
 
 	/* if type is text, get any nulls out of the body.  This is */
 	/* for the two seans and imap clients that get confused. */
 	if(strncmp(s_to_c(m->type), "text/", 5) == 0)
 		nullsqueeze(m);
 
 	/* */
 	/* cobble together Unix-style from line */
 	/* for local mailbox messages, we end up recreating the */
 	/* original header. */
 	/* for pop3 messages, the best we can do is  */
 	/* use the From: information and the RFC822 date. */
 	/* */
 	if(m->unixdate == nil || strcmp(s_to_c(m->unixdate), "???") == 0
 	|| strcmp(s_to_c(m->unixdate), "Thu Jan 1 00:00:00 GMT 1970") == 0){
 		if(m->unixdate){
 			s_free(m->unixdate);
 			m->unixdate = nil;
 		}
 		/* look for the date in the first Received: line. */
 		/* it's likely to be the right time zone (it's */
 	 	/* the local system) and in a convenient format. */
 		if(cistrncmp(m->header, "received:", 9)==0){
 			if((q = strchr(m->header, ';')) != nil){
 				p = q;
 				while((p = strchr(p, '\n')) != nil){
 					if(p[1] != ' ' && p[1] != '\t' && p[1] != '\n')
 						break;
 					p++;
 				}
 				if(p){
 					*p = '\0';
 					m->unixdate = date822tounix(q+1);
 					*p = '\n';
 				}
 			}
 		}
 
 		/* fall back on the rfc822 date	 */
 		if(m->unixdate==nil && m->date822)
 			m->unixdate = date822tounix(s_to_c(m->date822));
 	}
 
 	if(m->unixheader != nil)
 		s_free(m->unixheader);
 
 	/* only fake header for top-level messages for pop3 and imap4 */
 	/* clients (those protocols don't include the unix header). */
 	/* adding the unix header all the time screws up mime-attached */
 	/* rfc822 messages. */
 	if(!addfrom && !m->unixfrom){
 		m->unixheader = nil;
 		return;
 	}
 
 	m->unixheader = s_copy("From ");
 	if(m->unixfrom && strcmp(s_to_c(m->unixfrom), "???") != 0)
 		s_append(m->unixheader, s_to_c(m->unixfrom));
 	else if(m->from822)
 		s_append(m->unixheader, s_to_c(m->from822));
 	else
 		s_append(m->unixheader, "???");
 
 	s_append(m->unixheader, " ");
 	if(m->unixdate)
 		s_append(m->unixheader, s_to_c(m->unixdate));
 	else
 		s_append(m->unixheader, "Thu Jan  1 00:00:00 GMT 1970");
 
 	s_append(m->unixheader, "\n");
 }
 
 String*
 promote(String **sp)
 {
 	String *s;
 
 	if(*sp != nil)
 		s = s_clone(*sp);
 	else
 		s = nil;
 	return s;
 }
 
 void
 parsebody(Message *m, Mailbox *mb)
 {
 	Message *nm;
 
 	/* recurse */
 	if(strncmp(s_to_c(m->type), "multipart/", 10) == 0){
 		parseattachments(m, mb);
 	} else if(strcmp(s_to_c(m->type), "message/rfc822") == 0){
 		decode(m);
 		parseattachments(m, mb);
 		nm = m->part;
 
 		/* promote headers */
 		if(m->replyto822 == nil && m->from822 == nil && m->sender822 == nil){
 			m->from822 = promote(&nm->from822);
 			m->to822 = promote(&nm->to822);
 			m->date822 = promote(&nm->date822);
 			m->sender822 = promote(&nm->sender822);
 			m->replyto822 = promote(&nm->replyto822);
 			m->subject822 = promote(&nm->subject822);
 			m->unixdate = promote(&nm->unixdate);
 		}
 	}
 }
 
 void
 parse(Message *m, int justmime, Mailbox *mb, int addfrom)
 {
 	parseheaders(m, justmime, mb, addfrom);
 	parsebody(m, mb);
 }
 
 static void
 parseattachments(Message *m, Mailbox *mb)
 {
 	Message *nm, **l;
 	char *p, *x;
 
 	/* if there's a boundary, recurse... */
 	if(m->boundary != nil){
 		p = m->body;
 		nm = nil;
 		l = &m->part;
 		for(;;){
 			x = strstr(p, s_to_c(m->boundary));
 
 			/* no boundary, we're done */
 			if(x == nil){
 				if(nm != nil)
 					nm->rbend = nm->bend = nm->end = m->bend;
 				break;
 			}
 
 			/* boundary must be at the start of a line */
 			if(x != m->body && *(x-1) != '\n'){
 				p = x+1;
 				continue;
 			}
 
 			if(nm != nil)
 				nm->rbend = nm->bend = nm->end = x;
 			x += strlen(s_to_c(m->boundary));
 
 			/* is this the last part? ignore anything after it */
 			if(strncmp(x, "--", 2) == 0)
 				break;
 
 			p = strchr(x, '\n');
 			if(p == nil)
 				break;
 			nm = newmessage(m);
 			nm->start = nm->header = nm->body = nm->rbody = ++p;
 			nm->mheader = nm->header;
 			*l = nm;
 			l = &nm->next;
 		}
 		for(nm = m->part; nm != nil; nm = nm->next)
 			parse(nm, 1, mb, 0);
 		return;
 	}
 
 	/* if we've got an rfc822 message, recurse... */
 	if(strcmp(s_to_c(m->type), "message/rfc822") == 0){
 		nm = newmessage(m);
 		m->part = nm;
 		nm->start = nm->header = nm->body = nm->rbody = m->body;
 		nm->end = nm->bend = nm->rbend = m->bend;
 		parse(nm, 0, mb, 0);
 	}
 }
 
 /*
  *  pick up a header line
  */
 static int
 headerline(char **pp, String *hl)
 {
 	char *p, *x;
 
 	s_reset(hl);
 	p = *pp;
 	x = strpbrk(p, ":\n");
 	if(x == nil || *x == '\n')
 		return 0;
 	for(;;){
 		x = strchr(p, '\n');
 		if(x == nil)
 			x = p + strlen(p);
 		s_nappend(hl, p, x-p);
 		p = x;
 		if(*p != '\n' || *++p != ' ' && *p != '\t')
 			break;
 		while(*p == ' ' || *p == '\t')
 			p++;
 		s_putc(hl, ' ');
 	}
 	*pp = p;
 	return 1;
 }
 
 static String*
 addr822(char *p)
 {
 	String *s, *list;
 	int incomment, addrdone, inanticomment, quoted;
 	int n;
 	int c;
 
 	list = s_new();
 	s = s_new();
 	quoted = incomment = addrdone = inanticomment = 0;
 	n = 0;
 	for(; *p; p++){
 		c = *p;
 
 		/* whitespace is ignored */
 		if(!quoted && isspace(c) || c == '\r')
 			continue;
 
 		/* strings are always treated as atoms */
 		if(!quoted && c == '"'){
 			if(!addrdone && !incomment)
 				s_putc(s, c);
 			for(p++; *p; p++){
 				if(!addrdone && !incomment)
 					s_putc(s, *p);
 				if(!quoted && *p == '"')
 					break;
 				if(*p == '\\')
 					quoted = 1;
 				else
 					quoted = 0;
 			}
 			if(*p == 0)
 				break;
 			quoted = 0;
 			continue;
 		}
 
 		/* ignore everything in an expicit comment */
 		if(!quoted && c == '('){
 			incomment = 1;
 			continue;
 		}
 		if(incomment){
 			if(!quoted && c == ')')
 				incomment = 0;
 			quoted = 0;
 			continue;
 		}
 
 		/* anticomments makes everything outside of them comments */
 		if(!quoted && c == '<' && !inanticomment){
 			inanticomment = 1;
 			s = s_reset(s);
 			continue;
 		}
 		if(!quoted && c == '>' && inanticomment){
 			addrdone = 1;
 			inanticomment = 0;
 			continue;
 		}
 
 		/* commas separate addresses */
 		if(!quoted && c == ',' && !inanticomment){
 			s_terminate(s);
 			addrdone = 0;
 			if(n++ != 0)
 				s_append(list, " ");
 			s_append(list, s_to_c(s));
 			s = s_reset(s);
 			continue;
 		}
 
 		/* what's left is part of the address */
 		s_putc(s, c);
 
 		/* quoted characters are recognized only as characters */
 		if(c == '\\')
 			quoted = 1;
 		else
 			quoted = 0;
 
 	}
 
 	if(*s_to_c(s) != 0){
 		s_terminate(s);
 		if(n++ != 0)
 			s_append(list, " ");
 		s_append(list, s_to_c(s));
 	}
 	s_free(s);
 
 	if(n == 0){
 		s_free(list);
 		return nil;
 	}
 	return list;
 }
 
 static void
 to822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	s_free(m->to822);
 	m->to822 = addr822(p);
 }
 
 static void
 cc822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	s_free(m->cc822);
 	m->cc822 = addr822(p);
 }
 
 static void
 bcc822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	s_free(m->bcc822);
 	m->bcc822 = addr822(p);
 }
 
 static void
 from822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	s_free(m->from822);
 	m->from822 = addr822(p);
 }
 
 static void
 sender822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	s_free(m->sender822);
 	m->sender822 = addr822(p);
 }
 
 static void
 replyto822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	s_free(m->replyto822);
 	m->replyto822 = addr822(p);
 }
 
 static void
 mimeversion(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	s_free(m->mimeversion);
 	m->mimeversion = addr822(p);
 }
 
 static void
 killtrailingwhite(char *p)
 {
 	char *e;
 
 	e = p + strlen(p) - 1;
 	while(e > p && isspace(*e))
 		*e-- = 0;
 }
 
 static void
 date822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	p = skipwhite(p);
 	s_free(m->date822);
 	m->date822 = s_copy(p);
 	p = s_to_c(m->date822);
 	killtrailingwhite(p);
 }
 
 static void
 subject822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	p = skipwhite(p);
 	s_free(m->subject822);
 	m->subject822 = s_copy(p);
 	p = s_to_c(m->subject822);
 	killtrailingwhite(p);
 }
 
 static void
 inreplyto822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	p = skipwhite(p);
 	s_free(m->inreplyto822);
 	m->inreplyto822 = s_copy(p);
 	p = s_to_c(m->inreplyto822);
 	killtrailingwhite(p);
 }
 
 static void
 messageid822(Message *m, Header *h, char *p)
 {
 	p += strlen(h->type);
 	p = skipwhite(p);
 	s_free(m->messageid822);
 	m->messageid822 = s_copy(p);
 	p = s_to_c(m->messageid822);
 	killtrailingwhite(p);
 }
 
 static int
 isattribute(char **pp, char *attr)
 {
 	char *p;
 	int n;
 
 	n = strlen(attr);
 	p = *pp;
 	if(cistrncmp(p, attr, n) != 0)
 		return 0;
 	p += n;
 	while(*p == ' ')
 		p++;
 	if(*p++ != '=')
 		return 0;
 	while(*p == ' ')
 		p++;
 	*pp = p;
 	return 1;
 }
 
 static void
 ctype(Message *m, Header *h, char *p)
 {
 	String *s;
 
 	p += h->len;
 	p = skipwhite(p);
 
 	p = getstring(p, m->type, 1);
 
 	while(*p){
 		if(isattribute(&p, "boundary")){
 			s = s_new();
 			p = getstring(p, s, 0);
 			m->boundary = s_reset(m->boundary);
 			s_append(m->boundary, "--");
 			s_append(m->boundary, s_to_c(s));
 			s_free(s);
 		} else if(cistrncmp(p, "multipart", 9) == 0){
 			/*
 			 *  the first unbounded part of a multipart message,
 			 *  the preamble, is not displayed or saved
 			 */
 		} else if(isattribute(&p, "name")){
 			if(m->filename == nil)
 				setfilename(m, p);
 		} else if(isattribute(&p, "charset")){
 			p = getstring(p, s_reset(m->charset), 0);
 		}
 
 		p = skiptosemi(p);
 	}
 }
 
 static void
 cencoding(Message *m, Header *h, char *p)
 {
 	p += h->len;
 	p = skipwhite(p);
 	if(cistrncmp(p, "base64", 6) == 0)
 		m->encoding = Ebase64;
 	else if(cistrncmp(p, "quoted-printable", 16) == 0)
 		m->encoding = Equoted;
 }
 
 static void
 cdisposition(Message *m, Header *h, char *p)
 {
 	p += h->len;
 	p = skipwhite(p);
 	while(*p){
 		if(cistrncmp(p, "inline", 6) == 0){
 			m->disposition = Dinline;
 		} else if(cistrncmp(p, "attachment", 10) == 0){
 			m->disposition = Dfile;
 		} else if(cistrncmp(p, "filename=", 9) == 0){
 			p += 9;
 			setfilename(m, p);
 		}
 		p = skiptosemi(p);
 	}
 
 }
 
 ulong msgallocd, msgfreed;
 
 Message*
 newmessage(Message *parent)
 {
 	/* static int id; jpc */
 	Message *m;
 
 	msgallocd++;
 
 	m = emalloc(sizeof(*m));
 	memset(m, 0, sizeof(*m));
 	m->disposition = Dnone;
 	m->type = s_copy("text/plain");
 	m->charset = s_copy("iso-8859-1");
 	m->id = newid();
 	if(parent)
 		sprint(m->name, "%d", ++(parent->subname));
 	if(parent == nil)
 		parent = m;
 	m->whole = parent;
 	m->hlen = -1;
 	return m;
 }
 
 /* delete a message from a mailbox */
 void
 delmessage(Mailbox *mb, Message *m)
 {
 	Message **l;
 	int i;
 
 	mb->vers++;
 	msgfreed++;
 
 	if(m->whole != m){
 		/* unchain from parent */
 		for(l = &m->whole->part; *l && *l != m; l = &(*l)->next)
 			;
 		if(*l != nil)
 			*l = m->next;
 
 		/* clear out of name lookup hash table */
 		if(m->whole->whole == m->whole)
 			hfree(PATH(mb->id, Qmbox), m->name);
 		else
 			hfree(PATH(m->whole->id, Qdir), m->name);
 		for(i = 0; i < Qmax; i++)
 			hfree(PATH(m->id, Qdir), dirtab[i]);
 	}
 
 	/* recurse through sub-parts */
 	while(m->part)
 		delmessage(mb, m->part);
 
 	/* free memory */
 	if(m->mallocd)
 		free(m->start);
 	if(m->hallocd)
 		free(m->header);
 	if(m->ballocd)
 		free(m->body);
 	s_free(m->unixfrom);
 	s_free(m->unixdate);
 	s_free(m->unixheader);
 	s_free(m->from822);
 	s_free(m->sender822);
 	s_free(m->to822);
 	s_free(m->bcc822);
 	s_free(m->cc822);
 	s_free(m->replyto822);
 	s_free(m->date822);
 	s_free(m->inreplyto822);
 	s_free(m->subject822);
 	s_free(m->messageid822);
 	s_free(m->addrs);
 	s_free(m->mimeversion);
 	s_free(m->sdigest);
 	s_free(m->boundary);
 	s_free(m->type);
 	s_free(m->charset);
 	s_free(m->filename);
 
 	free(m);
 }
 
 /* mark messages (identified by path) for deletion */
 void
 delmessages(int ac, char **av)
 {
 	Mailbox *mb;
 	Message *m;
 	int i, needwrite;
 
 	qlock(&mbllock);
 	for(mb = mbl; mb != nil; mb = mb->next)
 		if(strcmp(av[0], mb->name) == 0){
 			qlock(&mb->ql);
 			break;
 		}
 	qunlock(&mbllock);
 	if(mb == nil)
 		return;
 
 	needwrite = 0;
 	for(i = 1; i < ac; i++){
 		for(m = mb->root->part; m != nil; m = m->next)
 			if(strcmp(m->name, av[i]) == 0){
 				if(!m->deleted){
 					mailplumb(mb, m, 1);
 					needwrite = 1;
 					m->deleted = 1;
 					logmsg("deleting", m);
 				}
 				break;
 			}
 	}
 	if(needwrite)
 		syncmbox(mb, 1);
 	qunlock(&mb->ql);
 }
 
 /*
  *  the following are called with the mailbox qlocked
  */
 void
 msgincref(Message *m)
 {
 	m->refs++;
 }
 void
 msgdecref(Mailbox *mb, Message *m)
 {
 	m->refs--;
 	if(m->refs == 0 && m->deleted)
 		syncmbox(mb, 1);
 }
 
 /*
  *  the following are called with mbllock'd
  */
 void
 mboxincref(Mailbox *mb)
 {
 	assert(mb->refs > 0);
 	mb->refs++;
 }
 void
 mboxdecref(Mailbox *mb)
 {
 	assert(mb->refs > 0);
 	qlock(&mb->ql);
 	mb->refs--;
 	if(mb->refs == 0){
 		delmessage(mb, mb->root);
 		if(mb->ctl)
 			hfree(PATH(mb->id, Qmbox), "ctl");
 		if(mb->close)
 			(*mb->close)(mb);
 		free(mb);
 	} else
 		qunlock(&mb->ql);
 }
 
 int
 cistrncmp(char *a, char *b, int n)
 {
 	while(n-- > 0){
 		if(tolower(*a++) != tolower(*b++))
 			return -1;
 	}
 	return 0;
 }
 
 int
 cistrcmp(char *a, char *b)
 {
 	for(;;){
 		if(tolower(*a) != tolower(*b++))
 			return -1;
 		if(*a++ == 0)
 			break;
 	}
 	return 0;
 }
 
 static char*
 skipwhite(char *p)
 {
 	while(isspace(*p))
 		p++;
 	return p;
 }
 
 static char*
 skiptosemi(char *p)
 {
 	while(*p && *p != ';')
 		p++;
 	while(*p == ';' || isspace(*p))
 		p++;
 	return p;
 }
 
 static char*
 getstring(char *p, String *s, int dolower)
 {
 	s = s_reset(s);
 	p = skipwhite(p);
 	if(*p == '"'){
 		p++;
 		for(;*p && *p != '"'; p++)
 			if(dolower)
 				s_putc(s, tolower(*p));
 			else
 				s_putc(s, *p);
 		if(*p == '"')
 			p++;
 		s_terminate(s);
 
 		return p;
 	}
 
 	for(; *p && !isspace(*p) && *p != ';'; p++)
 		if(dolower)
 			s_putc(s, tolower(*p));
 		else
 			s_putc(s, *p);
 	s_terminate(s);
 
 	return p;
 }
 
 static void
 setfilename(Message *m, char *p)
 {
 	m->filename = s_reset(m->filename);
 	getstring(p, m->filename, 0);
 	for(p = s_to_c(m->filename); *p; p++)
 		if(*p == ' ' || *p == '\t' || *p == ';')
 			*p = '_';
 }
 
 /* */
 /* undecode message body */
 /* */
 void
 decode(Message *m)
 {
 	int i, len;
 	char *x;
 
 	if(m->decoded)
 		return;
 	switch(m->encoding){
 	case Ebase64:
 		len = m->bend - m->body;
 		i = (len*3)/4+1;	/* room for max chars + null */
 		x = emalloc(i);
 		len = dec64((uchar*)x, i, m->body, len);
 		if(m->ballocd)
 			free(m->body);
 		m->body = x;
 		m->bend = x + len;
 		m->ballocd = 1;
 		break;
 	case Equoted:
 		len = m->bend - m->body;
 		x = emalloc(len+2);	/* room for null and possible extra nl */
 		len = decquoted(x, m->body, m->bend);
 		if(m->ballocd)
 			free(m->body);
 		m->body = x;
 		m->bend = x + len;
 		m->ballocd = 1;
 		break;
 	default:
 		break;
 	}
 	m->decoded = 1;
 }
 
 /* convert latin1 to utf */
 void
 convert(Message *m)
 {
 	int len;
 	char *x;
 
 	/* don't convert if we're not a leaf, not text, or already converted */
 	if(m->converted)
 		return;
 	if(m->part != nil)
 		return;
 	if(cistrncmp(s_to_c(m->type), "text", 4) != 0)
 		return;
 
 	if(cistrcmp(s_to_c(m->charset), "us-ascii") == 0 ||
 	   cistrcmp(s_to_c(m->charset), "iso-8859-1") == 0){
 		len = is8bit(m);
 		if(len > 0){
 			len = 2*len + m->bend - m->body + 1;
 			x = emalloc(len);
 			len = latin1toutf(x, m->body, m->bend);
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	} else if(cistrcmp(s_to_c(m->charset), "iso-8859-2") == 0){
 		len = xtoutf("8859-2", &x, m->body, m->bend);
 		if(len != 0){
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	} else if(cistrcmp(s_to_c(m->charset), "iso-8859-15") == 0){
 		len = xtoutf("8859-15", &x, m->body, m->bend);
 		if(len != 0){
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	} else if(cistrcmp(s_to_c(m->charset), "big5") == 0){
 		len = xtoutf("big5", &x, m->body, m->bend);
 		if(len != 0){
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	} else if(cistrcmp(s_to_c(m->charset), "iso-2022-jp") == 0){
 		len = xtoutf("jis", &x, m->body, m->bend);
 		if(len != 0){
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	} else if(cistrcmp(s_to_c(m->charset), "windows-1257") == 0
 			|| cistrcmp(s_to_c(m->charset), "windows-1252") == 0){
 		len = is8bit(m);
 		if(len > 0){
 			len = 2*len + m->bend - m->body + 1;
 			x = emalloc(len);
 			len = windows1257toutf(x, m->body, m->bend);
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	} else if(cistrcmp(s_to_c(m->charset), "windows-1251") == 0){
 		len = xtoutf("cp1251", &x, m->body, m->bend);
 		if(len != 0){
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	} else if(cistrcmp(s_to_c(m->charset), "koi8-r") == 0){
 		len = xtoutf("koi8", &x, m->body, m->bend);
 		if(len != 0){
 			if(m->ballocd)
 				free(m->body);
 			m->body = x;
 			m->bend = x + len;
 			m->ballocd = 1;
 		}
 	}
 
 	m->converted = 1;
 }
 
 enum
 {
 	Self=	1,
 	Hex=	2
 };
 uchar	tableqp[256];
 
 static void
 initquoted(void)
 {
 	int c;
 
 	memset(tableqp, 0, 256);
 	for(c = ' '; c <= '<'; c++)
 		tableqp[c] = Self;
 	for(c = '>'; c <= '~'; c++)
 		tableqp[c] = Self;
 	tableqp['\t'] = Self;
 	tableqp['='] = Hex;
 }
 
 static int
 hex2int(int x)
 {
 	if(x >= '0' && x <= '9')
 		return x - '0';
 	if(x >= 'A' && x <= 'F')
 		return (x - 'A') + 10;
 	if(x >= 'a' && x <= 'f')
 		return (x - 'a') + 10;
 	return 0;
 }
 
 static char*
 decquotedline(char *out, char *in, char *e)
 {
 	int c, soft;
 
 	/* dump trailing white space */
 	while(e >= in && (*e == ' ' || *e == '\t' || *e == '\r' || *e == '\n'))
 		e--;
 
 	/* trailing '=' means no newline */
 	if(*e == '='){
 		soft = 1;
 		e--;
 	} else
 		soft = 0;
 
 	while(in <= e){
 		c = (*in++) & 0xff;
 		switch(tableqp[c]){
 		case Self:
 			*out++ = c;
 			break;
 		case Hex:
 			c = hex2int(*in++)<<4;
 			c |= hex2int(*in++);
 			*out++ = c;
 			break;
 		}
 	}
 	if(!soft)
 		*out++ = '\n';
 	*out = 0;
 
 	return out;
 }
 
 int
 decquoted(char *out, char *in, char *e)
 {
 	char *p, *nl;
 
 	if(tableqp[' '] == 0)
 		initquoted();
 
 	p = out;
 	while((nl = strchr(in, '\n')) != nil && nl < e){
 		p = decquotedline(p, in, nl);
 		in = nl + 1;
 	}
 	if(in < e)
 		p = decquotedline(p, in, e-1);
 
 	/* make sure we end with a new line */
 	if(*(p-1) != '\n'){
 		*p++ = '\n';
 		*p = 0;
 	}
 
 	return p - out;
 }
 
 #if 0 /* jpc */
 static char*
 lowercase(char *p)
 {
 	char *op;
 	int c;
 
 	for(op = p; c = *p; p++)
 		if(isupper(c))
 			*p = tolower(c);
 	return op;
 }
 #endif
 
 /*
  *  return number of 8 bit characters
  */
 static int
 is8bit(Message *m)
 {
 	int count = 0;
 	char *p;
 
 	for(p = m->body; p < m->bend; p++)
 		if(*p & 0x80)
 			count++;
 	return count;
 }
 
 /* translate latin1 directly since it fits neatly in utf */
 int
 latin1toutf(char *out, char *in, char *e)
 {
 	Rune r;
 	char *p;
 
 	p = out;
 	for(; in < e; in++){
 		r = (*in) & 0xff;
 		p += runetochar(p, &r);
 	}
 	*p = 0;
 	return p - out;
 }
 
 /* translate any thing else using the tcs program */
 int
 xtoutf(char *charset, char **out, char *in, char *e)
 {
 	char *av[4];
 	int totcs[2];
 	int fromtcs[2];
 	int n, len, sofar;
 	char *p;
 
 	len = e-in+1;
 	sofar = 0;
 	*out = p = malloc(len+1);
 	if(p == nil)
 		return 0;
 
 	av[0] = charset;
 	av[1] = "-f";
 	av[2] = charset;
 	av[3] = 0;
 	if(pipe(totcs) < 0)
 		return 0;
 	if(pipe(fromtcs) < 0){
 		close(totcs[0]); close(totcs[1]);
 		return 0;
 	}
 	switch(rfork(RFPROC|RFFDG|RFNOWAIT)){
 	case -1:
 		close(fromtcs[0]); close(fromtcs[1]);
 		close(totcs[0]); close(totcs[1]);
 		return 0;
 	case 0:
 		close(fromtcs[0]); close(totcs[1]);
 		dup(fromtcs[1], 1);
 		dup(totcs[0], 0);
 		close(fromtcs[1]); close(totcs[0]);
 		dup(open("/dev/null", OWRITE), 2);
 		/*jpc exec("/bin/tcs", av); */
 		exec(unsharp("#9/bin/tcs"), av);
 		/* _exits(0); */
 		threadexits(nil);
 	default:
 		close(fromtcs[1]); close(totcs[0]);
 		switch(rfork(RFPROC|RFFDG|RFNOWAIT)){
 		case -1:
 			close(fromtcs[0]); close(totcs[1]);
 			return 0;
 		case 0:
 			close(fromtcs[0]);
 			while(in < e){
 				n = write(totcs[1], in, e-in);
 				if(n <= 0)
 					break;
 				in += n;
 			}
 			close(totcs[1]);
 			/* _exits(0); */
 			threadexits(nil);
 		default:
 			close(totcs[1]);
 			for(;;){
 				n = read(fromtcs[0], &p[sofar], len-sofar);
 				if(n <= 0)
 					break;
 				sofar += n;
 				p[sofar] = 0;
 				if(sofar == len){
 					len += 1024;
 					*out = p = realloc(p, len+1);
 					if(p == nil)
 						return 0;
 				}
 			}
 			close(fromtcs[0]);
 			break;
 		}
 		break;
 	}
 	return sofar;
 }
 
 enum {
 	Winstart= 0x7f,
 	Winend= 0x9f
 };
 
 Rune winchars[] = {
 	L'•',
 	L'•', L'•', L'‚', L'ƒ', L'„', L'…', L'†', L'‡',
 	L'ˆ', L'‰', L'Š', L'‹', L'Œ', L'•', L'•', L'•',
 	L'•', L'‘', L'’', L'“', L'”', L'•', L'–', L'—',
 	L'˜', L'™', L'š', L'›', L'œ', L'•', L'•', L'Ÿ'
 };
 
 int
 windows1257toutf(char *out, char *in, char *e)
 {
 	Rune r;
 	char *p;
 
 	p = out;
 	for(; in < e; in++){
 		r = (*in) & 0xff;
 		if(r >= 0x7f && r <= 0x9f)
 			r = winchars[r-0x7f];
 		p += runetochar(p, &r);
 	}
 	*p = 0;
 	return p - out;
 }
 
 void *
 emalloc(ulong n)
 {
 	void *p;
 
 	p = mallocz(n, 1);
 	if(!p){
 		fprint(2, "%s: out of memory alloc %lud\n", argv0, n);
 		threadexits("out of memory");
 	}
 	setmalloctag(p, getcallerpc(&n));
 	return p;
 }
 
 void *
 erealloc(void *p, ulong n)
 {
 	if(n == 0)
 		n = 1;
 	p = realloc(p, n);
 	if(!p){
 		fprint(2, "%s: out of memory realloc %lud\n", argv0, n);
 		threadexits("out of memory");
 	}
 	setrealloctag(p, getcallerpc(&p));
 	return p;
 }
 
 void
 mailplumb(Mailbox *mb, Message *m, int delete)
 {
 	Plumbmsg p;
 	Plumbattr a[7];
 	char buf[256];
 	int ai;
 	char lenstr[10], *from, *subject, *date;
 	static int fd = -1;
 
 	if(m->subject822 == nil)
 		subject = "";
 	else
 		subject = s_to_c(m->subject822);
 
 	if(m->from822 != nil)
 		from = s_to_c(m->from822);
 	else if(m->unixfrom != nil)
 		from = s_to_c(m->unixfrom);
 	else
 		from = "";
 
 	if(m->unixdate != nil)
 		date = s_to_c(m->unixdate);
 	else
 		date = "";
 
 	sprint(lenstr, "%ld", m->end-m->start);
 
 	if(biffing && !delete)
 		print("[ %s / %s / %s ]\n", from, subject, lenstr);
 
 	if(!plumbing)
 		return;
 
 	if(fd < 0)
 		fd = plumbopen("send", OWRITE);
 	if(fd < 0)
 		return;
 
 	p.src = "mailfs";
 	p.dst = "seemail";
 	p.wdir = "/mail/fs";
 	p.type = "text";
 
 	ai = 0;
 	a[ai].name = "filetype";
 	a[ai].value = "mail";
 
 	a[++ai].name = "sender";
 	a[ai].value = from;
 	a[ai-1].next = &a[ai];
 
 	a[++ai].name = "length";
 	a[ai].value = lenstr;
 	a[ai-1].next = &a[ai];
 
 	a[++ai].name = "mailtype";
 	a[ai].value = delete?"delete":"new";
 	a[ai-1].next = &a[ai];
 
 	a[++ai].name = "date";
 	a[ai].value = date;
 	a[ai-1].next = &a[ai];
 
 	if(m->sdigest){
 		a[++ai].name = "digest";
 		a[ai].value = s_to_c(m->sdigest);
 		a[ai-1].next = &a[ai];
 	}
 
 	a[ai].next = nil;
 
 	p.attr = a;
 	snprint(buf, sizeof(buf), "%s/%s/%s",
 		mntpt, mb->name, m->name);
 	p.ndata = strlen(buf);
 	p.data = buf;
 
 	plumbsend(fd, &p);
 }
 
 /* */
 /* count the number of lines in the body (for imap4) */
 /* */
 void
 countlines(Message *m)
 {
 	int i;
 	char *p;
 
 	i = 0;
 	for(p = strchr(m->rbody, '\n'); p != nil && p < m->rbend; p = strchr(p+1, '\n'))
 		i++;
 	sprint(m->lines, "%d", i);
 }
 
 char *LOG = "fs";
 
 void
 logmsg(char *s, Message *m)
 {
 	int pid;
 
 	if(!logging)
 		return;
 	pid = getpid();
 	if(m == nil)
 		syslog(0, LOG, "%s.%d: %s", user, pid, s);
 	else
 		syslog(0, LOG, "%s.%d: %s msg from %s digest %s",
 			user, pid, s,
 			m->from822 ? s_to_c(m->from822) : "?",
 			s_to_c(m->sdigest));
 }
 
 /*
  *  squeeze nulls out of the body
  */
 static void
 nullsqueeze(Message *m)
 {
 	char *p, *q;
 
 	q = memchr(m->body, 0, m->end-m->body);
 	if(q == nil)
 		return;
 
 	for(p = m->body; q < m->end; q++){
 		if(*q == 0)
 			continue;
 		*p++ = *q;
 	}
 	m->bend = m->rbend = m->end = p;
 }
 
 
 /* */
 /* convert an RFC822 date into a Unix style date */
 /* for when the Unix From line isn't there (e.g. POP3). */
 /* enough client programs depend on having a Unix date */
 /* that it's easiest to write this conversion code once, right here. */
 /* */
 /* people don't follow RFC822 particularly closely, */
 /* so we use strtotm, which is a bunch of heuristics. */
 /* */
 
 extern int strtotm(char*, Tm*);
 String*
 date822tounix(char *s)
 {
 	char *p, *q;
 	Tm tm;
 
 	if(strtotm(s, &tm) < 0)
 		return nil;
 
 	p = asctime(&tm);
 	if(q = strchr(p, '\n'))
 		*q = '\0';
 	return s_copy(p);
 }