head.c

/***********************************************************************
*                                                                      *
*               This software is part of the BSD package               *
*Copyright (c) 1978-2011 The Regents of the University of California an*
*                                                                      *
* Redistribution and use in source and binary forms, with or           *
* without modification, are permitted provided that the following      *
* conditions are met:                                                  *
*                                                                      *
*    1. Redistributions of source code must retain the above           *
*       copyright notice, this list of conditions and the              *
*       following disclaimer.                                          *
*                                                                      *
*    2. Redistributions in binary form must reproduce the above        *
*       copyright notice, this list of conditions and the              *
*       following disclaimer in the documentation and/or other         *
*       materials provided with the distribution.                      *
*                                                                      *
*    3. Neither the name of The Regents of the University of California*
*       names of its contributors may be used to endorse or            *
*       promote products derived from this software without            *
*       specific prior written permission.                             *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND               *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,          *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF             *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE             *
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS    *
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,             *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED      *
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,        *
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    *
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,      *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY       *
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE              *
* POSSIBILITY OF SUCH DAMAGE.                                          *
*                                                                      *
* Redistribution and use in source and binary forms, with or without   *
* modification, are permitted provided that the following conditions   *
* are met:                                                             *
* 1. Redistributions of source code must retain the above copyright    *
*    notice, this list of conditions and the following disclaimer.     *
* 2. Redistributions in binary form must reproduce the above copyright *
*    notice, this list of conditions and the following disclaimer in   *
*    the documentation and/or other materials provided with the        *
*    distribution.                                                     *
* 3. Neither the name of the University nor the names of its           *
*    contributors may be used to endorse or promote products derived   *
*    from this software without specific prior written permission.     *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS"    *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED    *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A      *
* PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS    *
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,      *
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT     *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF     *
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND  *
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,   *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT   *
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   *
* SUCH DAMAGE.                                                         *
*                                                                      *
*                          Kurt Shoens (UCB)                           *
*                                 gsf                                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Mail -- a mail program
 *
 * Routines for processing and detecting headlines.
 */

#include "mailx.h"

static const struct lab fields[] = {
	"newsgroups",		GNEWS,
	"article-id",		GNEWS,
	"reply-to",		GNEWS|GREPLY,
	"original-from",	GNEWS|GREPLY,
	"from",			GNEWS|GREPLY,
	"sender",		GNEWS,
	"apparently-to",	GTO,
	"original-to",		GTO,
	"to",			GTO,
	"cc",			GCC,
	"bcc",			GBCC,
	"subject",		GSUB,
	"subj",			GSUB,
	"status",		GSTATUS,
	"references",		GREFERENCES,
	"message-id",		GMESSAGEID,
	"received",		0,
	"return-path",		0,
	"importance",		0,
	"in-reply-to",		0,
	"priority",		0,
	"x-",			0,
};

/*
 * Data setup for mimehead().
 */

#define CONTENT_boundary	1
#define CONTENT_disposition	2
#define CONTENT_encoding	3
#define CONTENT_filename	4
#define CONTENT_name		5
#define CONTENT_type		6

struct content {
	const char*	name;
	int		index;
};

static const struct content	contents[] = {
	"boundary",		CONTENT_boundary,
	"disposition",		CONTENT_disposition,
	"filename",		CONTENT_filename,
	"name",			CONTENT_name,
	"transfer-encoding",	CONTENT_encoding,
	"type",			CONTENT_type,
};

/*
 * Called by mimehead() to set content data values.
 */
