Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <bio.h>

#include <libsec.h>

#include <auth.h>

#include <fcall.h>

#include "imap4d.h"

static void	body64(int in, int out);

static void	bodystrip(int in, int out);

static void	cleanupHeader(Header *h);

static char	*domBang(char *s);

static void	freeMAddr(MAddr *a);

static void	freeMimeHdr(MimeHdr *mh);

static char	*headAddrSpec(char *e, char *w);

static MAddr	*headAddresses(void);

static MAddr	*headAddress(void);

static char	*headAtom(char *disallowed);

static int	headChar(int eat);

static char	*headDomain(char *e);

static MAddr	*headMAddr(MAddr *old);

static char	*headPhrase(char *e, char *w);

static char	*headQuoted(int start, int stop);

static char	*headSkipWhite(int);

static void	headSkip(void);

static char	*headSubDomain(void);

static char	*headText(void);

static void	headToEnd(void);

static char	*headWord(void);

static void	mimeDescription(Header *h);

static void	mimeDisposition(Header *h);

static void	mimeEncoding(Header *h);

static void	mimeId(Header *h);

static void	mimeLanguage(Header *h);

static void	mimeMd5(Header *h);

static MimeHdr	*mimeParams(void);

static void	mimeType(Header *h);

static MimeHdr	*mkMimeHdr(char *s, char *t, MimeHdr *next);

static void	msgAddDate(Msg *m);

static void	msgAddHead(Msg *m, char *head, char *body);

static int	msgBodySize(Msg *m);

static int	msgHeader(Msg *m, Header *h, char *file);

static long	msgReadFile(Msg *m, char *file, char **ss);

static int	msgUnix(Msg *m, int top);

static void	stripQuotes(char *q);

static MAddr	*unixFrom(char *s);

static char bogusBody[] = 

	"This message contains null characters, so it cannot be displayed correctly.\r\n"

	"Most likely you were sent a bogus message or a binary file.\r\n"

	"\r\n"

	"Each of the following attachments has a different version of the message.\r\n"

	"The first is inlined with all non-printable characters stripped.\r\n"

	"The second contains the message as it was stored in your mailbox.\r\n"

	"The third has the initial header stripped.\r\n";

static char bogusMimeText[] =

	"Content-Disposition: inline\r\n"

	"Content-Type: text/plain; charset=\"US-ASCII\"\r\n"

	"Content-Transfer-Encoding: 7bit\r\n";

static char bogusMimeBinary[] =

	"Content-Disposition: attachment\r\n"

	"Content-Type: application/octet-stream\r\n"

	"Content-Transfer-Encoding: base64\r\n";

/*

 * stop list for header fields

 */

static char	*headFieldStop = ":";

static char	*mimeTokenStop = "()<>@,;:\\\"/[]?=";

static char	*headAtomStop = "()<>@,;:\\\".[]";

static uchar	*headStr;

static uchar	*lastWhite;

long

selectFields(char *dst, long n, char *hdr, SList *fields, int matches)

{

	SList *f;

	uchar *start;

	char *s;

	long m, nf;

	headStr = (uchar*)hdr;

	m = 0;

	for(;;){

		start = headStr;

		s = headAtom(headFieldStop);

		if(s == nil)

			break;

		headSkip();

		for(f = fields; f != nil; f = f->next){

			if(cistrcmp(s, f->s) == !matches){

				nf = headStr - start;

				if(m + nf > n)

					return 0;

				memmove(&dst[m], start, nf);

				m += nf;

			}

		}

		free(s);

	}

	if(m + 3 > n)

		return 0;

	dst[m++] = '\r';

	dst[m++] = '\n';

	dst[m] = '\0';

	return m;

}

void

freeMsg(Msg *m)

{

	Msg *k, *last;

	free(m->iBuf);

	freeMAddr(m->to);

	if(m->replyTo != m->from)

		freeMAddr(m->replyTo);

	if(m->sender != m->from)

		freeMAddr(m->sender);

	if(m->from != m->unixFrom)

		freeMAddr(m->from);

	freeMAddr(m->unixFrom);

	freeMAddr(m->cc);

	freeMAddr(m->bcc);

	free(m->unixDate);

	cleanupHeader(&m->head);

	cleanupHeader(&m->mime);

	for(k = m->kids; k != nil; ){

		last = k;

		k = k->next;

		freeMsg(last);

	}

	free(m->fs);

	free(m);

}

