rohrpost

mime.c (26639B)

---

 /*
  * Copy me if you can.
  * by 20h
  */
 
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 #include <ctype.h>
 #include <iconv.h>
 #include <errno.h>
 #include <time.h>
 
 #include "ind.h"
 #include "llist.h"
 #include "mime.h"
 #include "parser.h"
 #include "base64.h"
 #include "quote.h"
 #include "param.h"
 #include "dos.h"
 
 enum {
 	HEADER = 0x01,
 	HEADERVALUE,
 };
 
 mime_t *
 mime_new(void)
 {
 	mime_t *part;
 
 	part = mallocz(sizeof(mime_t), 2);
 	part->hdrs = llist_new();
 	part->parts = llist_new();
 	part->state = HEADER;
 
 	return part;
 }
 
 void
 mime_subfree(mime_t *mime, llistelem_t *elem)
 {
 	forllist(mime->parts, elem) {
 		if (elem->key == NULL)
 			mime_free((mime_t *)elem->data);
 		elem->data = NULL;
 	}
 	llist_free(mime->parts);
 }
 
 void
 mime_free(mime_t *mime)
 {
 	mime_subfree(mime, NULL);
 	llist_free(mime->hdrs);
 
 	if (mime->body != NULL)
 		free(mime->body);
 	if (mime->partid != NULL)
 		free(mime->partid);
 	if (mime->ct != NULL)
 		free(mime->ct);
 	if (mime->cte != NULL)
 		free(mime->cte);
 	if (mime->charset != NULL)
 		free(mime->charset);
 	if (mime->boundary != NULL)
 		free(mime->boundary);
 	if (mime->rawhdrs != NULL)
 		free(mime->rawhdrs);
 	free(mime);
 }
 
 struct tm *
 mime_parsedate(char *str)
 {
 	struct tm tim;
 
 	memset(&tim, 0, sizeof(tim));
 	if (strptime(str, "%a, %d %b %Y %T %z", &tim) != NULL)
 		return memdup(&tim, sizeof(tim));
 
 	if (!strncmp(str, "Date: ", 6))
 		str += 6;
 
 	/*
 	 * Malformatted dates seen in the wild.
 	 */
 	if (strptime(str, "%a, %d %b %Y %T %Z", &tim) != NULL)
 		return memdup(&tim, sizeof(tim));
 
 	if (strptime(str, "%d %b %Y %T %z", &tim) != NULL)
 		return memdup(&tim, sizeof(tim));
 
 	if (strptime(str, "%a, %d %b %Y, %T %z", &tim) != NULL)
 		return memdup(&tim, sizeof(tim));
 
 	if (strptime(str, "%d.%m.%Y", &tim) != NULL)
 		return memdup(&tim, sizeof(tim));
 
 	return memdup(&tim, sizeof(tim));
 }
 
 char *
 mime_iconv(char *str, char *from, char *to)
 {
 	iconv_t *ifd;
 	size_t left, avail, nconv;
 	char *outb, *strp, *outbp;
 	int olen, sd;
 
 	ifd = iconv_open(to, from);
 	if (ifd == (iconv_t)-1)
 		return NULL;
 
 	//printf("mime_iconv: '%s'; from='%s'\n", str, from);
 
 	left = strlen(str);
 	olen = left / 2;
 	avail = olen;
 	outb = mallocz(olen+1, 1);
 	outbp = outb;
 	strp = str;
 	for (;;) {
 		nconv = iconv(ifd, &strp, &left, &outbp, &avail);
 		if (nconv == (size_t)-1) {
 			if (errno == E2BIG) {
 				olen += 5;
 				sd = outbp - outb;
 				outb = reallocz(outb, olen+1, 0);
 				outbp = &outb[sd];
 				avail += 5;
 				continue;
 			}
 			if (errno == EILSEQ || errno == EINVAL)
 				return NULL;
 			free(outb);
 			iconv_close(ifd);
 			return NULL;
 		}
 		break;
 	}
 
 	iconv_close(ifd);
 	if (outbp != NULL)
 		outbp[0] = '\0';
 	return outb;
 }
 
 char *
 mime_decodeheaderext(char *value)
 {
 	char *work, *cret, *ret, *cs, *str, *enc, *ast, *dstr;
 	int len, slen;
 
 	len = strlen(value);
 
 	ret = memdupz(value, len);
 	work = memdupz(value, len);
 
 	if (!(work[0] == '=' && work[1] == '?' && work[len-1] == '='
 				&& work[len-2] == '?')) {
 		free(work);
 		return ret;
 	}
 	cs = &work[2];
 
 	work[len-2] = '\0';
 	enc = strchr(&work[2], '?');
 	if (enc == NULL) {
 		free(work);
 		return ret;
 	}
 	enc[0] = '\0';
 	enc++;
 	str = strchr(enc, '?');
 	if (str == NULL) {
 		free(work);
 		return ret;
 	}
 	str[0] = '\0';
 	str++;
 
 	/*
 	 * RFC 2231 :(
 	 * See: https://en.wikipedia.org/wiki/Mr._Mime
 	 */
 	ast = strchr(enc, '*');
 	if (ast != NULL)
 		ast[0] = '\0';
 
 	slen = strlen(str);
 	if (slen == 0) {
 		free(work);
 		free(ret);
 		return memdupz("", 1);
 	}
 
 	cret = NULL;
 	switch(enc[0]) {
 	case 'B':
 	case 'b':
 		cret = b64dec(str, &slen);
 		break;
 	case 'Q':
 	case 'q':
 		cret = qpdec(str, &slen, 1);
 		break;
 	}
 
 	//printf("mime_decodeheader: mime_iconv str='%s'; cret='%s';\n", str, cret);
 	if (cret != NULL) {
 		free(ret);
 		if (strcasecmp(cs, "utf-8")) {
 			dstr = mime_iconv(cret, cs, "UTF-8");
 			if (dstr == NULL) {
 				str = smprintf("ERR(%s)", str);
 			} else {
 				str = dstr;
 			}
 			free(cret);
 		} else {
 			str = cret;
 		}
 	} else {
 		str = ret;
 	}
 	free(work);
 
 	return str;
 }
 
 int
 mime_isextws(char *str, int len)
 {
 	int i;
 
 	for (i = 0; i < len; i++) {
 		switch (str[i]) {
 		case '\n':
 		case '\r':
 		case ' ':
 		case '\t':
 			break;
 		default:
 			return 0;
 		}
 	}
 	return 1;
 }
 
 char *
 mime_decodeheader(char *value)
 {
 	char *work, *extp, *extw, *extb, *exte, *extr, *ret, *q1, *q2;
 	int vlen, rlen, elen, wasenc, i;
 
 	//printf("mime_decodeheader\n");
 	ret = NULL;
 	rlen = 0;
 	vlen = strlen(value);
 	work = memdup(value, vlen+1);
 	extp = work;
 	wasenc = 0;
 
 	/*
 	 * Avoid being tricked by malformed headers.
 	 */
 	for (i = 0; i < 32; i++) {
 		extb = strstr(extp, "=?");
 		if (extb != NULL) {
 			elen = extb - extp;
 			if (extp != extb && (!wasenc ||
 					!mime_isextws(extp, elen))) {
 				extw = memdupz(extp, elen);
 				ret = memdupcat(ret, rlen, extw, elen+1);
 				free(extw);
 				rlen += elen;
 			}
 
 			exte = NULL;
 			q1 = strchr(&extb[2], '?');
 			if (q1 != NULL) {
 				q2 = strchr(&q1[1], '?');
 				if (q2 != NULL)
 					exte = strstr(&q2[1], "?=");
 			}
 			if (exte != NULL) {
 				elen = &exte[2] - extb;
 				extw = memdupz(extb, elen);
 				extr = mime_decodeheaderext(extw);
 				free(extw);
 				elen = strlen(extr);
 				ret = memdupcat(ret, rlen, extr, elen+1);
 				rlen += elen;
 				free(extr);
 				extp = &exte[2];
 				wasenc = 1;
 				continue;
 			}
 		}
 		break;
 	}
 	if ((extp - work) < vlen)
 		ret = memdupcat(ret, rlen, extp, strlen(extp)+1);
 	free(work);
 
 	/* Remove any space character, like newline. */
 	if (ret != NULL)
 		strnormalizespace(ret);
 
 	return ret;
 }
 
 char *cstries[] = {
 	"utf-8",
 	"iso-8859-1",
 	"windows-1252",
 	"koi8",
 	"euc-jp"
 	"shift_jis",
 	"big5",
 	"iso-8859-15",
 	NULL
 };
 
 char *
 mime_guesscharset(char *str)
 {
 	int i, eq;
 	char *itry;
 
 	for (i = 0; i < nelem(cstries); i++) {
 		itry = mime_iconv(str, cstries[i], cstries[i]);
 		if (itry == NULL)
 			continue;
 		eq = strcmp(str, itry);
 		free(itry);
 		if (!eq)
 			break;
 	}
 
 	return cstries[i];
 }
 
 char *
 mime_guessheader(char *value)
 {
 	char *nvalue, *gcs;
 
 	gcs = NULL;
 
 	//printf("mime_guessheader '%s'\n", value);
 
 	nvalue = value;
 	if (!strisascii(value)) {
 		/*
 		 * Guessing begins. Some major MUA developers did not read any
 		 * RFCs.
 		 */
 
 		gcs = mime_guesscharset(value);
 		if (gcs != NULL) {
 			nvalue = mime_iconv(value, gcs, "utf-8");
 			if (nvalue == NULL) {
 				nvalue = value;
 				gcs = NULL;
 			}
 		}
 	}
 
 	value = mime_decodeheader(nvalue);
 	if (gcs != NULL)
 		free(nvalue);
 	return value;
 }
 
 char *
 mime_decodeparam(char *value)
 {
 	char *work, *cret, *ret, *cs, *str, *lang, *dstr;
 	int len, slen;
 
 	len = strlen(value);
 	ret = memdup(value, len+1);
 	work = memdup(value, len+1);
 
 	cs = work;
 	lang = strchr(work, '\'');
 	if (lang == NULL) {
 		free(work);
 		return ret;
 	}
 	lang[0] = '\0';
 	lang++;
 	str = strchr(lang, '\'');
 	if (str == NULL) {
 		free(work);
 		return ret;
 	}
 	str[0] = '\0';
 	str++;
 
 	slen = strlen(str);
 	cret = paramdec(str, &slen);
 
 	if (cret != NULL) {
 		if (strcasecmp(cs, "utf-8")) {
 			free(ret);
 			dstr = mime_iconv(cret, cs, "UTF-8");
 			if (dstr == NULL) {
 				str = smprintf("ERR(%s)", str);
 			} else {
 				str = dstr;
 			}
 			free(cret);
 		} else {
 			free(ret);
 			str = cret;
 		}
 	} else {
 		str = ret;
 	}
 	free(work);
 
 	return str;
 }
 
 char *
 mime_encodestring(char *value)
 {
 	char *b64, *ret;
 
 	if (strisascii(value))
 		return memdups(value);
 
 	b64 = b64enc(value, strlen(value));
 	ret = smprintf("=?UTF-8?b?%s?=", b64);
 	free(b64);
 
 	return ret;
 }
 
 char *
 mime_encodeheader(char *header, char *value)
 {
 	char *ret, *b64, *p, *mp, *str;
 	int hlen, lmax, isascii, firstline, slen;
 
 	isascii = 0;
 
 	/*
 	 * RFC 2047:
 	 *  One encoded word should be at max. 75 characters.
 	 *  One encoded line is limited to 76 characters.
 	 */
 	hlen = strlen(header) + 2;
 	if (strisascii(value)) {
 		isascii = 1;
 		lmax = 75 - hlen;
 	} else {
 		lmax = 63 - hlen;
 	}
 	slen = strlen(value);
 
 	ret = NULL;
 	for (p = value, firstline = 1; slen > 0; slen -= lmax, p = mp) {
 		if (firstline) {
 			lmax += hlen;
 			firstline = 0;
 		}
 
 		mp = findlimitws(p, lmax);
 		if (mp == NULL) {
 			str = memdupz(p, slen);
 		} else {
 			str = memdupz(p, mp - p);
 		}
 
 		if (!isascii) {
 			b64 = b64enc(str, strlen(str));
 			free(str);
 			mp = smprintf("=?UTF-8?b?%s?=", b64);
 			free(b64);
 			str = mp;
 		}
 
 		if (ret != NULL) {
 			mp = smprintf("%s %s", ret, str);
 			free(ret);
 			ret = mp;
 		} else {
 			ret = smprintf("%s", str);
 		}
 	}
 
 	return ret;
 }
 
 int
 mime_paramsort(llistelem_t *elem1, llistelem_t *elem2)
 {
 	int a, b;
 	char *n1, *n2;
 
 	n1 = strrchr(elem1->key, '*');
 	if (n1 == NULL)
 		a = -1;
 	else
 		a = atoi(&n1[1]);
 	n2 = strrchr(elem2->key, '*');
 	if (n2 == NULL)
 		b = -1;
 	else
 		b = atoi(&n2[1]);
 
 	return a - b;
 }
 
 /*
  * Order and concatenate ordered params.
  */
 llist_t *
 mime_sanitizeparams(llist_t *params)
 {
 	llistelem_t *param, *hit, *nparam;
 	llist_t *reorder, *hits;
 	char *nvalue, *dvalue;
 	int i, n;
 	//char *key;
 	//int klen;
 
 	reorder = llist_new();
 	//printf("mime_sanitizeparams: start\n");
 	n = 0;
 	forllist(params, param) {
 		if (n == 0) {
 			//printf("first key: %s\n", param->key);
 			n++;
 			continue;
 		}
 
 		//key = param->key;
 		//printf("key = %s\n", key);
 		//klen = strlen(key);
 
 		nvalue = strrchr(param->key, '*');
 		if (nvalue == NULL)
 			continue;
 		for (i = 1; nvalue[i]; i++)
 			if (!isdigit(nvalue[i]))
 				break;
 		if (nvalue[i])
 			continue;
 		//printf("nvalue = %s\n", nvalue);
 
 		dvalue = mime_decodeparam((char *)param->data);
 		if (dvalue != NULL) {
 			//printf("decoded: %s\n", dvalue);
 			free(param->data);
 			param->data = dvalue;
 			param->datalen = strlen(dvalue)+1;
 		}
 
 		nvalue[0] = '\0';
 		//printf("key after = %s\n", key);
 		if (llist_get(reorder, param->key) != NULL)
 			llist_add(reorder, param->key, NULL, 0);
 		nvalue[0] = '*';
 	}
 
 	/*
 	 * Sort and concatenate the return list.
 	 */
 	forllist(reorder, param) {
 		hits = llist_new();
 		forllist(params, nparam) {
 			if (!strncmp(nparam->key, param->key,
 						strlen(param->key))) {
 				//printf("nparam->key = %s\n", nparam->key);
 				llist_add(hits, nparam->key, nparam->data,
 						nparam->datalen);
 			}
 		}
 		if (hits->len < 1) {
 			llist_free(hits);
 			continue;
 		}
 
 		nparam = llistelem_new(param->key, NULL, 0);
 		hits = llist_internsort(hits, mime_paramsort);
 
 		forllist(hits, hit) {
 			nparam->data = memdupcat(nparam->data,
 					nparam->datalen, hit->data,
 					hit->datalen);
 			nparam->datalen += hit->datalen-1;
 		}
 
 		params = llist_listdel(params, hits);
 		llist_free(hits);
 		llist_addelem(params, nparam);
 	}
 	llist_free(reorder);
 
 	return params;
 }
 
 llist_t *
 mime_parseheader(char *field)
 {
 	char *tok, *buf, *key, *value, *sep, *eq, quot;
 	llist_t *ret;
 	int tlen;
 
 	buf = memdups(field);
 
 	tok = buf;
 	ret = llist_new();
 	//printf("mime_parseheader: buf = '%s'\n", buf);
 	while (tok[0] != '\0') {
 		key = NULL;
 		value = NULL;
 
 		/*
 		 * 0.) Sanitize the beginning and the end.
 		 */
 		while (isspace(tok[0]))
 			tok++;
 		tlen = strlen(tok);
 		while (isspace(tok[tlen-1])) {
 			tok[tlen-1] = '\0';
 			tlen--;
 		}
 		//printf("mime_parseheader: after sanitize: tok = '%s'\n", tok);
 
 		/*
 		 * 1.) ([\t\r\v\f ]*)key
 		 */
 		key = tok + strspn(tok, "\t\r\v\f ");
 		//printf("mime_parseheader: key = '%s'\n", tok);
 
 		/*
 		 * 2.) key
 		 */
 		tok = key + strcspn(key, "\t\r\v\f =;");
 		if (tok[0] == ';' || tok[0] == '\0') {
 			quot = tok[0];
 			tok[0] = '\0';
 			if (strlen(key) > 0) {
 				//printf("mime_parseheader: add key '%s'\n", key);
 				llist_add(ret, key, NULL, 0);
 			}
 			if (quot != '\0')
 				tok++;
 			continue;
 		}
 
 		//printf("mime_parseheader: tok = '%s'\n", tok);
 		if (tok[0] == '=') {
 			eq = tok;
 		} else {
 			/*
 			 * 3.) key([\t\r\v\f ]*)=
 			 */
 			tok[0] = '\0';
 			eq = tok + 1 + strspn(tok+1, "\t\r\v\f ;");
 			if (eq[0] == ';') {
 				if (strlen(key) > 0)
 					llist_add(ret, key, NULL, 0);
 				tok++;
 				continue;
 			}
 
 			if (eq[0] != '=') {
 				/*
 				 * 3.1.) key;
 				 */
 				if (strlen(key) > 0)
 					llist_add(ret, key, NULL, 0);
 				tok++;
 				continue;
 			}
 		}
 		tok[0] = '\0';
 		/*
 		 * 4.) key=([\t\r\v\f ]*)("|)value
 		 */
 		tok = eq + 1 + strspn(eq+1, "\t\r\v\f ");
 		switch (tok[0]) {
 		case '"':
 		case '\'':
 			quot = tok[0];
 			for (sep = tok+1; sep[0] != '\0'; sep++) {
 				if (sep[0] == quot) {
 					sep[0] = '\0';
 					sep++;
 					break;
 				}
 				if (sep[0] == '\\' && sep[1] != '\0')
 					memmove(&sep[1], sep, strlen(&sep[1]));
 			}
 			value = &tok[1];
 			tok = sep;
 
 			sep = tok + strcspn(tok, ";");
 			if (sep[0] == ';') {
 				tok = sep + 1;
 			} else {
 				tok = sep;
 			}
 			break;
 		default:
 			/*
 			 * 4.1.) value
 			 */
 			value = tok;
 			sep = tok + strcspn(tok, "\t\r\v\f ;");
 			if (sep[0] == ';') {
 				sep[0] = '\0';
 				tok = sep + 1;
 			} else {
 				tok = sep;
 			}
 			break;
 		}
 
 		//printf("mime_parseheader: add %s = '%s'\n", key, value);
 		llist_add(ret, key, value, strlen(value)+1);
 	}
 	free(buf);
 
 	//printf("ret->len = %d\n", ret->len);
 	if (ret->len > 0)
 		return mime_sanitizeparams(ret);
 
 	llist_free(ret);
 	return NULL;
 }
 
 void
 mime_mkpartidsintern(mime_t *mime, char *sect, int pid)
 {
 	llistelem_t *part;
 
 	mime->partid = smprintf("%s%d", sect, pid);
 	sect = smprintf("%s.", mime->partid);
 
 	pid = 1;
 	forllist(mime->parts, part) {
 		mime_mkpartidsintern((mime_t *)part->data, sect, pid);
 		pid++;
 	}
 	free(sect);
 }
 
 void
 mime_mkpartids(mime_t *mime)
 {
 	int pid;
 	llistelem_t *part;
 
 	mime->partid = memdupz("0", 1);
 	pid = 1;
 	forllist(mime->parts, part)
 		mime_mkpartidsintern((mime_t *)part->data, "", pid++);
 }
 
 /*
  * This functions searches for the next boundary occurence. It will
  * return *choice = 1, if it was an end boundary; otherwise 0.
  */
 char *
 mime_sgetbound(char *bound, char **p, char *max, int *len, int *choice)
 {
 	char *ret, *op;
 	int slen, isenl, isend, sublen;
 
 	ret = NULL;
 
 	//printf("bound = '%s'\n", bound);
 	//printf("p = '%s'\n", *p);
 	slen = strlen(bound);
 	*choice = 0;
 	isenl = 0;
 	isend = 0;
 	sublen = 0;
 
 	for (;;) {
 		op = memmem(*p, (max-(*p)), bound, slen);
 		if (op == NULL)
 			return ret;
 
 		if (!strncmp(op+slen, "--", 2)) {
 			isend = 1;
 			if (op[slen+2] == '\n')
 				isenl = 1;
 		} else if (op[slen] == '\n') {
 			isenl = 1;
 		}
 		//printf("isenl = %d, isend = %d\n", isenl, isend);
 
 		if (op == *p)
 			break;
 
 		if (op > (*p + 1) && op[-2] == '\r' && op[-1] == '\n')
 			sublen = 2;
 		if (op > *p && op[-2] != '\r' && op[-1] == '\n')
 			sublen = 1;
 		//printf("sublen = %d\n", sublen);
 		break;
 	}
 
 	if (isend) {
 		*choice = 1;
 		slen += 2;
 	}
 
 	*len = op - *p - sublen;
 	ret = memdupz(*p, *len);
 
 	*p = op + slen + (isend * 2) + (2 - isenl);
 
 	//printf("p = '%s'\n", *p);
 
 	return ret;
 }
 
 mime_t *
 mime_preparepart(mime_t *mime)
 {
 	llistelem_t *hdr, *field;
 	llist_t *hdrf;
 
 	//printf("mime = %p\n", mime);
 	hdr = llist_ciget(mime->hdrs, "content-type");
 	if (hdr != NULL && hdr->data != NULL && strlen(hdr->data) > 0) {
 		//printf("content-type: %s\n", (char *)hdr->data);
 		hdrf = mime_parseheader(hdr->data);
 		//printf("hdrf = %p\n", hdrf);
 		//printf("%s\n", hdrf->first->key);
 		if (hdrf != NULL) {
 			if (!strncasecmp(hdrf->first->key, "multipart", 9)) {
 				//printf("is multipart\n");
 				field = llist_ciget(hdrf, "boundary");
 				if (field == NULL) {
 					return NULL;
 					//die("Could not find boundary "
 					//	"in multipart!\n");
 				}
 				mime->boundary = smprintf("--%s",
 						(char *)field->data);
 				//printf("boundary: \"%s\"\n", mime->boundary);
 			}
 			mime->ct = memdups(hdrf->first->key);
 
 			field = llist_ciget(hdrf, "charset");
 			if (field != NULL && field->data != NULL) {
 				mime->charset = memdupz(field->data,
 						field->datalen);
 			}
 
 			llist_free(hdrf);
 		}
 	}
 
 	if (mime->ct == NULL)
 		mime->ct = memdupz("text/plain", 10);
 	//printf("mime->ct = %s\n", mime->ct);
 	if (mime->charset == NULL)
 		mime->charset = memdupz("iso8859-1", 9);
 	//printf("mime->charset = %s\n", mime->charset);
 
 	hdr = llist_ciget(mime->hdrs, "Content-Transfer-Encoding");
 	if (hdr != NULL && hdr->data != NULL) {
 		mime->cte = memdupz(hdr->data, hdr->datalen);
 	} else {
 		mime->cte = memdupz("7bit", 4);
 	}
 	//printf("mime->cte = %s\n", mime->cte);
 
 	return mime;
 }
 
 mime_t *
 mime_parsebufintern(mime_t *mime, char *str, int len)
 {
 	int i, partlen, isend, blen;
 	char *p, *rp, buf[1025], *key, *value, *tvalue, *part;
 	llistelem_t *hdr;
 	mime_t *partm;
 
 	rp = str;
 	p = str;
 	for (; (rp = sgets(buf, sizeof(buf)-1, &p));) {
 		blen = strlen(buf);
 		if (buf[blen-1] == '\r')
 			buf[blen-1] = '\0';
 		//printf("line '%s'\n", buf);
 
 		switch (mime->state) {
 		case HEADERVALUE:
 			switch (buf[0]) {
 			case ' ':
 			case '\t':
 			case '\r':
 			case '\f':
 			case '\v':
 				//printf("hdrvalue: %s (%d)\n", buf,
 				//		(int)strlen(buf));
 				/*
 				 * " value"
 				 */
 				sscanf(buf, "%*[ \t\r\v\f]%1024m[^\n]",
 						&value);
 				if (value != NULL && hdr != NULL) {
 					if (hdr->data != NULL) {
 						part = memdup(value, strlen(value)+1);
 
 						/* Adding a space. */
 						hdr->data = memdupcat(hdr->data,
 								hdr->datalen-1,
 								" ", 1);
 						hdr->datalen++;
 
 						/* Adding the next line. */
 						i = strlen(part);
 						key = memdupcat(hdr->data,
 								hdr->datalen-1,
 								part, i+1);
 						free(part);
 						hdr->data = key;
 						hdr->datalen += i;
 						//printf("%s = %s\n", hdr->key,
 						//	(char *)hdr->data);
 					}
 					free(value);
 				}
 				goto mimeparsebufagain;
 			default:
 				break;
 			}
 
 			if (hdr != NULL)
 				hdr = NULL;
 			mime->state = HEADER;
 			/* FALL THROUGH: No header value found. */
 		case HEADER:
 			//printf("hdr: %s\n", buf);
 
 			/*
 			 * End of headers.
 			 */
 			if (strlen(buf) == 0) {
 				//printf("end of headers '%c' + '%c'\n", p[0], p[1]);
 				/*
 				 * Heuristics for ugly e-mail generators
 				 * follow.
 				 */
 				/*
 				 * Does the line begin with "--"? Looks
 				 * like a boundary. Go to next body part.
 				 */
 				if (p[0] == '-' && p[1] == '-') {
 					mime->rawhdrs = memdupz(str, (p - str));
 					mime->rawhdrslen = p - str;
 					goto mimeparsebufbodyparse;
 				}
 				/*
 				 * Does the line have some "header:
 				 * value\n" form? Go on parsing headers.
 				 */
 				for (key = p; key[0] != '\n'; key++) {
 					//printf("key[0] = '%c'\n", key[0]);
 					if (key[0] == ':')
 						break;
 					if (key[0] == ' ') {
 						mime->rawhdrs = memdupz(str, (p - str));
 						mime->rawhdrslen = p - str;
 						goto mimeparsebufbodyparse;
 					}
 				}
 				/*
 				 * A line simply ended with no header
 				 * suspicion.
 				 */
 				if (key[0] == '\n') {
 					mime->rawhdrs = memdupz(str, (p - str));
 					mime->rawhdrslen = p - str;
 					goto mimeparsebufbodyparse;
 				}
 			}
 
 			/*
 			 * "key: value"
 			 */
 			key = NULL;
 			value = NULL;
 			tvalue = NULL;
 			sscanf(buf, "%1024m[^: \t\r\v\f]:"
 					"%1024m[^\n]", &key, &value);
 			if (value == NULL)
 				value = memdupz(" ", 2);
 			//printf("%s = %s\n", key, value);
 			if (key != NULL && value != NULL) {
 				tvalue = value + strspn(value,
 						" \t\r\v\f");
 				hdr = llistelem_new(key, tvalue,
 						strlen(tvalue)+1);
 				llist_addelem(mime->hdrs, hdr);
 				mime->state = HEADERVALUE;
 			}
 			if (key != NULL)
 				free(key);
 			if (value != NULL)
 				free(value);
 			break;
 		default:
 mimeparsebufagain:
 			break;
 		}
 	}
 	//printf("return mime_preparepart\n");
 	return mime_preparepart(mime);
 
 mimeparsebufbodyparse:
 	//printf("body parsing begins.\n");
 	mime = mime_preparepart(mime);
 	if (mime == NULL)
 		return NULL;
 
 	/*
 	 * It is not a multipart message, so take the remainder
 	 * of the given message.
 	 */
 	if (mime->boundary == NULL) {
 		//printf("No boundary there. Taking the remainder.\n");
 		partlen = str - p + len;
 		mime->body = memdupz(p, partlen);
 		mime->bodylen = partlen;
 		//printf("strlen = %ld; partlen = %d;\n", strlen(mime->body),
 		//		partlen);
 		//printf("mime->body = \"%s\"\n", mime->body);
 
 		return mime;
 	} else {
 		//printf("There is a boundary.\n");
 	}
 
 	partlen = 0;
 	//printf("p = \"%s\"\n", p);
 	mime->body = mime_sgetbound(mime->boundary, &p, str + len - 1,
 			&partlen, &isend);
 	mime->bodylen = partlen;
 	if (isend) {
 		/*
 		 * This is an end boundary at the beginning
 		 * of a multipart message. Abort.
 		 */
 		//die("End boundary at beginning of multipart.\n");
 		return mime;
 	}
 	if (mime->body == NULL) {
 		//die("Could not find beginning MIME content.\n");
 		return mime;
 	}
 	//printf("mime->body = \"%s\"\n", mime->body);
 
 	for(;;) {
 		partlen = 0;
 		part = mime_sgetbound(mime->boundary, &p, str + len - 1,
 				&partlen, &isend);
 		//printf("part = \"%s\"\n", part);
 		if (part == NULL) {
 			/*
 			 * There maybe no ending boundary. Some e-mail
 			 * signing applications forget this.
 			 */
 			if (p < (str + len - 1)) {
 				partlen = str - p + len;
 				part = memdupz(p, partlen);
 				p = str + len - 1;
 			} else {
 				break;
 			}
 		}
 
 		partm = mime_new();
 		partm = mime_parsebufintern(partm, part, partlen);
 		if (partm != NULL)
 			llist_addraw(mime->parts, NULL, partm, sizeof(partm));
 		free(part);
 
 		if (isend)
 			break;
 	}
 
 	return mime;
 }
 
 mime_t *
 mime_parsebuf(char *str, int len)
 {
 	mime_t *ret, *pret;
 
 	ret = mime_new();
 	pret = mime_parsebufintern(ret, str, len);
 	if (pret == NULL) {
 		mime_free(ret);
 		return NULL;
 	}
 
 	mime_mkpartids(ret);
 
 	return ret;
 }
 
 char *
 mime_searchsplit(char *data, int klen)
 {
 	char *p, *op;
 	int incomment;
 
 	if (strlen(data) + klen <= 74)
 		return NULL;
 
 	p = &data[73 - klen];
 	op = p;
 	incomment = 0;
 
 	for (;;) {
 		switch (p[0]) {
 		case '"':
 		case '\'':
 			/*
 			 * This is meant to be broken.
 			 * It's just heuristics.
 			 */
 			incomment = !incomment;
 			break;
 		case ' ':
 		case '\t':
 		case '\f':
 		case '\n':
 		case '\r':
 			if (incomment)
 				break;
 			return p;
 		case '\0':
 			return &data[73 - klen];
 		}
 
 		if (p == data) {
 			p = op;
 			op = NULL;
 			continue;
 		}
 
 		if (op != NULL) {
 			p--;
 		} else {
 			p++;
 		}
 	}
 
 	return NULL;
 }
 
 char *
 mime_printheader(llistelem_t *hdr)
 {
 	char *buf, *sp, *osp;
 	int blen, splen;
 
 	blen = 0;
 	sp = mime_searchsplit((char *)hdr->data, strlen(hdr->key) + 2);
 	if (sp != NULL) {
 		buf = smprintf("%s: ", hdr->key);
 		blen = strlen(buf);
 
 		buf = memdupcat(buf, blen, (char *)hdr->data,
 				(sp - (char *)hdr->data));
 		blen += (sp - (char *)hdr->data);
 		buf = memdupcat(buf, blen, "\r\n", 2);
 		blen += 2;
 
 		for (osp = sp;; osp = sp) {
 			sp = mime_searchsplit(osp, 8);
 			if (sp == NULL)
 				break;
 
 			buf = memdupcat(buf, blen, "\t", 1);
 			blen += 1;
 			buf = memdupcat(buf, blen, osp, (sp - osp));
 			blen += (sp - osp);
 			buf = memdupcat(buf, blen, "\r\n", 2);
 			blen += 2;
 		}
 
 		if (strlen(osp) > 0) {
 			buf = memdupcat(buf, blen, "\t", 1);
 			blen += 1;
 			splen = strlen(osp);
 			buf = memdupcat(buf, blen, osp, splen);
 			blen += splen;
 			buf = memdupcat(buf, blen, "\r\n", 2);
 		}
 	} else {
 		buf = smprintf("%s: %s\r\n", hdr->key, (char *)hdr->data);
 	}
 
 	return buf;
 }
 
 char *
 mime_printbuf(mime_t *mime, int *len)
 {
 	llistelem_t *hdr;
 	char *ret, *abuf;
 	int rlen, alen;
 
 	rlen = 0;
 	ret = NULL;
 
 	forllist(mime->hdrs, hdr) {
 		abuf = mime_printheader(hdr);
 		alen = strlen(abuf);
 
 		ret = memdupcat(ret, rlen, abuf, alen);
 		rlen += alen;
 		free(abuf);
 		/*
 		 * TODO: Add part handling.
 		 */
 	}
 
 	ret = memdupcat(ret, rlen, "\r\n", 2);
 	rlen += 2;
 
 	return ret;
 }
 
 void
 printtabs(int depth)
 {
 	for (; depth; depth--)
 		printf("\t");
 }
 
 void
 mime_printintern(mime_t *mime, int depth)
 {
 	llistelem_t *elem;
 
 	printtabs(depth);
 	printf("partid: %s\n", mime->partid);
 	printtabs(depth);
 	printf("hdr:\n");
 	forllist(mime->hdrs, elem) {
 		printtabs(depth);
 		printf("%s = %s\n", elem->key, (char *)elem->data);
 	}
 
 	printtabs(depth);
 	printf("body:\n");
 	printtabs(depth);
 	printf("%d\n", mime->bodylen);
 	printf("%s", mime->body);
 
 	if (mime->parts->len > 0) {
 		printtabs(depth);
 		printf("parts:\n");
 		forllist(mime->parts, elem)
 			mime_printintern((mime_t *)elem->data, depth+1);
 	}
 }
 
 void
 mime_print(mime_t *mime)
 {
 	mime_printintern(mime, 0);
 }
 
 char *
 mime_decodepartencoding(mime_t *mime, int *len)
 {
 	char *ret;
 
 	//printf("ct = \"%s\"\n", mime->ct);
 	//printf("cte = \"%s\"\n", mime->cte);
 	ret = NULL;
 	if (!strcasecmp(mime->cte, "base64")) {
 		*len = mime->bodylen;
 		ret = b64dec(mime->body, len);
 	} else if (!strcasecmp(mime->cte, "quoted-printable")) {
 		*len = mime->bodylen;
 		ret = qpdec(mime->body, len, 0);
 	} else if (!strncasecmp(mime->ct, "text/", 5)) {
 		/* Convert CRLF to LF. */
 		*len = mime->bodylen;
 		ret = dosdec(mime->body, len);
 	}
 
 	if (ret == NULL && mime->body != NULL && mime->bodylen > 0) {
 		*len = mime->bodylen;
 		ret = memdupz(mime->body, mime->bodylen);
 	}
 
 	return ret;
 }
 
 char *
 mime_decodepart(mime_t *mime, int *len)
 {
 	char *ret, *cret;
 
 	if (mime->bodylen == 0) {
 		*len = 0;
 		return memdupz("", 1);
 	}
 
 	ret = mime_decodepartencoding(mime, len);
 	if (ret == NULL) {
 		*len = 0;
 		return memdupz("", 1);
 	}
 
 	if (strcasecmp(mime->cte, "binary")) {
 		if (strcasecmp(mime->charset, "utf-8")) {
 			cret = mime_iconv(ret, mime->charset, "UTF-8");
 			if (cret != NULL) {
 				free(ret);
 				ret = cret;
 			}
 			*len = strlen(ret);
 		}
 	}
 
 	return ret;
 }
 
 char *
 mime_filename(mime_t *mime)
 {
 	char *filename;
 	llistelem_t *hdr, *name;
 	llist_t *hdrp;
 
 	filename = NULL;
 
 	/*
 	 * 1.) The standard.
 	 */
 	hdr = llist_ciget(mime->hdrs, "Content-Disposition");
 	if (hdr != NULL && hdr->data != NULL) {
 		hdrp = mime_parseheader((char *)hdr->data);
 		if (hdrp != NULL) {
 			name = llist_ciget(hdrp, "filename");
 			if (name != NULL && name->data != NULL) {
 				filename = mime_guessheader(
 						(char *)name->data);
 			}
 			llist_free(hdrp);
 		}
 
 		if (filename != NULL)
 			return filename;
 	}
 
 	/*
 	 * 2.) The modern age.
 	 */
 	hdr = llist_ciget(mime->hdrs, "Content-Type");
 	if (hdr != NULL && hdr->data != NULL) {
 		hdrp = mime_parseheader((char *)hdr->data);
 		if (hdrp != NULL) {
 			name = llist_ciget(hdrp, "name");
 			if (name != NULL && name->data != NULL) {
 				filename = mime_guessheader(
 						(char *)name->data);
 			}
 			llist_free(hdrp);
 		}
 
 		if (filename != NULL)
 			return filename;
 	}
 
 	return NULL;
 }
 
 
 char *
 mime_mkfilename(char *id, mime_t *mime)
 {
 	char *filename;
 	llistelem_t *hdr;
 
 	filename = mime_filename(mime);
 	if (filename != NULL)
 		return filename;
 
 	/*
 	 * 3.) The ugly.
 	 */
 	hdr = llist_ciget(mime->hdrs, "Content-Description");
 	if (hdr != NULL && hdr->data != NULL) {
 		filename = mime_guessheader((char *)hdr->data);
 		if (filename != NULL)
 			return filename;
 	}
 
 	/*
 	 * 4.) Last resort.
 	 */
 	if (id == NULL)
 		id = "000";
 	return smprintf("%s.%s.part", id, mime->partid);
 }
 
 char *
 mime_mkboundary(void)
 {
 	srand(time(NULL));
 	return smprintf("=--= _TUlNRSBTdWNrcyEK/%x_ =--=", rand());
 }