static int
content(Mime_t* mp, void* entry, char* data, size_t size, Mimedisc_t* disc)
{
	register struct content*	cp = (struct content*)entry;
	register struct part*		ap;
	register struct bound*		bp;
	char*				s;
	char*				e;

	note(DEBUG, "content multi=%d %s `%-.*s'", state.part.in.multi, cp->name, size, data);
	if (!(ap = ((struct state_part*)disc)->head))
		ap = &state.part.global;
	switch (cp->index) {
	case CONTENT_boundary:
		if (state.part.in.multi) {
			if (!(bp = newof(0, struct bound, 1, size + 1))) {
				note(ERROR|SYSTEM, "Out of space");
				break;
			}
			bp->size = size;
			memcpy(bp->data, data, size);
			bp->next = state.part.in.boundary;
			state.part.in.boundary = bp;
			note(DEBUG, "content boundary=`%s'", bp->data);
		}
		break;
	case CONTENT_disposition:
		ap->flags |= PART_disposition;
		if (!mimecmp("inline", data, NiL))
			ap->flags |= PART_inline;
		/*FALLTHROUGH*/
	case CONTENT_type:
		if (!mimecmp("multipart", data, NiL))
			state.part.in.multi = 1;
		else if (!*ap->type || !strchr(ap->type, '/') || cp->index == CONTENT_type && (ap->flags & PART_disposition)) {
			ap->flags &= ~PART_disposition;
			if (size >= sizeof(ap->type))
				size = sizeof(ap->type) - 1;
			strncopy(ap->type, data, size + 1);
			strlower(ap->type);
			s = data + size;
			if (!(e = strchr(s, '\n')))
				e = s + strlen(s);
			if ((size = (e - s)) >= sizeof(ap->opts))
				size = sizeof(ap->opts) - 1;
			strncopy(ap->opts, s, size + 1);
			if (!mimecmp("text/plain", data, NiL) || !mimecmp("text/enriched", data, NiL))
			{
				ap->flags |= PART_text;
				if (!strncmp(ap->code, "bin", 3))
					*ap->code = 0;
			}
			else if (!mimecmp("message", data, NiL))
				ap->flags |= PART_message;
			else
				ap->flags |= PART_application;
		}
		break;
	case CONTENT_encoding:
		if (size >= sizeof(ap->code))
			size = sizeof(ap->code) - 1;
		strncopy(ap->code, data, size + 1);
		strlower(ap->code);
		if ((ap->flags & PART_text) && !strncmp(ap->code, "bin", 3))
			*ap->code = 0;
		break;
	case CONTENT_name:
		if (*ap->name)
			break;
		/*FALLTHROUGH*/
	case CONTENT_filename:
		if (size >= sizeof(ap->name))
			size = sizeof(ap->name) - 1;
		strncopy(ap->name, data, size + 1);
		break;
	}
	return 0;
}

/*
 * Open a mime handle and return non-0 if ok to mime.
 * op==0 for header parsing, op==1 for viewing.
 */
int
mime(int op)
{
	if (state.part.init < 0)
		return 0;
	if (!state.part.mime) {
		state.part.disc.version = MIME_VERSION;
		state.part.disc.flags = 0;
		state.part.disc.errorf = 0;
		state.part.disc.valuef = content;
		if (!(state.part.mime = mimeopen(&state.part.disc))) {
			state.part.init = -1;
			return 0;
		}
	}
	if (state.part.init < op) {
		mimeload(state.part.mime, state.var.mailcap, MIME_LIST);
		state.part.init = op;
	}
	return 1;
}

/*
 * Set up a message for header parsing.
 */
int
headset(register struct parse* pp, struct msg* mp, FILE* fp, struct header* hp, Dt_t** ignore, unsigned long flags)
{
	int		r;
	struct bound*	bp;

	while (bp = state.part.in.boundary) {
		state.part.in.boundary = bp->next;
		free(bp);
	}
	pp->fp = mp ? setinput(mp) : fp;
	pp->mp = mp;
	if ((flags & GMIME) && !mime(0))
		flags &= ~GMIME;
	if (pp->hp = hp) {
		if (flags & GRULE)
			headclear(hp, flags);
		else
			hp->h_clear = flags;
	}
	pp->count = mp ? mp->m_size : 0;
	pp->flags = flags & (GDISPLAY|GNL);
	pp->ignore = 0;
	if (hp || (flags & GFROM))
		r = 1;
	else if ((r = headget(pp)) && (pp->flags & GDISPLAY) && pp->length > 6) {
		register char*	s;
		register char*	t;
		struct name*	np;
		int		c;

		/*
		 * Pun on GMETOO -- if from me then don't ignore To:
		 */
		for (s = t = pp->buf + 5; *t && !isspace(*t); t++);
		c = *t;
		*t = 0;
		if (streq(s, state.var.user) || (np = dictsearch(&state.aliases, s, LOOKUP)) && streq(np->name, state.var.user))
			pp->flags |= GMETOO;
		*t = c;
	}
	pp->ignore = ignore;
	pp->flags |= flags;
	pp->type = 0;
	if (state.part.in.head) {
		state.part.in.count = 0;
		do {
			state.part.in.tail = state.part.in.head->next;
			free(state.part.in.head);
		} while (state.part.in.head = state.part.in.tail);
	}
	state.part.in.multi = 0;
	if (state.part.global.flags)
		memset(&state.part.global, 0, sizeof(state.part.global));
	return r;
}