ulong

msgSize(Msg *m)

{

	return m->head.size + m->size;

}

int

infoIsNil(char *s)

{

	return s == nil || s[0] == '\0';

}

char*

maddrStr(MAddr *a)

{

	char *host, *addr;

	int n;

	host = a->host;

	if(host == nil)

		host = "";

	n = strlen(a->box) + strlen(host) + 2;

	if(a->personal != nil)

		n += strlen(a->personal) + 3;

	addr = emalloc(n);

	if(a->personal != nil)

		snprint(addr, n, "%s <%s@%s>", a->personal, a->box, host);

	else

		snprint(addr, n, "%s@%s", a->box, host);

	return addr;

}

/*

 * return actual name of f in m's fs directory

 * this is special cased when opening m/rawbody, m/mimeheader, or m/rawheader,

 * if the message was corrupted.  in that case,

 * a temporary file is made to hold the base64 encoding of m/raw.

 */

int

msgFile(Msg *m, char *f)

{

	Msg *parent, *p;

	Dir d;

	Tm tm;

	char buf[64], nbuf[2];

	uchar dbuf[64];

	int i, n, fd, fd1, fd2;

	if(!m->bogus

	|| strcmp(f, "") != 0 && strcmp(f, "rawbody") != 0

	&& strcmp(f, "rawheader") != 0 && strcmp(f, "mimeheader") != 0

	&& strcmp(f, "info") != 0 && strcmp(f, "unixheader") != 0){

		if(strlen(f) > MsgNameLen)

			bye("internal error: msgFile name too long");

		strcpy(m->efs, f);

		return cdOpen(m->fsDir, m->fs, OREAD);

	}

	/*

	 * walk up the stupid runt message parts for non-multipart messages

	 */

	parent = m->parent;

	if(parent != nil && parent->parent != nil){

		m = parent;

		parent = m->parent;

	}

	p = m;

	if(parent != nil)

		p = parent;

	if(strcmp(f, "info") == 0 || strcmp(f, "unixheader") == 0){

		strcpy(p->efs, f);

		return cdOpen(p->fsDir, p->fs, OREAD);

	}

	fd = imapTmp();

	if(fd < 0)

		return -1;

	/*

	 * craft the message parts for bogus messages

	 */

	if(strcmp(f, "") == 0){

		/*

		 * make a fake directory for each kid

		 * all we care about is the name

		 */

		if(parent == nil){

			nulldir(&d);

			d.mode = DMDIR|0600;

			d.qid.type = QTDIR;

			d.name = nbuf;

			nbuf[1] = '\0';

			for(i = '1'; i <= '4'; i++){

				nbuf[0] = i;

				n = convD2M(&d, dbuf, sizeof(dbuf));

				if(n <= BIT16SZ)

					fprint(2, "bad convD2M %d\n", n);

				write(fd, dbuf, n);

			}

		}

	}else if(strcmp(f, "mimeheader") == 0){

		if(parent != nil){

			switch(m->id){

			case 1:

			case 2:

				fprint(fd, "%s", bogusMimeText);

				break;

			case 3:

			case 4:

				fprint(fd, "%s", bogusMimeBinary);

				break;

			}

		}

	}else if(strcmp(f, "rawheader") == 0){

		if(parent == nil){

			date2tm(&tm, m->unixDate);

			rfc822date(buf, sizeof(buf), &tm);

			fprint(fd,

				"Date: %s\r\n"

				"From: imap4 daemon <%s@%s>\r\n"

				"To: <%s@%s>\r\n"

				"Subject: This message was illegal or corrupted\r\n"

				"MIME-Version: 1.0\r\n"

				"Content-Type: multipart/mixed;\r\n\tboundary=\"upas-%s\"\r\n",

					buf, username, site, username, site, m->info[IDigest]);

		}

	}else if(strcmp(f, "rawbody") == 0){

		fd1 = msgFile(p, "raw");

		strcpy(p->efs, "rawbody");

		fd2 = cdOpen(p->fsDir, p->fs, OREAD);

		if(fd1 < 0 || fd2 < 0){

			close(fd);

			close(fd1);

			close(fd2);

			return -1;

		}

		if(parent == nil){

			fprint(fd,

				"This is a multi-part message in MIME format.\r\n"

				"--upas-%s\r\n"

				"%s"

				"\r\n"

				"%s"

				"\r\n",

					m->info[IDigest], bogusMimeText, bogusBody);

			fprint(fd,

				"--upas-%s\r\n"

				"%s"

				"\r\n",

					m->info[IDigest], bogusMimeText);

			bodystrip(fd1, fd);

			fprint(fd,

				"--upas-%s\r\n"

				"%s"

				"\r\n",

					m->info[IDigest], bogusMimeBinary);

			seek(fd1, 0, 0);

			body64(fd1, fd);

			fprint(fd,

				"--upas-%s\r\n"

				"%s"

				"\r\n",

					m->info[IDigest], bogusMimeBinary);

			body64(fd2, fd);

			fprint(fd, "--upas-%s--\r\n", m->info[IDigest]);

		}else{

			switch(m->id){

			case 1:

				fprint(fd, "%s", bogusBody);

				break;

			case 2:

				bodystrip(fd1, fd);

				break;

			case 3:

				body64(fd1, fd);

				break;

			case 4:

				body64(fd2, fd);

				break;

			}

		}

		close(fd1);

		close(fd2);

	}

	seek(fd, 0, 0);

	return fd;

}