/*
 * Generate the message status field.
 */
static void
status(struct parse* pp)
{
	register char*	s;

	pp->flags &= ~GSTATUS;
	s = strcopy(pp->buf, "Status");
	pp->separator = s;
	*s++ = (pp->flags & GDISPLAY) ? ':' : 0;
	*s++ = ' ';
	if (pp->mp->m_flag & MSPAM)
		*s++ = 'X';
	if (pp->mp->m_flag & MREAD)
		*s++ = 'R';
	if (!(pp->mp->m_flag & MNEW))
		*s++ = 'O';
	if (*(s - 1) == ' ')
		s--;
	*s++ = '\n';
	*s = 0;
	pp->length = s - pp->buf;
	if (!(pp->flags & GNL))
		pp->buf[pp->length - 1] = 0;
}

/*
 * Attach part ap to the current message.
 */
static void
attach(register struct part* ap)
{
	register int	c;
	register int	p;
	register char*	s;
	register char*	t;

	if (!(ap->flags & (PART_application|PART_message|PART_text)))
		ap->flags |= PART_text;
	if ((ap->flags & PART_text) && ((ap->flags & PART_inline) || !ap->name[0]))
		ap->flags |= PART_body;
	if (!(ap->flags & PART_body))
		ap->count = ++state.part.in.count;
	if (!ap->name[0])
		sfsprintf(ap->name, sizeof(ap->name), "%d.att", ap->count);
	else {
		s = t = ap->name;
		for (p = 0; c = *s++; p = c) {
			if (c == '/' || c == '\\') {
				c = 0;
				t = ap->name;
			}
			else {
				if (isspace(c) || iscntrl(c) || !isprint(c) || c == '#' || c == '$' || c == '&' || c == '*' || c == '(' || c == ')' || c == '"' || c == '\'' || c == '`' || c == '<' || c == '>' || c == '?' || c == '[' || c == ']' || c == '{' || c == '}')
					c = '_';
				if (c != '_' && c != '-' || p != '_' && p != '-')
					*t++ = c;
			}
		}
		*t = 0;
	}
	if (!*ap->type)
		strcpy(ap->type, "unknown");
	note(DEBUG, "part %d offset=%ld size=%ld lines=%ld flags=0x%08x type=%s name=%s", ap->count, (long)ap->offset, (long)ap->size, (long)ap->lines, ap->flags, ap->type, ap->name);
	if (state.part.in.tail)
		state.part.in.tail->next = ap;
	else
		state.part.in.head = ap;
	state.part.in.tail = ap;
}

/*
 * Read the next header line.
 */
static char*
headline(register struct parse* pp)
{
	register char*	s;
	register char*	e;
	register char*	t;
	register int	c;
	register int	n;

	if (pp->mp && pp->count <= 0 || (pp->flags & GDONE) || !fgets(pp->buf, sizeof(pp->buf), pp->fp)) {
		pp->flags |= GDONE;
		if (pp->hp)
			pp->hp->h_clear = 0;
		return 0;
	}
	pp->length = n = strlen(pp->buf);
	s = pp->buf + n;
	e = pp->buf + sizeof(pp->buf) - 1;
	pp->count -= n;
	if (*pp->buf != '\n' && (*pp->buf != '\r' || *(pp->buf + 1) != '\n')) {
		while ((!pp->mp || pp->count > 0) && (c = fgetc(pp->fp)) != EOF) {
			if (c == '\r' || c == '\n' || !isspace(c)) {
				ungetc(c, pp->fp);
				break;
			}
			t = s;
			if (s < e) {
				*(s - 1) = ' ';
				*s++ = ' ';
			}
			n = 1;
			while ((c = fgetc(pp->fp)) != EOF) {
				n++;
				if (s < e)
					*s++ = c;
				if (c == '\n')
					break;
			}
			pp->count -= n;
			pp->length += s - t;
		}
	}
	*s = 0;
	return pp->buf;
}

/*
 * Get mime multipart content.
 */
static void
multipart(register struct parse* pp)
{
	register char*	s;
	unsigned long	count;
	off_t		offset;
	int		n;
	int		header;
	struct part*	ap;
	struct bound*	bp;

	if (!state.part.in.boundary)
		return;
	pp->flags &= ~GMIME;
	offset = ftell(pp->fp) - pp->length;
	count = pp->count + pp->length;
	ap = 0;
	header = 0;
	while (s = headline(pp)) {
		if (state.part.in.boundary && (pp->length == (state.part.in.boundary->size + 3) || pp->length == (state.part.in.boundary->size + 5)) && s[0] == '-' && s[1] == '-' && !strncmp(s + 2, state.part.in.boundary->data, state.part.in.boundary->size)) {
			if (ap) {
				ap->raw.size = ftell(pp->fp) - ap->raw.offset - pp->length;
				attach(ap);
				note(DEBUG, "raw offset=%ld size=%ld", (long)ap->raw.offset, (long)ap->raw.size);
			}
			if (!(ap = newof(0, struct part, 1, 0))) {
				note(ERROR|SYSTEM, "Out of space");
				break;
			}
			ap->raw.offset = ftell(pp->fp);
			header = 1;
			if (s[state.part.in.boundary->size + 2] == '-' && s[state.part.in.boundary->size + 3] == '-') {
				bp = state.part.in.boundary->next;
				free(state.part.in.boundary);
				if (!(state.part.in.boundary = bp)) {
					header = 0;
					while (pp->count > 0 && (n = getc(pp->fp)) == '\n')
						pp->count--;
					if (n != EOF)
						ungetc(n, pp->fp);
					ap->offset = ftell(pp->fp);
				}
			}
		}
		else if (header) {
			state.part.head = ap;
			if (!mimehead(state.part.mime, (void*)contents, elementsof(contents), sizeof(*contents), s)) {
				if (ap->flags & PART_message) {
					ap->flags &= ~PART_message;
					header = 1;
				}
				else
					header = strchr(s, ':') != 0;
				ap->offset = ftell(pp->fp);
			}
			state.part.head = 0;
		}
		else if (ap) {
			ap->size += pp->length;
			ap->lines++;
		}
	}
	if (ap) {
		if (header)
			free(ap);
		else
			attach(ap);
	}
	fseek(pp->fp, offset, SEEK_SET);
	pp->count = count;
}

/*
 * Get the next message header.
 */