int

msgIsMulti(Header *h)

{

	return h->type != nil && cistrcmp("multipart", h->type->s) == 0;

}

int

msgIsRfc822(Header *h)

{

	return h->type != nil && cistrcmp("message", h->type->s) == 0 && cistrcmp("rfc822", h->type->t) == 0;

}

/*

 * check if a message has been deleted by someone else

 */

void

msgDead(Msg *m)

{

	if(m->expunged)

		return;

	*m->efs = '\0';

	if(!cdExists(m->fsDir, m->fs))

		m->expunged = 1;

}

/*

 * make sure the message has valid associated info

 * used for ISubject, IDigest, IInReplyTo, IMessageId.

 */

int

msgInfo(Msg *m)

{

	char *s;

	int i;

	if(m->info[0] != nil)

		return 1;

	i = msgReadFile(m, "info", &m->iBuf);

	if(i < 0)

		return 0;

	s = m->iBuf;

	for(i = 0; i < IMax; i++){

		m->info[i] = s;

		s = strchr(s, '\n');

		if(s == nil)

			break;

		*s++ = '\0';

	}

	for(; i < IMax; i++)

		m->info[i] = nil;

	for(i = 0; i < IMax; i++)

		if(infoIsNil(m->info[i]))

			m->info[i] = nil;

	return 1;

}

/*

 * make sure the message has valid mime structure

 * and sub-messages

 */

int

msgStruct(Msg *m, int top)

{

	Msg *k, head, *last;

	Dir *d;

	char *s;

	ulong max, id;

	int i, nd, fd, ns;

	if(m->kids != nil)

		return 1;

	if(m->expunged

	|| !msgInfo(m)

	|| !msgUnix(m, top)

	|| !msgBodySize(m)

	|| !msgHeader(m, &m->mime, "mimeheader")

	|| (top || msgIsRfc822(&m->mime) || msgIsMulti(&m->mime)) && !msgHeader(m, &m->head, "rawheader")){

		if(top && m->bogus && !(m->bogus & BogusTried)){

			m->bogus |= BogusTried;

			return msgStruct(m, top);

		}

		msgDead(m);

		return 0;

	}

	/*

	 * if a message has no kids, it has a kid which is just the body of the real message

	 */

	if(!msgIsMulti(&m->head) && !msgIsMulti(&m->mime) && !msgIsRfc822(&m->head) && !msgIsRfc822(&m->mime)){

		k = MKZ(Msg);

		k->id = 1;

		k->fsDir = m->fsDir;

		k->bogus = m->bogus;

		k->parent = m->parent;

		ns = m->efs - m->fs;

		k->fs = emalloc(ns + (MsgNameLen + 1));

		memmove(k->fs, m->fs, ns);

		k->efs = k->fs + ns;

		*k->efs = '\0';

		k->size = m->size;

		m->kids = k;

		return 1;

	}

	/*

	 * read in all child messages messages

	 */

	fd = msgFile(m, "");

	if(fd < 0){

		msgDead(m);

		return 0;

	}

	max = 0;

	head.next = nil;

	last = &head;

	while((nd = dirread(fd, &d)) > 0){

		for(i = 0; i < nd; i++){

			s = d[i].name;

			id = strtol(s, &s, 10);

			if(id <= max || *s != '\0'

			|| (d[i].mode & DMDIR) != DMDIR)

				continue;

			max = id;

			k = MKZ(Msg);

			k->id = id;

			k->fsDir = m->fsDir;

			k->bogus = m->bogus;

			k->parent = m;

			ns = strlen(m->fs);

			k->fs = emalloc(ns + 2 * (MsgNameLen + 1));

			k->efs = seprint(k->fs, k->fs + ns + (MsgNameLen + 1), "%s%lud/", m->fs, id);

			k->prev = last;

			k->size = ~0UL;

			k->lines = ~0UL;

			last->next = k;

			last = k;

		}

	}

	close(fd);

	m->kids = head.next;

	/*

	 * if kids fail, just whack them

	 */

	top = top && (msgIsRfc822(&m->head) || msgIsMulti(&m->head));

	for(k = m->kids; k != nil; k = k->next){

		if(!msgStruct(k, top)){

			for(k = m->kids; k != nil; ){

				last = k;

				k = k->next;

				freeMsg(last);

			}

			m->kids = nil;

			break;

		}

	}

	return 1;

}