int
headget(register struct parse* pp)
{
	register char*			s;
	register char*			t;
	register int			n;
	register const struct lab*	lp;
	off_t				body;
	off_t				text;
	int				i;
	int				separator;

	while (s = headline(pp)) {
		/*
		 * A blank line separates the headers from the body.
		 */
		if ((n = *s) == '\n' || n == '\r' && (n = *(s + 1)) == '\n') {
			if (state.var.headerbotch && pp->fp != stdin && (body = ftell(pp->fp)) > 0) {
				/*
				 * If the next batch of lines up to
				 * a blank line look like headers then
				 * treat them as such rather than
				 * message body.  This compensates
				 * for those mailers that botch the
				 * message manual of style.
				 */
				text = body;
				separator = 1;
				i = 0;
				for (;;) {
					if (!(s = fgets(pp->buf, sizeof(pp->buf), pp->fp)))
						goto done;
					if ((n = *s) == '\n' || n == '\r' && (n = *(s + 1)) == '\n') {
						if (!separator)
							break;
						text = ftell(pp->fp);
					}
					else if (isspace(n)) {
						if (!i)
							goto done;
						separator = 0;
					}
					else if (isalpha(n) || n == '>') {
						if (n != '>' || strncmp(++s, "From ", 5)) {
							t = s;
							do {
								if (!*s || isspace(*s))
									goto done;
							} while (*s++ != ':');
							if (!i) {
								n = s - t - 1;
								if (n > 2 && (t[0] == 'X' || t[0] == 'x') && t[1] == '-')
									i = 1;
								else {
									i = -1;
									do {
										if (++i >= elementsof(fields))
											goto done;
									} while (strncasecmp(fields[i].name, t, n));
								}
							}
						}
						separator = 0;
					}
					else if (isprint(n)) {
						while (*++s == n);
						if (*s != '\n' && (*s != '\r' || *(s + 1) != '\n'))
							goto done;
						if (separator)
							text = ftell(pp->fp);
					}
					else
						goto done;
				}
				n = fseek(pp->fp, text, SEEK_SET);
				pp->count -= text - body;
				continue;
 done:
				n = fseek(pp->fp, body, SEEK_SET);
				s = pp->buf;
				*s++ = '\n';
				*s = 0;
			}
			pp->flags |= GDONE;
			break;
		}
		if (isspace(n))
			continue;
		if (!isalnum(n) && isprint(n)) {
			t = s;
			while (*++t == n);
			if (*t == '\n' || *t == '\r' && *(t + 1) == '\n') {
				if (n == '-' && (t - s) > 2) {
					/*
					 * Edit rule treated like a blank line.
					 */
					break;
				}
				/*
				 * Treat rules as ignored header lines.
				 */
				continue;
			}
		}
		if ((pp->flags & GMIME) && mimehead(state.part.mime, (void*)contents, elementsof(contents), sizeof(*contents), s))
			multipart(pp);
		else {
			i = 0;
			while (*s == '>') {
				s++;
				i = 1;
			}
			pp->name = s;
			for (n = 0; *s && !isspace(*s) && *s != ':'; n = *s++) {
				if (isupper(*s)) {
					if (isalnum(n))
						*s = tolower(*s);
				}
				else if (islower(*s)) {
					if (!isalnum(n))
						*s = toupper(*s);
				}
			}
			if ((separator = *(pp->separator = s)) != ':' && i)
				continue;
			*s = 0;
			if (!pp->ignore || !ignored(pp->ignore, pp->name) || (pp->flags & GMETOO) && streq(pp->name, "To") && ((pp->flags &= ~GMETOO), 1)) {
				while (isspace(*++s));
				pp->data = s;
				pp->type = 0;
				if (pp->flags & GCOMPOSE) {
					for (lp = state.hdrtab; lp->name; lp++)
						if (pp->flags & (lp->type|GMISC)) {
							s = pp->name;
							t = (char*)lp->name;
							if (upper(*s) == *t) {
								while (lower(*++s) == *++t);
								if (!*s && *t == ':') {
									if (pp->flags & lp->type) {
										pp->flags &= ~lp->type;
										pp->type = lp->type;
										if (lp->type & GSTATUS)
											status(pp);
									}
									break;
								}
							}
						}
					if (!pp->type && (pp->flags & GMISC)) {
						pp->type = GMISC;
						*pp->separator = separator;
						pp->data = pp->name;
					}
				}
				if (!(pp->flags & GNL))
					pp->buf[pp->length - 1] = 0;
				if (pp->type && pp->hp)
					extract(pp->hp, pp->type, pp->data);
				if (pp->flags & GDISPLAY)
					*pp->separator = separator;
				return 1;
			}
		}
	}
	if (pp->flags & GSTATUS) {
		status(pp);
		return 1;
	}
	if (state.part.in.head) {
		fseek(pp->fp, state.part.in.head->offset, SEEK_SET);
		pp->count = state.part.in.head->size;
	}
	return 0;
}

/*
 * Fetch the field info by name from the passed message.
 */
static char*
grabname(struct parse* pp, struct msg* mp, char* name, unsigned long type)
{
	register char*	r = 0;
	register int	n = 0;
	register int	i;
	register int	u;

	if (headset(pp, mp, NiL, NiL, NiL, 0)) {
		u = (type & GUSER) ? strlen(state.var.user) : 0;
		while (headget(pp)) {
			if (!strcasecmp(pp->name, name)) {
				if (!(type & GLAST))
					return savestr(pp->data);
				if (u > 0 && !strncasecmp(pp->data, state.var.user, u) && pp->data[u] == '@')
					u = -u;
				else if (u < 0) {
					if (!*pp->data)
						return savestr(pp->data);
					continue;
				}
				i = strlen(pp->data) + 1;
				if (i > n) {
					n = i;
					r = savestr(pp->data);
				}
				else
					strcpy(r, pp->data);
			}
		}
	}
	return r;
}

/*
 * Fetch the field info by type from the passed message.
 */
static char*
grabtype(struct parse* pp, register struct msg* mp, unsigned long type)
{
	register char*	s;
	register char*	e;
	register char*	t;
	register FILE*	fp;
	struct sender*	sp;
	struct sendor*	op;
	struct sendand*	ap;
	int		i;
	int		first = 1;
	char		namebuf[LINESIZE];

	if (type & (GREPLY|GSENDER)) {
		for (sp = state.sender; sp; sp = sp->next)
			for (op = &sp->sendor; op; op = op->next)
				for (ap = &op->sendand; ap;) {
					if (!(s = grabname(pp, mp, ap->head, ap->flags)) || !strmatch(s, ap->pattern))
						break;
					if (!(ap = ap->next))
						return sp->address;
				}
		if (type & GSENDER)
			return 0;
	}
	e = namebuf + sizeof(namebuf);
	for (i = 0; i < elementsof(fields); i++)
		if ((fields[i].type & type) &&
		    (s = grabname(pp, mp, (char*)fields[i].name, type)) &&
		    ((type & (GNEWS|GSUB)) || (s = skin(s, type))) &&
		    yankword(s, namebuf)) {
			if ((type & GNEWS) && (t = strchr(s, ',')))
				*t = 0;
			if (type & (GNEWS|GSUB))
				for (e = s, i = 0; *e; e++)
					if (isspace(*e))
					{
						if (i || *e != ' ')
						{
							t = e;
							while (i = *e++)
							{
								if (isspace(i))
									for (i = ' '; isspace(*e); e++);
								*t++ = i;
							}
							*t = 0;
							break;
						}
						i = 1;
					}
					else
						i = 0;
			return s;
		}
#if 0
	if (!(type & (GREPLY|GTO)) || (type & GLAST))
#else
	if (!(type & (GREPLY|GTO)))
#endif
		return 0;
	fp = setinput(mp);
	namebuf[0] = 0;
	if (readline(fp, pp->buf, sizeof(pp->buf)) >= 0) {
 again:
		for (;;) {
			for (s = pp->buf; *s && *s != ' '; s++);
			for (; *s == ' ' || *s == '\t'; s++) ;
			for (t = &namebuf[strlen(namebuf)]; *s && *s != ' ' && *s != '\t' && t < namebuf + sizeof(namebuf) - 1;)
				*t++ = *s++;
			*t = 0;
			if (readline(fp, pp->buf, sizeof(pp->buf)) < 0)
				break;
			if (!(s = strchr(pp->buf, 'F')))
				break;
			if (strncmp(s, "From", 4))
				break;
			while (s = strchr(s, 'r')) {
				if (!strncmp(s, "remote", 6)) {
					if (!(s = strchr(s, 'f')))
						break;
					if (strncmp(s, "from", 4))
						break;
					if (!(s = strchr(s, ' ')))
						break;
					s++;
					if (first) {
						first = 0;
						s = strncopy(namebuf, s, e - namebuf);
					}
					else if (t = strrchr(namebuf, '!')) {
						t++;
						s = strncopy(t, s, e - t);
						strncopy(s, "!", e - s);
					}
					goto again;
				}
				s++;
			}
		}
	}
	return skin(savestr(namebuf), type);
}