static long

msgReadFile(Msg *m, char *file, char **ss)

{

	Dir *d;

	char *s, buf[BufSize];

	vlong length;

	long n, nn;

	int fd;

	fd = msgFile(m, file);

	if(fd < 0){

		msgDead(m);

		return -1;

	}

	n = read(fd, buf, BufSize);

	if(n < BufSize){

		close(fd);

		if(n < 0){

			*ss = nil;

			return -1;

		}

		s = emalloc(n + 1);

		memmove(s, buf, n);

		s[n] = '\0';

		*ss = s;

		return n;

	}

	d = dirfstat(fd);

	if(d == nil){

		close(fd);

		return -1;

	}

	length = d->length;

	free(d);

	nn = length;

	s = emalloc(nn + 1);

	memmove(s, buf, n);

	if(nn > n)

		nn = readn(fd, s+n, nn-n) + n;

	close(fd);

	if(nn != length){

		free(s);

		return -1;

	}

	s[nn] = '\0';

	*ss = s;

	return nn;

}

static void

freeMAddr(MAddr *a)

{

	MAddr *p;

	while(a != nil){

		p = a;

		a = a->next;

		free(p->personal);

		free(p->box);

		free(p->host);

		free(p);

	}

}

/*

 * the message is corrupted or illegal.

 * reset message fields.  msgStruct will reparse the message,

 * relying on msgFile to make up corrected body parts.

 */

static int

msgBogus(Msg *m, int flags)

{

	if(!(m->bogus & flags))

		m->bogus |= flags;

	m->lines = ~0;

	free(m->head.buf);

	free(m->mime.buf);

	memset(&m->head, 0, sizeof(Header));

	memset(&m->mime, 0, sizeof(Header));

	return 0;

}

/*

 *  stolen from upas/marshal; base64 encodes from one fd to another.

 *

 *  the size of buf is very important to enc64.  Anything other than

 *  a multiple of 3 will cause enc64 to output a termination sequence.

 *  To ensure that a full buf corresponds to a multiple of complete lines,

 *  we make buf a multiple of 3*18 since that's how many enc64 sticks on

 *  a single line.  This avoids short lines in the output which is pleasing

 *  but not necessary.

 */

static int

enc64x18(char *out, int lim, uchar *in, int n)

{

	int m, mm, nn;

	nn = 0;

	for(; n > 0; n -= m){

		m = 18 * 3;

		if(m > n)

			m = n;

		mm = enc64(out, lim - nn, in, m);

		in += m;

		out += mm;

		*out++ = '\r';

		*out++ = '\n';

		nn += mm + 2;

	}

	return nn;

}

static void

body64(int in, int out)

{

	uchar buf[3*18*54];

	char obuf[3*18*54*2];

	int m, n;

	for(;;){

		n = read(in, buf, sizeof(buf));

		if(n < 0)

			return;

		if(n == 0)

			break;

		m = enc64x18(obuf, sizeof(obuf), buf, n);

		if(write(out, obuf, m) < 0)

			return;

	}

}

/*

 * strip all non-printable characters from a file

 */

static void

bodystrip(int in, int out)