/*
 * Grab field/address header from this message.
 * If name!=0 then it contains the header name,
 * otherwise grab by type.
 */
char*
grab(register struct msg* mp, unsigned long type, char* name)
{
	register char*	s;
	struct parse	pp;

	if (!name)
		s = grabtype(&pp, mp, type);
	else if ((s = grabname(&pp, mp, name, type)) && (type & (GCOMPARE|GDISPLAY)))
		s = normalize(s, type, NiL, 0);
	return s;
}

/*
 * Collect a liberal (space, tab delimited) word into b.
 * Update p to point to the next word.
 */
char*
wordnext(char** p, char* b)
{
	register char*	s;
	register char*	t;
	register int	c;

	if (!(s = *p) || !*s)
		return 0;
	while (isspace(*s))
		s++;
	t = b;
	while ((c = *s++) && !isspace(c)) {
		*t++ = c;
		if (c == '"') {
			do {
				if (!(c = *s++)) {
					s--;
					break;
				}
			} while ((*t++ = c) != '"');
 		}
	}
	if (!c)
		s--;
	else
		while (isspace(*s))
			s++;
	*p = s;
	*t = 0;
	return *b ? b : (char*)0;
}

/*
 * Split a headline into its useful components.
 * Copy the line into dynamic string space, then set
 * pointers into the copied line in the passed headline
 * structure.  Actually, it scans.
 */
void
parse(struct msg* mp, char* line, register struct headline* hl, char* pbuf, size_t psize)
{
	register char*	s;
	register char*	t;
	register char*	e;
	struct parse	pp;

	hl->l_from = 0;
	hl->l_info = 0;
	hl->l_date = 0;
	t = pbuf;
	e = t + psize;
	if (mp && state.folder == FMH && strncmp(line, "From ", 5)) {
		hl->l_from = grabname(&pp, mp, "From", 0);
		hl->l_date = grabname(&pp, mp, "Date", 0);
	}
	else if (wordnext(&line, pp.buf) && (s = wordnext(&line, pp.buf))) {
		if (state.var.news) {
			t = strncopy(hl->l_info = t, s, e - t);
			if (mp) {
				hl->l_from = grabname(&pp, mp, "From", 0);
				hl->l_date = grabname(&pp, mp, "Date", 0);
			}
		}
		else {
			t = strncopy(hl->l_from = t, s, e - t - 1) + 1;
			if (*(s = line)) {
				if (s[0] == 't' && s[1] == 't' && s[2] == 'y') {
					t = strncopy(hl->l_info = t, s, e - t);
					s = wordnext(&line, pp.buf);
				}
				if (*(s = line))
					t = strncopy(hl->l_date = t, s, e - t);
			}
		}
	}
}

/*
 * See if the passed line buffer is a mail header.
 * Return true if yes.  Note the extreme pains to
 * accomodate all funny formats.
 */
int
ishead(char* linebuf, int inhead)
{
	register char*	cp;
	struct headline	hl;
	char		parbuf[LINESIZE];


	if (state.var.news) {
		cp = linebuf;
		if (*cp++ == 'A' && *cp++ == 'r' && *cp++ == 't' &&
		    *cp++ == 'i' && *cp++ == 'c' && *cp++ == 'l' &&
		    *cp++ == 'e' && (*cp == ' ' || *cp == ':'))
			return 1;
	}
	cp = linebuf;
	if (*cp++ != 'F' || *cp++ != 'r' || *cp++ != 'o' || *cp++ != 'm' ||
	    *cp++ != ' ')
		return 0;
	parse(NiL, linebuf, &hl, parbuf, sizeof(parbuf));
	if (!hl.l_from || !hl.l_date || !isdate(hl.l_date)) {
		note(DEBUG, "\"%s\": not a header: no from or date field", linebuf);
		return 0;
	}
	return 1;
}