{

	uchar buf[3*18*54];

	int m, n, i, c;

	for(;;){

		n = read(in, buf, sizeof(buf));

		if(n < 0)

			return;

		if(n == 0)

			break;

		m = 0;

		for(i = 0; i < n; i++){

			c = buf[i];

			if(c > 0x1f && c < 0x7f		/* normal characters */

			|| c >= 0x9 && c <= 0xd)	/* \t, \n, vertical tab, form feed, \r */

				buf[m++] = c;

		}

		if(m && write(out, buf, m) < 0)

			return;

	}

}

/*

 * read in the message body to count \n without a preceding \r

 */

static int

msgBodySize(Msg *m)

{

	Dir *d;

	char buf[BufSize + 2], *s, *se;

	vlong length;

	ulong size, lines, bad;

	int n, fd, c;

	if(m->lines != ~0UL)

		return 1;

	fd = msgFile(m, "rawbody");

	if(fd < 0)

		return 0;

	d = dirfstat(fd);

	if(d == nil){

		close(fd);

		return 0;

	}

	length = d->length;

	free(d);

	size = 0;

	lines = 0;

	bad = 0;

	buf[0] = ' ';

	for(;;){

		n = read(fd, &buf[1], BufSize);

		if(n <= 0)

			break;

		size += n;

		se = &buf[n + 1];

		for(s = &buf[1]; s < se; s++){

			c = *s;

			if(c == '\0'){

				close(fd);

				return msgBogus(m, BogusBody);

			}

			if(c != '\n')

				continue;

			if(s[-1] != '\r')

				bad++;

			lines++;

		}

		buf[0] = buf[n];

	}

	if(size != length)

		bye("bad length reading rawbody");

	size += bad;

	m->size = size;

	m->lines = lines;

	close(fd);

	return 1;

}

/*

 * retrieve information from the unixheader file

 */

static int

msgUnix(Msg *m, int top)

{

	Tm tm;

	char *s, *ss;

	if(m->unixDate != nil)

		return 1;

	if(!top){

bogus:

		m->unixDate = estrdup("");

		m->unixFrom = unixFrom(nil);

		return 1;

	}

	if(msgReadFile(m, "unixheader", &ss) < 0)

		return 0;

	s = ss;

	s = strchr(s, ' ');

	if(s == nil){

		free(ss);

		goto bogus;

	}

	s++;

	m->unixFrom = unixFrom(s);

	s = (char*)headStr;

	if(date2tm(&tm, s) == nil)

		s = m->info[IUnixDate];

	if(s == nil){

		free(ss);

		goto bogus;

	}

	m->unixDate = estrdup(s);

	free(ss);

	return 1;

}

/*

 * parse the address in the unix header

 * last line of defence, so must return something

 */

static MAddr *

unixFrom(char *s)

{

	MAddr *a;

	char *e, *t;

	if(s == nil)

		return nil;

	headStr = (uchar*)s;

	t = emalloc(strlen(s) + 2);

	e = headAddrSpec(t, nil);

	if(e == nil)

		a = nil;

	else{

		if(*e != '\0')

			*e++ = '\0';

		else

			e = site;

		a = MKZ(MAddr);

		a->box = estrdup(t);

		a->host = estrdup(e);

	}

	free(t);

	return a;

}

/*

 * read in the entire header,

 * and parse out any existing mime headers

 */

static int

msgHeader(Msg *m, Header *h, char *file)

{

	char *s, *ss, *t, *te;

	ulong lines, n, nn;

	long ns;

	int dated, c;

	if(h->buf != nil)

		return 1;

	ns = msgReadFile(m, file, &ss);

	if(ns < 0)

		return 0;

	s = ss;

	n = ns;

	/*

	 * count lines ending with \n and \r\n

	 * add an extra line at the end, since upas/fs headers

	 * don't have a terminating \r\n

	 */

	lines = 1;

	te = s + ns;

	for(t = s; t < te; t++){

		c = *t;

		if(c == '\0')

			return msgBogus(m, BogusHeader);

		if(c != '\n')

			continue;

		if(t == s || t[-1] != '\r')

			n++;

		lines++;

	}

	if(t > s && t[-1] != '\n'){

		if(t[-1] != '\r')

			n++;

		n++;

	}

	n += 2;

	h->buf = emalloc(n + 1);

	h->size = n;

	h->lines = lines;

	/*

	 * make sure all headers end in \r\n

	 */

	nn = 0;

	for(t = s; t < te; t++){

		c = *t;

		if(c == '\n'){