*** empty log message ***

2 files changed, 12575 insertions, 0 deletions

diff --git a/net-mail/pine-maildir/files/filter.c b/net-mail/pine-maildir/files/filter.c
new file mode 100644
index 000000000000..9264fa088b3d
--- /dev/null
+++ b/net-mail/pine-maildir/files/filter.c
@@ -0,0 +1,6902 @@
+#if !defined(lint) && !defined(DOS)
+static char rcsid[] = "$Id: filter.c,v 1.1 2000/11/15 16:46:06 achim Exp $";
+#endif
+/*----------------------------------------------------------------------
+
+            T H E    P I N E    M A I L   S Y S T E M
+
+   Laurence Lundblade and Mike Seibel
+   Networks and Distributed Computing
+   Computing and Communications
+   University of Washington
+   Administration Builiding, AG-44
+   Seattle, Washington, 98195, USA
+   Internet: lgl@CAC.Washington.EDU
+             mikes@CAC.Washington.EDU
+
+   Please address all bugs and comments to "pine-bugs@cac.washington.edu"
+
+
+   Pine and Pico are registered trademarks of the University of Washington.
+   No commercial use of these trademarks may be made without prior written
+   permission of the University of Washington.
+
+   Pine, Pico, and Pilot software and its included text are Copyright
+   1989-1999 by the University of Washington.
+
+   The full text of our legal notices is contained in the file called
+   CPYRIGHT, included with this distribution.
+
+
+   Pine is in part based on The Elm Mail System:
+    ***********************************************************************
+    *  The Elm Mail System  -  Revision: 2.13                             *
+    *                                                                     *
+    * 			Copyright (c) 1986, 1987 Dave Taylor              *
+    * 			Copyright (c) 1988, 1989 USENET Community Trust   *
+    ***********************************************************************
+
+
+  ----------------------------------------------------------------------*/
+
+/*======================================================================
+     filter.c
+
+     This code provides a generalized, flexible way to allow
+     piping of data thru filters.  Each filter is passed a structure
+     that it will use to hold its static data while it operates on
+     the stream of characters that are passed to it.  After processing
+     it will either return or call the next filter in
+     the pipe with any character (or characters) it has ready to go. This
+     means some terminal type of filter has to be the last in the
+     chain (i.e., one that writes the passed char someplace, but doesn't
+     call another filter).
+
+     See below for more details.
+
+     The motivation is to handle MIME decoding, richtext conversion,
+     iso_code stripping and anything else that may come down the
+     pike (e.g., PEM) in an elegant fashion.  mikes (920811)
+
+   TODO:
+       reasonable error handling
+
+  ====*/
+
+
+#include "headers.h"
+
+
+/*
+ * Internal prototypes
+ */
+int	gf_so_readc PROTO((unsigned char *));
+int	gf_so_writec PROTO((int));
+int	gf_sreadc PROTO((unsigned char *));
+int	gf_swritec PROTO((int));
+int	gf_freadc PROTO((unsigned char *));
+int	gf_fwritec PROTO((int));
+void	gf_terminal PROTO((FILTER_S *, int));
+char   *gf_filter_puts PROTO((char *));
+void	gf_filter_eod PROTO((void));
+void    gf_error PROTO((char *));
+void	gf_8bit_put PROTO((FILTER_S *, int));
+int	so_reaquire PROTO((STORE_S *));
+void   *so_file_open PROTO((STORE_S *));
+int	so_cs_writec PROTO((int, STORE_S *));
+int	so_pico_writec PROTO((int, STORE_S *));
+int	so_file_writec PROTO((int, STORE_S *));
+int	so_cs_readc PROTO((unsigned char *, STORE_S *));
+int	so_pico_readc PROTO((unsigned char *, STORE_S *));
+int	so_file_readc PROTO((unsigned char *, STORE_S *));
+int	so_cs_puts PROTO((STORE_S *, char *));
+int	so_pico_puts PROTO((STORE_S *, char *));
+int	so_file_puts PROTO((STORE_S *, char *));
+
+
+/*
+ * GENERALIZED STORAGE FUNCTIONS.  Idea is to allow creation of
+ * storage objects that can be written into and read from without
+ * the caller knowing if the storage is core or in a file
+ * or whatever.
+ */
+#define	MSIZE_INIT	8192
+#define	MSIZE_INC	4096
+
+
+/*
+ * System specific options
+ */
+#ifdef	DOS
+#define	NO_PIPE
+#endif
+#if	defined(DOS) || defined(OS2)
+#define CRLF_NEWLINES
+#endif
+
+/*
+ * Various parms for opening and creating files directly and via stdio.
+ * NOTE: If "binary" mode file exists, use it.
+ */
+#ifdef	O_BINARY
+#define STDIO_READ	"rb"
+#define STDIO_APPEND	"a+b"
+#else
+#define	O_BINARY	0
+#define	STDIO_READ	"r"
+#define	STDIO_APPEND	"a+"
+#endif
+
+#define	OP_FL_RDWR	(O_RDWR | O_CREAT | O_APPEND | O_BINARY)
+#define	OP_FL_RDONLY	(O_RDONLY | O_BINARY)
+
+#ifdef	S_IREAD
+#define	OP_MD_USER	(S_IREAD | S_IWRITE)
+#else
+#define	OP_MD_USER	0600
+#endif
+
+#ifdef	S_IRUSR
+#define	OP_MD_ALL	(S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | \
+			 S_IROTH | S_IWOTH)
+#else
+#define	OP_MD_ALL	0666
+#endif
+
+
+/*
+ * allocate resources associated with the specified type of
+ * storage.  If requesting a named file object, open it for
+ * appending, else just open a temp file.
+ *
+ * return the filled in storage object
+ */
+STORE_S *
+so_get(source, name, rtype)
+    SourceType  source;			/* requested storage type */
+    char       *name;			/* file name 		  */
+    int		rtype;			/* file access type	  */
+{
+    STORE_S *so = (STORE_S *)fs_get(sizeof(STORE_S));
+
+    memset(so, 0, sizeof(STORE_S));
+    so->flags |= rtype;
+
+    if(name)					/* stash the name */
+      so->name = cpystr(name);
+#ifdef	DOS
+    else if(source == TmpFileStar || source == FileStar){
+	/*
+	 * Coerce to TmpFileStar.  The MSC library's "tmpfile()"
+	 * doesn't observe the "TMP" or "TEMP" environment vars and
+	 * always wants to write "\".  This is problematic in shared,
+	 * networked environments.
+	 */
+	source   = TmpFileStar;
+	so->name = temp_nam(NULL, "pi");
+    }
+#else
+    else if(source == TmpFileStar)		/* make one up! */
+      so->name = temp_nam(NULL, "pine-tmp");
+#endif
+
+    so->src = source;
+    if(so->src == FileStar || so->src == TmpFileStar){
+	so->writec = so_file_writec;
+	so->readc  = so_file_readc;
+	so->puts   = so_file_puts;
+
+	/*
+	 * The reason for both FileStar and TmpFileStar types is
+	 * that, named or unnamed, TmpFileStar's are unlinked
+	 * when the object is given back to the system.  This is
+	 * useful for keeping us from running out of file pointers as
+	 * the pointer associated with the object can be temporarily
+	 * returned to the system without destroying the object.
+	 *
+	 * The programmer is warned to be careful not to assign the
+	 * TmpFileStar type to any files that are expected to remain
+	 * after the dust has settled!
+	 */
+	if(so->name){
+	    if(!(so->txt = so_file_open(so))){
+		dprint(1, (debugfile, "so_get error: %s : %s", so->name,
+			   error_description(errno)));
+		fs_give((void **)&so->name);
+		fs_give((void **)&so); 		/* so freed & set to NULL */
+	    }
+	}
+	else{
+	    if(!(so->txt = (void *) create_tmpfile())){
+		dprint(1, (debugfile, "so_get error: tmpfile : %s",
+			   error_description(errno)));
+		fs_give((void **)&so);		/* so freed & set to NULL */
+	    }
+	}
+    }
+    else if(so->src == PicoText){
+	so->writec = so_pico_writec;
+	so->readc  = so_pico_readc;
+	so->puts   = so_pico_puts;
+	if(!(so->txt = pico_get())){
+	    dprint(1, (debugfile, "so_get error: alloc of pico text space"));
+	    if(so->name)
+	      fs_give((void **)&so->name);
+	    fs_give((void **)&so);		/* so freed & set to NULL */
+	}
+    }
+    else{
+	so->writec = so_cs_writec;
+	so->readc  = so_cs_readc;
+	so->puts   = so_cs_puts;
+	so->txt	   = (void *)fs_get((size_t) MSIZE_INIT * sizeof(char));
+	so->dp	   = so->eod = (unsigned char *) so->txt;
+	so->eot	   = so->dp + MSIZE_INIT;
+	memset(so->eod, 0, so->eot - so->eod);
+    }
+
+    return(so);
+}
+
+
+/*
+ * so_give - free resources associated with a storage object and then
+ *           the object itself.
+ */
+void
+so_give(so)
+STORE_S **so;
+{
+    if(!so)
+      return;
+
+    if((*so)->src == FileStar || (*so)->src == TmpFileStar){
+        if((*so)->txt)
+	  fclose((FILE *)(*so)->txt);	/* disassociate from storage */
+
+	if((*so)->name && (*so)->src == TmpFileStar)
+	  unlink((*so)->name);		/* really disassociate! */
+    }
+    else if((*so)->txt && (*so)->src == PicoText)
+      pico_give((*so)->txt);
+    else if((*so)->txt)
+      fs_give((void **)&((*so)->txt));
+
+    if((*so)->name)
+      fs_give((void **)&((*so)->name));	/* blast the name            */
+
+    fs_give((void **)so);		/* release the object        */
+}
+
+
+/*
+ * so_file_open
+ */
+void *
+so_file_open(so)
+    STORE_S *so;
+{
+    char *type  = ((so->flags) & WRITE_ACCESS) ? STDIO_APPEND : STDIO_READ;
+    int   flags = ((so->flags) & WRITE_ACCESS) ? OP_FL_RDWR : OP_FL_RDONLY,
+	  mode  = (((so->flags) & OWNER_ONLY) || so->src == TmpFileStar)
+		   ? OP_MD_USER : OP_MD_ALL,
+	  fd;
+
+    /*
+     * Use open instead of fopen so we can make temp files private.
+     */
+    return(((fd = open(so->name, flags, mode)) >= 0)
+	     ? (so->txt = (void *) fdopen(fd, type)) : NULL);
+}
+
+
+/*
+ * put a character into the specified storage object,
+ * expanding if neccessary
+ *
+ * return 1 on success and 0 on failure
+ */
+int
+so_cs_writec(c, so)
+    int      c;
+    STORE_S *so;
+{
+    if(so->dp >= so->eot){
+	size_t cur_o  = so->dp - (unsigned char *) so->txt;
+	size_t data_o = so->eod - (unsigned char *) so->txt;
+	size_t size   = (so->eot - (unsigned char *) so->txt) + MSIZE_INC;
+
+	fs_resize(&so->txt, size * sizeof(char));
+	so->dp   = (unsigned char *) so->txt + cur_o;
+	so->eod  = (unsigned char *) so->txt + data_o;
+	so->eot  = (unsigned char *) so->txt + size;
+	memset(so->eod, 0, so->eot - so->eod);
+    }
+
+    *so->dp++ = (unsigned char) c;
+    if(so->dp > so->eod)
+      so->eod = so->dp;
+
+    return(1);
+}
+
+int
+so_pico_writec(c, so)
+    int      c;
+    STORE_S *so;
+{
+    unsigned char ch = (unsigned char) c;
+
+    return(pico_writec(so->txt, ch));
+}
+
+int
+so_file_writec(c, so)
+    int      c;
+    STORE_S *so;
+{
+    unsigned char ch = (unsigned char) c;
+    int rv = 0;
+
+    if(so->txt || so_reaquire(so))
+      do
+	rv = fwrite(&ch,sizeof(unsigned char),(size_t)1,(FILE *)so->txt);
+      while(!rv && ferror((FILE *)so->txt) && errno == EINTR);
+
+    return(rv);
+}
+
+
+/*
+ * get a character from the specified storage object.
+ *
+ * return 1 on success and 0 on failure
+ */
+int
+so_cs_readc(c, so)
+    unsigned char *c;
+    STORE_S       *so;
+{
+    return((so->dp < so->eod) ? *c = *(so->dp)++, 1 : 0);
+}
+
+int
+so_pico_readc(c, so)
+    unsigned char *c;
+    STORE_S       *so;
+{
+    return(pico_readc(so->txt, c));
+}
+
+int
+so_file_readc(c, so)
+    unsigned char *c;
+    STORE_S       *so;
+{
+    int rv = 0;
+
+    if(so->txt || so_reaquire(so))
+      do
+	rv = fread(c, sizeof(char), (size_t)1, (FILE *)so->txt);
+      while(!rv && ferror((FILE *)so->txt) && errno == EINTR);
+
+    return(rv);
+}
+
+
+/*
+ * write a string into the specified storage object,
+ * expanding if necessary (and cheating if the object
+ * happens to be a file!)
+ *
+ * return 1 on success and 0 on failure
+ */
+int
+so_cs_puts(so, s)
+    STORE_S *so;
+    char    *s;
+{
+    int slen = strlen(s);
+
+    if(so->dp + slen >= so->eot){
+	register size_t cur_o  = so->dp - (unsigned char *) so->txt;
+	register size_t data_o = so->eod - (unsigned char *) so->txt;
+	register size_t len   = so->eot - (unsigned char *) so->txt;
+	while(len <= cur_o + slen + 1)
+	  len += MSIZE_INC;		/* need to resize! */
+
+	fs_resize(&so->txt, len * sizeof(char));
+	so->dp	 = (unsigned char *)so->txt + cur_o;
+	so->eod	 = (unsigned char *)so->txt + data_o;
+	so->eot	 = (unsigned char *)so->txt + len;
+	memset(so->eod, 0, so->eot - so->eod);
+    }
+
+    memcpy(so->dp, s, slen);
+    so->dp += slen;
+    if(so->dp > so->eod)
+      so->eod = so->dp;
+
+    return(1);
+}
+
+int
+so_pico_puts(so, s)
+    STORE_S *so;
+    char    *s;
+{
+    return(pico_puts(so->txt, s));
+}
+
+int
+so_file_puts(so, s)
+    STORE_S *so;
+    char    *s;
+{
+    int rv = *s ? 0 : 1;
+
+    if(!rv && (so->txt || so_reaquire(so)))
+      do
+	rv = fwrite(s, strlen(s)*sizeof(char), (size_t)1, (FILE *)so->txt);
+      while(!rv && ferror((FILE *)so->txt) && errno == EINTR);
+
+    return(rv);
+}
+
+
+/*
+ *
+ */
+int
+so_nputs(so, s, n)
+    STORE_S *so;
+    char    *s;
+    long     n;
+{
+    while(n--)
+      if(!so_writec((unsigned char) *s++, so))
+	return(0);		/* ERROR putting char ! */
+
+    return(1);
+}
+
+
+
+/*
+ * Position the storage object's pointer to the given offset
+ * from the start of the object's data.
+ */
+int
+so_seek(so, pos, orig)
+    STORE_S *so;
+    long     pos;
+    int      orig;
+{
+    if(so->src == CharStar){
+	switch(orig){
+	    case 0 :				/* SEEK_SET */
+	      return((pos < so->eod - (unsigned char *) so->txt)
+		      ? so->dp = (unsigned char *)so->txt + pos, 0 : -1);
+	    case 1 :				/* SEEK_CUR */
+	      return((pos > 0)
+		       ? ((pos < so->eod - so->dp) ? so->dp += pos, 0: -1)
+		       : ((pos < 0)
+			   ? ((-pos < so->dp - (unsigned char *)so->txt)
+			        ? so->dp += pos, 0 : -1)
+			   : 0));
+	    case 2 :				/* SEEK_END */
+	      return((pos < so->eod - (unsigned char *) so->txt)
+		      ? so->dp = so->eod - pos, 0 : -1);
+	    default :
+	      return(-1);
+	}
+    }
+    else if(so->src == PicoText)
+      return(pico_seek(so->txt, pos, orig));
+    else			/* FileStar or TmpFileStar */
+      return((so->txt || so_reaquire(so))
+		? fseek((FILE *)so->txt,pos,orig)
+		: -1);
+}
+
+
+/*
+ * Change the given storage object's size to that specified.  If size
+ * is less than the current size, the internal pointer is adjusted and
+ * all previous data beyond the given size is lost.
+ *
+ * Returns 0 on failure.
+ */
+int
+so_truncate(so, size)
+    STORE_S *so;
+    long     size;
+{
+    if(so->src == CharStar){
+	if(so->eod < (unsigned char *) so->txt + size){	/* alloc! */
+	    unsigned char *newtxt = (unsigned char *) so->txt;
+	    register size_t len   = so->eot - (unsigned char *) so->txt;
+
+	    while(len <= size)
+	      len += MSIZE_INC;		/* need to resize! */
+
+	    if(len > so->eot - (unsigned char *) newtxt){
+		fs_resize((void **) &newtxt, len * sizeof(char));
+		so->eot = newtxt + len;
+		so->eod = newtxt + (so->eod - (unsigned char *) so->txt);
+		memset(so->eod, 0, so->eot - so->eod);
+	    }
+
+	    so->eod = newtxt + size;
+	    so->dp  = newtxt + (so->dp - (unsigned char *) so->txt);
+	    so->txt = newtxt;
+	}
+	else if(so->eod > (unsigned char *) so->txt + size){
+	    if(so->dp > (so->eod = (unsigned char *)so->txt + size))
+	      so->dp = so->eod;
+
+	    memset(so->eod, 0, so->eot - so->eod);
+	}
+
+	return(1);
+    }
+    else if(so->src == PicoText){
+	fatal("programmer botch: unsupported so_truncate call");
+	/*NOTREACHED*/
+    }
+    else			/* FileStar or TmpFileStar */
+      return(fflush((FILE *) so->txt) != EOF
+	     && fseek((FILE *) so->txt, size, 0) == 0
+	     && ftruncate(fileno((FILE *)so->txt), size) == 0);
+}
+
+
+/*
+ * so_release - a rather misnamed function.  the idea is to release
+ *              what system resources we can (e.g., open files).
+ *              while maintaining a reference to it.
+ *              it's up to the functions that deal with this object
+ *              next to re-aquire those resources.
+ */
+int
+so_release(so)
+STORE_S *so;
+{
+    if(so->txt && so->name && (so->src == FileStar || so->src == TmpFileStar)){
+	if(fgetpos((FILE *)so->txt, (fpos_t *)&(so->used)) == 0){
+	    fclose((FILE *)so->txt);		/* free the handle! */
+	    so->txt = NULL;
+	}
+    }
+
+    return(1);
+}
+
+
+/*
+ * so_reaquire - get any previously released system resources we
+ *               may need for the given storage object.
+ *       NOTE: at the moment, only FILE * types of objects are
+ *             effected, so it only needs to be called before
+ *             references to them.
+ *
+ */
+so_reaquire(so)
+STORE_S *so;
+{
+    int   rv = 1;
+
+    if(!so->txt && (so->src == FileStar || so->src == TmpFileStar)){
+	if(!(so->txt = so_file_open(so))){
+	    q_status_message2(SM_ORDER,3,5, "ERROR reopening %s : %s", so->name,
+				error_description(errno));
+	    rv = 0;
+	}
+	else if(fsetpos((FILE *)so->txt, (fpos_t *)&(so->used))){
+	    q_status_message2(SM_ORDER, 3, 5, "ERROR positioning in %s : %s",
+				so->name, error_description(errno));
+	    rv = 0;
+	}
+    }
+
+    return(rv);
+}
+
+
+/*
+ * so_text - return a pointer to the text the store object passed
+ */
+void *
+so_text(so)
+STORE_S *so;
+{
+    return((so) ? so->txt : NULL);
+}
+
+
+/*
+ * END OF GENERALIZE STORAGE FUNCTIONS
+ */
+
+
+/*
+ * Start of filters, pipes and various support functions
+ */
+
+/*
+ * pointer to first function in a pipe, and pointer to last filter
+ */
+FILTER_S         *gf_master = NULL;
+static	gf_io_t   last_filter;
+static	char     *gf_error_string;
+static	long	  gf_byte_count;
+static	jmp_buf   gf_error_state;
+
+
+/*
+ * A list of states used by the various filters.  Reused in many filters.
+ */
+#define	DFL	0
+#define	EQUAL	1
+#define	HEX	2
+#define	WSPACE	3
+#define	CCR	4
+#define	CLF	5
+#define	TOKEN	6
+#define	TAG	7
+#define	HANDLE	8
+#define	HDATA	9
+
+
+
+/*
+ * Macros to reduce function call overhead associated with calling
+ * each filter for each byte filtered, and to minimize filter structure
+ * dereferences.  NOTE: "queuein" has to do with putting chars into the
+ * filter structs data queue.  So, writing at the queuein offset is
+ * what a filter does to pass processed data out of itself.  Ditto for
+ * queueout.  This explains the FI --> queueout init stuff below.
+ */
+#define	GF_QUE_START(F)	(&(F)->queue[0])
+#define	GF_QUE_END(F)	(&(F)->queue[GF_MAXBUF - 1])
+
+#define	GF_IP_INIT(F)	ip  = (F) ? &(F)->queue[(F)->queuein] : NULL
+#define	GF_EIB_INIT(F)	eib = (F) ? GF_QUE_END(F) : NULL
+#define	GF_OP_INIT(F)	op  = (F) ? &(F)->queue[(F)->queueout] : NULL
+#define	GF_EOB_INIT(F)	eob = (F) ? &(F)->queue[(F)->queuein] : NULL
+
+#define	GF_IP_END(F)	(F)->queuein  = ip - GF_QUE_START(F)
+#define	GF_OP_END(F)	(F)->queueout = op - GF_QUE_START(F)
+
+#define	GF_INIT(FI, FO)	register unsigned char *GF_OP_INIT(FI);	 \
+			register unsigned char *GF_EOB_INIT(FI); \
+			register unsigned char *GF_IP_INIT(FO);  \
+			register unsigned char *GF_EIB_INIT(FO);
+
+#define	GF_CH_RESET(F)	(op = eob = GF_QUE_START(F), \
+					    (F)->queueout = (F)->queuein = 0)
+
+#define	GF_END(FI, FO)	(GF_OP_END(FI), GF_IP_END(FO))
+
+#define	GF_FLUSH(F)	((int)(GF_IP_END(F), (*(F)->f)((F), GF_DATA), \
+			       GF_IP_INIT(F), GF_EIB_INIT(F)))
+
+#define	GF_PUTC(F, C)	((int)(*ip++ = (C), (ip >= eib) ? GF_FLUSH(F) : 1))
+
+#define	GF_GETC(F, C)	((op < eob) ? (((C) = *op++), 1) : GF_CH_RESET(F))
+
+
+/*
+ * Generalized getc and putc routines.  provided here so they don't
+ * need to be re-done elsewhere to
+ */
+
+/*
+ * pointers to objects to be used by the generic getc and putc
+ * functions
+ */
+static struct gf_io_struct {
+    FILE          *file;
+    char          *txtp;
+    unsigned long  n;
+} gf_in, gf_out;
+
+
+#define	GF_SO_STACK	struct gf_so_stack
+static GF_SO_STACK {
+    STORE_S	*so;
+    GF_SO_STACK *next;
+} *gf_so_in, *gf_so_out;
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * getc function
+ */
+void
+gf_set_readc(gc, txt, len, src)
+    gf_io_t       *gc;
+    void          *txt;
+    unsigned long  len;
+    SourceType     src;
+{
+    gf_in.n = len;
+    if(src == FileStar){
+	gf_in.file = (FILE *)txt;
+	fseek(gf_in.file, 0L, 0);
+	*gc = gf_freadc;
+    }
+    else{
+	gf_in.txtp = (char *)txt;
+	*gc = gf_sreadc;
+    }
+}
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * putc function
+ */
+void
+gf_set_writec(pc, txt, len, src)
+    gf_io_t       *pc;
+    void          *txt;
+    unsigned long  len;
+    SourceType     src;
+{
+    gf_out.n = len;
+    if(src == FileStar){
+	gf_out.file = (FILE *)txt;
+	*pc = gf_fwritec;
+    }
+    else{
+	gf_out.txtp = (char *)txt;
+	*pc = gf_swritec;
+    }
+}
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * getc function
+ */
+void
+gf_set_so_readc(gc, so)
+    gf_io_t *gc;
+    STORE_S *so;
+{
+    GF_SO_STACK *sp = (GF_SO_STACK *) fs_get(sizeof(GF_SO_STACK));
+
+    sp->so   = so;
+    sp->next = gf_so_in;
+    gf_so_in = sp;
+    *gc      = gf_so_readc;
+}
+
+
+void
+gf_clear_so_readc(so)
+    STORE_S *so;
+{
+    GF_SO_STACK *sp;
+
+    if(sp = gf_so_in){
+	if(so == sp->so){
+	    gf_so_in = gf_so_in->next;
+	    fs_give((void **) &sp);
+	}
+	else
+	  panic("Programmer botch: Can't unstack store readc");
+    }
+    else
+      panic("Programmer botch: NULL store clearing store readc");
+}
+
+
+/*
+ * setup to use and return a pointer to the generic
+ * putc function
+ */
+void
+gf_set_so_writec(pc, so)
+    gf_io_t *pc;
+    STORE_S *so;
+{
+    GF_SO_STACK *sp = (GF_SO_STACK *) fs_get(sizeof(GF_SO_STACK));
+
+    sp->so    = so;
+    sp->next  = gf_so_out;
+    gf_so_out = sp;
+    *pc       = gf_so_writec;
+}
+
+
+void
+gf_clear_so_writec(so)
+    STORE_S *so;
+{
+    GF_SO_STACK *sp;
+
+    if(sp = gf_so_out){
+	if(so == sp->so){
+	    gf_so_out = gf_so_out->next;
+	    fs_give((void **) &sp);
+	}
+	else
+	  panic("Programmer botch: Can't unstack store writec");
+    }
+    else
+      panic("Programmer botch: NULL store clearing store writec");
+}
+
+
+/*
+ * put the character to the object previously defined
+ */
+int
+gf_so_writec(c)
+int c;
+{
+    return(so_writec(c, gf_so_out->so));
+}
+
+
+/*
+ * get a character from an object previously defined
+ */
+int
+gf_so_readc(c)
+unsigned char *c;
+{
+    return(so_readc(c, gf_so_in->so));
+}
+
+
+/* get a character from a file */
+/* assumes gf_out struct is filled in */
+int
+gf_freadc(c)
+unsigned char *c;
+{
+    int rv = 0;
+
+    do {
+	errno = 0;
+	clearerr(gf_in.file);
+	rv = fread(c, sizeof(unsigned char), (size_t)1, gf_in.file);
+    } while(!rv && ferror(gf_in.file) && errno == EINTR);
+
+    return(rv);
+}
+
+
+/* put a character to a file */
+/* assumes gf_out struct is filled in */
+int
+gf_fwritec(c)
+    int c;
+{
+    unsigned char ch = (unsigned char)c;
+    int rv = 0;
+
+    do
+      rv = fwrite(&ch, sizeof(unsigned char), (size_t)1, gf_out.file);
+    while(!rv && ferror(gf_out.file) && errno == EINTR);
+
+    return(rv);
+}
+
+
+/* get a character from a string, return nonzero if things OK */
+/* assumes gf_out struct is filled in */
+int
+gf_sreadc(c)
+unsigned char *c;
+{
+    return((gf_in.n) ? *c = *(gf_in.txtp)++, gf_in.n-- : 0);
+}
+
+
+/* put a character into a string, return nonzero if things OK */
+/* assumes gf_out struct is filled in */
+int
+gf_swritec(c)
+    int c;
+{
+    return((gf_out.n) ? *(gf_out.txtp)++ = c, gf_out.n-- : 0);
+}
+
+
+/*
+ * output the given string with the given function
+ */
+int
+gf_puts(s, pc)
+    register char *s;
+    gf_io_t        pc;
+{
+    while(*s != '\0')
+      if(!(*pc)((unsigned char)*s++))
+	return(0);		/* ERROR putting char ! */
+
+    return(1);
+}
+
+
+/*
+ * output the given string with the given function
+ */
+int
+gf_nputs(s, n, pc)
+    register char *s;
+    long	   n;
+    gf_io_t        pc;
+{
+    while(n--)
+      if(!(*pc)((unsigned char)*s++))
+	return(0);		/* ERROR putting char ! */
+
+    return(1);
+}
+
+
+/*
+ * Start of generalized filter routines
+ */
+
+/*
+ * initializing function to make sure list of filters is empty.
+ */
+void
+gf_filter_init()
+{
+    FILTER_S *flt, *fltn = gf_master;
+
+    while((flt = fltn) != NULL){	/* free list of old filters */
+	fltn = flt->next;
+	fs_give((void **)&flt);
+    }
+
+    gf_master = NULL;
+    gf_error_string = NULL;		/* clear previous errors */
+    gf_byte_count = 0L;			/* reset counter */
+}
+
+
+
+/*
+ * link the given filter into the filter chain
+ */
+void
+gf_link_filter(f, data)
+    filter_t  f;
+    void     *data;
+{
+    FILTER_S *new, *tail;
+
+#ifdef	CRLF_NEWLINES
+    /*
+     * If the system's native EOL convention is CRLF, then there's no
+     * point in passing data thru a filter that's not doing anything
+     */
+    if(f == gf_nvtnl_local || f == gf_local_nvtnl)
+      return;
+#endif
+
+    new = (FILTER_S *)fs_get(sizeof(FILTER_S));
+    memset(new, 0, sizeof(FILTER_S));
+
+    new->f = f;				/* set the function pointer     */
+    new->opt = data;			/* set any optional parameter data */
+    (*f)(new, GF_RESET);		/* have it setup initial state  */
+
+    if(tail = gf_master){		/* or add it to end of existing  */
+	while(tail->next)		/* list  */
+	  tail = tail->next;
+
+	tail->next = new;
+    }
+    else				/* attach new struct to list    */
+      gf_master = new;			/* start a new list */
+}
+
+
+/*
+ * terminal filter, doesn't call any other filters, typically just does
+ * something with the output
+ */
+void
+gf_terminal(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    if(flg == GF_DATA){
+	GF_INIT(f, f);
+
+	while(op < eob)
+	  if((*last_filter)(*op++) <= 0) /* generic terminal filter */
+	    gf_error(errno ? error_description(errno) : "Error writing pipe");
+
+	GF_CH_RESET(f);
+    }
+    else if(flg == GF_RESET)
+      errno = 0;			/* prepare for problems */
+}
+
+
+/*
+ * set some outside gf_io_t function to the terminal function
+ * for example: a function to write a char to a file or into a buffer
+ */
+void
+gf_set_terminal(f)			/* function to set generic filter */
+    gf_io_t f;
+{
+    last_filter = f;
+}
+
+
+/*
+ * common function for filter's to make it known that an error
+ * has occurred.  Jumps back to gf_pipe with error message.
+ */
+void
+gf_error(s)
+    char *s;
+{
+    /* let the user know the error passed in s */
+    gf_error_string = s;
+    longjmp(gf_error_state, 1);
+}
+
+
+/*
+ * The routine that shoves each byte through the chain of
+ * filters.  It sets up error handling, and the terminal function.
+ * Then loops getting bytes with the given function, and passing
+ * it on to the first filter in the chain.
+ */
+char *
+gf_pipe(gc, pc)
+    gf_io_t gc, pc;			/* how to get a character */
+{
+    unsigned char c;
+
+#if	defined(DOS) && !defined(_WINDOWS)
+    MoveCursor(0, 1);
+    StartInverse();
+#endif
+
+    dprint(4, (debugfile, "-- gf_pipe: "));
+
+    /*
+     * set up for any errors a filter may encounter
+     */
+    if(setjmp(gf_error_state)){
+#if	defined(DOS) && !defined(_WINDOWS)
+	ibmputc(' ');
+	EndInverse();
+#endif
+	dprint(4, (debugfile, "ERROR: %s\n",
+		   gf_error_string ? gf_error_string : "NULL"));
+	return(gf_error_string); 	/*  */
+    }
+
+    /*
+     * set and link in the terminal filter
+     */
+    gf_set_terminal(pc);
+    gf_link_filter(gf_terminal, NULL);
+
+    /*
+     * while there are chars to process, send them thru the pipe.
+     * NOTE: it's necessary to enclose the loop below in a block
+     * as the GF_INIT macro calls some automatic var's into
+     * existence.  It can't be placed at the start of gf_pipe
+     * because its useful for us to be called without filters loaded
+     * when we're just being used to copy bytes between storage
+     * objects.
+     */
+    {
+	GF_INIT(gf_master, gf_master);
+
+	while((*gc)(&c)){
+	    gf_byte_count++;
+#ifdef	DOS
+	    if(!(gf_byte_count & 0x3ff))
+#ifdef	_WINDOWS
+	      /* Under windows we yeild to allow event processing.
+	       * Progress display is handled throught the alarm()
+	       * mechinism.
+	       */
+	      mswin_yeild ();
+#else
+	      /* Poor PC still needs spinning bar */
+	      ibmputc("/-\\|"[((int) gf_byte_count >> 10) % 4]);
+	      MoveCursor(0, 1);
+#endif
+#endif
+
+	    GF_PUTC(gf_master, c & 0xff);
+	}
+
+	/*
+	 * toss an end-of-data marker down the pipe to give filters
+	 * that have any buffered data the opportunity to dump it
+	 */
+	GF_FLUSH(gf_master);
+	(*gf_master->f)(gf_master, GF_EOD);
+    }
+
+#if	defined(DOS) && !defined(_WINDOWS)
+    ibmputc(' ');
+    EndInverse();
+#endif
+
+    dprint(1, (debugfile, "done.\n"));
+    return(NULL);			/* everything went OK */
+}
+
+
+/*
+ * return the number of bytes piped so far
+ */
+long
+gf_bytes_piped()
+{
+    return(gf_byte_count);
+}
+
+
+/*
+ * filter the given input with the given command
+ *
+ *  Args: cmd -- command string to execute
+ *	prepend -- string to prepend to filtered input
+ *	source_so -- storage object containing data to be filtered
+ *	pc -- function to write filtered output with
+ *	aux_filters -- additional filters to pass data thru after "cmd"
+ *
+ *  Returns: NULL on sucess, reason for failure (not alloc'd!) on error
+ */
+char *
+gf_filter(cmd, prepend, source_so, pc, aux_filters)
+    char       *cmd, *prepend;
+    STORE_S    *source_so;
+    gf_io_t	pc;
+    FILTLIST_S *aux_filters;
+{
+    unsigned char c;
+    int	     flags;
+    char   *errstr = NULL, buf[MAILTMPLEN], *rfile = NULL;
+    PIPE_S *fpipe;
+
+    dprint(4, (debugfile, "so_filter: \"%s\"\n", cmd));
+
+    gf_filter_init();
+    for( ; aux_filters && aux_filters->filter; aux_filters++)
+      gf_link_filter(aux_filters->filter, aux_filters->data);
+
+    gf_set_terminal(pc);
+    gf_link_filter(gf_terminal, NULL);
+
+    /*
+     * Spawn filter feeding it data, and reading what it writes.
+     */
+    so_seek(source_so, 0L, 0);
+#ifdef	NO_PIPE
+    /*
+     * When there're no pipes for IPC, use an output file to collect
+     * the result...
+     */
+    flags = PIPE_WRITE | PIPE_NOSHELL | PIPE_RESET;
+    rfile = temp_nam(NULL, "pf");
+#else
+    flags = PIPE_WRITE | PIPE_READ | PIPE_NOSHELL | PIPE_RESET;
+#endif
+
+    if(fpipe = open_system_pipe(cmd, rfile ? &rfile : NULL, NULL, flags, 0)){
+#ifdef	NO_PIPE
+	if(prepend && (fputs(prepend, fpipe->out.f) == EOF
+		       || fputc('\n', fpipe->out.f) == EOF))
+	  errstr = error_description(errno);
+
+	/*
+	 * Write the output, and deal with the result later...
+	 */
+	while(!errstr && so_readc(&c, source_so))
+	  if(fputc(c, fpipe->out.f) == EOF)
+	    errstr = error_description(errno);
+#else
+#ifdef	NON_BLOCKING_IO
+	int     n;
+
+	if(fcntl(fileno(fpipe->in.f), F_SETFL, NON_BLOCKING_IO) == -1)
+	  errstr = "Can't set up non-blocking IO";
+
+	if(prepend && (fputs(prepend, fpipe->out.f) == EOF
+		       || fputc('\n', fpipe->out.f) == EOF))
+	  errstr = error_description(errno);
+
+	while(!errstr){
+	    /* if the pipe can't hold a K we're sunk (too bad PIPE_MAX
+	     * isn't ubiquitous ;).
+	     */
+	    for(n = 0; !errstr && fpipe->out.f && n < 1024; n++)
+	      if(!so_readc(&c, source_so)){
+		  fclose(fpipe->out.f);
+		  fpipe->out.f = NULL;
+	      }
+	      else if(fputc(c, fpipe->out.f) == EOF)
+		errstr = error_description(errno);
+
+	    /*
+	     * Note: We clear errno here and test below, before ferror,
+	     *	     because *some* stdio implementations consider
+	     *	     EAGAIN and EWOULDBLOCK equivalent to EOF...
+	     */
+	    errno = 0;
+	    clearerr(fpipe->in.f); /* fix from <cananian@cananian.mit.edu> */
+
+	    while(!errstr && fgets(buf, MAILTMPLEN, fpipe->in.f))
+	      errstr = gf_filter_puts(buf);
+
+	    /* then fgets failed! */
+	    if(!errstr && !(errno == EAGAIN || errno == EWOULDBLOCK)){
+		if(feof(fpipe->in.f))		/* nothing else interesting! */
+		  break;
+		else if(ferror(fpipe->in.f))	/* bummer. */
+		  errstr = error_description(errno);
+	    }
+	    else if(errno == EAGAIN || errno == EWOULDBLOCK)
+	      clearerr(fpipe->in.f);
+	}
+#else
+	if(prepend && (fputs(prepend, fpipe->out.f) == EOF
+		       || fputc('\n', fpipe->out.f) == EOF))
+	  errstr = error_description(errno);
+
+	/*
+	 * Well, do the best we can, and hope the pipe we're writing
+	 * doesn't fill up before we start reading...
+	 */
+	while(!errstr && so_readc(&c, source_so))
+	  if(fputc(c, fpipe->out.f) == EOF)
+	    errstr = error_description(errno);
+
+	fclose(fpipe->out.f);
+	fpipe->out.f = NULL;
+	while(!errstr && fgets(buf, MAILTMPLEN, fpipe->in.f))
+	  errstr = gf_filter_puts(buf);
+#endif /* NON_BLOCKING */
+#endif /* NO_PIPE */
+
+	gf_filter_eod();
+
+	if(close_system_pipe(&fpipe) && !errstr)
+	  errstr = "Pipe command returned error.";
+
+#ifdef	NO_PIPE
+	/*
+	 * retrieve filters result...
+	 */
+	{
+	    FILE *fp;
+
+	    if(fp = fopen(rfile, STDIO_READ)){
+		while(!errstr && fgets(buf, MAILTMPLEN, fp))
+		  errstr = gf_filter_puts(buf);
+
+		fclose(fp);
+	    }
+
+	    fs_give((void **)&rfile);
+	}
+#endif
+    }
+
+    return(errstr);
+}
+
+
+/*
+ * gf_filter_puts - write the given string down the filter's pipe
+ */
+char *
+gf_filter_puts(s)
+    register char *s;
+{
+    GF_INIT(gf_master, gf_master);
+
+    /*
+     * set up for any errors a filter may encounter
+     */
+    if(setjmp(gf_error_state)){
+	dprint(4, (debugfile, "ERROR: gf_filter_puts: %s\n",
+		   gf_error_string ? gf_error_string : "NULL"));
+	return(gf_error_string);
+    }
+
+    while(*s)
+      GF_PUTC(gf_master, (*s++) & 0xff);
+
+    GF_END(gf_master, gf_master);
+    return(NULL);
+}
+
+
+/*
+ * gf_filter_eod - flush pending data filter's input queue and deliver
+ *		   the GF_EOD marker.
+ */
+void
+gf_filter_eod()
+{
+    GF_INIT(gf_master, gf_master);
+    GF_FLUSH(gf_master);
+    (*gf_master->f)(gf_master, GF_EOD);
+}
+
+
+
+
+/*
+ * END OF PIPE SUPPORT ROUTINES, BEGINNING OF FILTERS
+ *
+ * Filters MUST use the specified interface (pointer to filter
+ * structure, the unsigned character buffer in that struct, and a
+ * cmd flag), and pass each resulting octet to the next filter in the
+ * chain.  Only the terminal filter need not call another filter.
+ * As a result, filters share a pretty general structure.
+ * Typically three main conditionals separate initialization from
+ * data from end-of-data command processing.
+ *
+ * Lastly, being character-at-a-time, they're a little more complex
+ * to write than filters operating on buffers because some state
+ * must typically be kept between characters.  However, for a
+ * little bit of complexity here, much convenience is gained later
+ * as they can be arbitrarily chained together at run time and
+ * consume few resources (especially memory or disk) as they work.
+ * (NOTE 951005: even less cpu now that data between filters is passed
+ *  via a vector.)
+ *
+ * A few notes about implementing filters:
+ *
+ *  - A generic filter template looks like:
+ *
+ *    void
+ *    gf_xxx_filter(f, flg)
+ *        FILTER_S *f;
+ *        int       flg;
+ *    {
+ *	  GF_INIT(f, f->next);		// def's var's to speed queue drain
+ *
+ *        if(flg == GF_DATA){
+ *	      register unsigned char c;
+ *
+ *	      while(GF_GETC(f, c)){	// macro taking data off input queue
+ *	          // operate on c and pass it on here
+ *                GF_PUTC(f->next, c);	// macro writing output queue
+ *	      }
+ *
+ *	      GF_END(f, f->next);	// macro to sync pointers/offsets
+ *	      //WARNING: DO NOT RETURN BEFORE ALL INCOMING DATA'S PROCESSED
+ *        }
+ *        else if(flg == GF_EOD){
+ *            // process any buffered data here and pass it on
+ *	      GF_FLUSH(f->next);	// flush pending data to next filter
+ *            (*f->next->f)(f->next, GF_EOD);
+ *        }
+ *        else if(flg == GF_RESET){
+ *            // initialize any data in the struct here
+ *        }
+ *    }
+ *
+ *  - Any free storage allocated during initialization (typically tied
+ *    to the "line" pointer in FILTER_S) is the filter's responsibility
+ *    to clean up when the GF_EOD command comes through.
+ *
+ *  - Filter's must pass GF_EOD they receive on to the next
+ *    filter in the chain so it has the opportunity to flush
+ *    any buffered data.
+ *
+ *  - All filters expect NVT end-of-lines.  The idea is to prepend
+ *    or append either the gf_local_nvtnl or gf_nvtnl_local
+ *    os-dependant filters to the data on the appropriate end of the
+ *    pipe for the task at hand.
+ *
+ *  - NOTE: As of 951004, filters no longer take their input as a single
+ *    char argument, but rather get data to operate on via a vector
+ *    representing the input queue in the FILTER_S structure.
+ *
+ */
+
+
+
+/*
+ * BASE64 TO BINARY encoding and decoding routines below
+ */
+
+
+/*
+ * BINARY to BASE64 filter (encoding described in rfc1341)
+ */
+void
+gf_binary_b64(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    static char *v =
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register unsigned char t = f->t;
+	register long n = f->n;
+
+	while(GF_GETC(f, c)){
+
+	    switch(n++){
+	      case 0 : case 3 : case 6 : case 9 : case 12: case 15: case 18:
+	      case 21: case 24: case 27: case 30: case 33: case 36: case 39:
+	      case 42: case 45:
+		GF_PUTC(f->next, v[c >> 2]);
+					/* byte 1: high 6 bits (1) */
+		t = c << 4;		/* remember high 2 bits for next */
+		break;
+
+	      case 1 : case 4 : case 7 : case 10: case 13: case 16: case 19:
+	      case 22: case 25: case 28: case 31: case 34: case 37: case 40:
+	      case 43:
+		GF_PUTC(f->next, v[(t|(c>>4)) & 0x3f]);
+		t = c << 2;
+		break;
+
+	      case 2 : case 5 : case 8 : case 11: case 14: case 17: case 20:
+	      case 23: case 26: case 29: case 32: case 35: case 38: case 41:
+	      case 44:
+		GF_PUTC(f->next, v[(t|(c >> 6)) & 0x3f]);
+		GF_PUTC(f->next, v[c & 0x3f]);
+		break;
+	    }
+
+	    if(n == 45){			/* start a new line? */
+		GF_PUTC(f->next, '\015');
+		GF_PUTC(f->next, '\012');
+		n = 0L;
+	    }
+	}
+
+	f->n = n;
+	f->t = t;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){		/* no more data */
+	switch (f->n % 3) {		/* handle trailing bytes */
+	  case 0:			/* no trailing bytes */
+	    break;
+
+	  case 1:
+	    GF_PUTC(f->next, v[(f->t) & 0x3f]);
+	    GF_PUTC(f->next, '=');	/* byte 3 */
+	    GF_PUTC(f->next, '=');	/* byte 4 */
+	    break;
+
+	  case 2:
+	    GF_PUTC(f->next, v[(f->t) & 0x3f]);
+	    GF_PUTC(f->next, '=');	/* byte 4 */
+	    break;
+	}
+
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset binary_b64\n"));
+	f->n = 0L;
+    }
+}
+
+
+
+/*
+ * BASE64 to BINARY filter (encoding described in rfc1341)
+ */
+void
+gf_b64_binary(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    static char v[] = {65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,
+		       65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,65,
+		       65,65,65,65,65,65,65,65,65,65,65,62,65,65,65,63,
+		       52,53,54,55,56,57,58,59,60,61,62,65,65,64,65,65,
+		       65, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+		       15,16,17,18,19,20,21,22,23,24,25,65,65,65,65,65,
+		       65,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+		       41,42,43,44,45,46,47,48,49,50,51,65,65,65,65,65};
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register unsigned char t = f->t;
+	register int n = (int) f->n;
+	register int state = f->f1;
+
+	while(GF_GETC(f, c)){
+
+	    if(state){
+		state = 0;
+		if (c != '=') {
+		    gf_error("Illegal '=' in base64 text");
+		    /* NO RETURN */
+		}
+	    }
+
+	    /* in range, and a valid value? */
+	    if((c & ~0x7f) || (c = v[c]) > 63){
+		if(c == 64){
+		    switch (n++) {	/* check quantum position */
+		      case 2:
+			state++;	/* expect an equal as next char */
+			break;
+
+		      case 3:
+			n = 0L;		/* restart quantum */
+			break;
+
+		      default:		/* impossible quantum position */
+			gf_error("Internal base64 decoder error");
+			/* NO RETURN */
+		    }
+		}
+	    }
+	    else{
+		switch (n++) {		/* install based on quantum position */
+		  case 0:		/* byte 1: high 6 bits */
+		    t = c << 2;
+		    break;
+
+		  case 1:		/* byte 1: low 2 bits */
+		    GF_PUTC(f->next, (t|(c >> 4)));
+		    t = c << 4;		/* byte 2: high 4 bits */
+		    break;
+
+		  case 2:		/* byte 2: low 4 bits */
+		    GF_PUTC(f->next, (t|(c >> 2)));
+		    t = c << 6;		/* byte 3: high 2 bits */
+		    break;
+
+		  case 3:
+		    GF_PUTC(f->next, t | c);
+		    n = 0L;		/* reinitialize mechanism */
+		    break;
+		}
+	    }
+	}
+
+	f->f1 = state;
+	f->t = t;
+	f->n = n;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset b64_binary\n"));
+	f->n  = 0L;			/* quantum position */
+	f->f1 = 0;			/* state holder: equal seen? */
+    }
+}
+
+
+
+
+/*
+ * QUOTED-PRINTABLE ENCODING AND DECODING filters below.
+ * encoding described in rfc1341
+ */
+
+#define	GF_MAXLINE	80		/* good buffer size */
+
+/*
+ * default action for QUOTED-PRINTABLE to 8BIT decoder
+ */
+#define	GF_QP_DEFAULT(f, c)	{ \
+				    if((c) == ' '){ \
+					state = WSPACE; \
+						/* reset white space! */ \
+					(f)->linep = (f)->line; \
+					*((f)->linep)++ = ' '; \
+				    } \
+				    else if((c) == '='){ \
+					state = EQUAL; \
+				    } \
+				    else \
+				      GF_PUTC((f)->next, (c)); \
+				}
+
+
+/*
+ * QUOTED-PRINTABLE to 8BIT filter
+ */
+void
+gf_qp_8bit(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register int state = f->f1;
+
+	while(GF_GETC(f, c)){
+
+	    switch(state){
+	      case DFL :		/* default case */
+	      default:
+		GF_QP_DEFAULT(f, c);
+		break;
+
+	      case CCR    :		/* non-significant space */
+		state = DFL;
+		if(c == '\012')
+		  continue;		/* go on to next char */
+
+		GF_QP_DEFAULT(f, c);
+		break;
+
+	      case EQUAL  :
+		if(c == '\015'){	/* "=\015" is a soft EOL */
+		    state = CCR;
+		    break;
+		}
+
+		if(c == '='){		/* compatibility clause for old guys */
+		    GF_PUTC(f->next, '=');
+		    state = DFL;
+		    break;
+		}
+
+		if(!isxdigit((unsigned char)c)){	/* must be hex! */
+		    fs_give((void **)&(f->line));
+		    gf_error("Non-hexadecimal character in QP encoding");
+		    /* NO RETURN */
+		}
+
+		if (isdigit ((unsigned char)c))
+		  f->t = c - '0';
+		else
+		  f->t = c - (isupper((unsigned char)c) ? 'A' - 10 : 'a' - 10);
+
+		state = HEX;
+		break;
+
+	      case HEX :
+		state = DFL;
+		if(!isxdigit((unsigned char)c)){	/* must be hex! */
+		    fs_give((void **)&(f->line));
+		    gf_error("Non-hexadecimal character in QP encoding");
+		    /* NO RETURN */
+		}
+
+		if (isdigit((unsigned char)c))
+		  c -= '0';
+		else
+		  c -= (isupper((unsigned char)c) ? 'A' - 10 : 'a' - 10);
+
+		GF_PUTC(f->next, c + (f->t << 4));
+		break;
+
+	      case WSPACE :
+		if(c == ' '){		/* toss it in with other spaces */
+		    if(f->linep - f->line < GF_MAXLINE)
+		      *(f->linep)++ = ' ';
+		    break;
+		}
+
+		state = DFL;
+		if(c == '\015'){	/* not our white space! */
+		    f->linep = f->line;	/* reset buffer */
+		    GF_PUTC(f->next, '\015');
+		    break;
+		}
+
+		/* the spaces are ours, write 'em */
+		f->n = f->linep - f->line;
+		while((f->n)--)
+		  GF_PUTC(f->next, ' ');
+
+		GF_QP_DEFAULT(f, c);	/* take care of 'c' in default way */
+		break;
+	    }
+	}
+
+	f->f1 = state;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	fs_give((void **)&(f->line));
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset qp_8bit\n"));
+	f->f1 = DFL;
+	f->linep = f->line = (char *)fs_get(GF_MAXLINE * sizeof(char));
+    }
+}
+
+
+
+/*
+ * USEFUL MACROS TO HELP WITH QP ENCODING
+ */
+
+#define	QP_MAXL	75			/* 76th place only for continuation */
+
+/*
+ * Macro to test and wrap long quoted printable lines
+ */
+#define	GF_8BIT_WRAP(f)		{ \
+				    GF_PUTC((f)->next, '='); \
+				    GF_PUTC((f)->next, '\015'); \
+				    GF_PUTC((f)->next, '\012'); \
+				}
+
+/*
+ * write a quoted octet in QUOTED-PRINTABLE encoding, adding soft
+ * line break if needed.
+ */
+#define	GF_8BIT_PUT_QUOTE(f, c)	{ \
+				    if(((f)->n += 3) > QP_MAXL){ \
+					GF_8BIT_WRAP(f); \
+					(f)->n = 3;	/* set line count */ \
+				    } \
+				    GF_PUTC((f)->next, '='); \
+				     GF_PUTC((f)->next, HEX_CHAR1(c)); \
+				     GF_PUTC((f)->next, HEX_CHAR2(c)); \
+				 }
+
+/*
+ * just write an ordinary octet in QUOTED-PRINTABLE, wrapping line
+ * if needed.
+ */
+#define	GF_8BIT_PUT(f, c)	{ \
+				      if((++(f->n)) > QP_MAXL){ \
+					  GF_8BIT_WRAP(f); \
+					  f->n = 1L; \
+				      } \
+				      if(f->n == 1L && c == '.'){ \
+					  GF_8BIT_PUT_QUOTE(f, c); \
+					  f->n = 3; \
+				      } \
+				      else \
+					GF_PUTC(f->next, c); \
+				 }
+
+
+/*
+ * default action for 8bit to quoted printable encoder
+ */
+#define	GF_8BIT_DEFAULT(f, c)	if((c) == ' '){ \
+				     state = WSPACE; \
+				 } \
+				 else if(c == '\015'){ \
+				     state = CCR; \
+				 } \
+				 else if(iscntrl(c & 0x7f) || (c == 0x7f) \
+					 || (c & 0x80) || (c == '=')){ \
+				     GF_8BIT_PUT_QUOTE(f, c); \
+				 } \
+				 else{ \
+				   GF_8BIT_PUT(f, c); \
+				 }
+
+
+/*
+ * 8BIT to QUOTED-PRINTABLE filter
+ */
+void
+gf_8bit_qp(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    short dummy_dots = 0, dummy_dmap = 1;
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	 register unsigned char c;
+	 register int state = f->f1;
+
+	 while(GF_GETC(f, c)){
+
+	     /* keep track of "^JFrom " */
+	     Find_Froms(f->t, dummy_dots, f->f2, dummy_dmap, c);
+
+	     switch(state){
+	       case DFL :		/* handle ordinary case */
+		 GF_8BIT_DEFAULT(f, c);
+		 break;
+
+	       case CCR :		/* true line break? */
+		 state = DFL;
+		 if(c == '\012'){
+		     GF_PUTC(f->next, '\015');
+		     GF_PUTC(f->next, '\012');
+		     f->n = 0L;
+		 }
+		 else{			/* nope, quote the CR */
+		     GF_8BIT_PUT_QUOTE(f, '\015');
+		     GF_8BIT_DEFAULT(f, c); /* and don't forget about c! */
+		 }
+		 break;
+
+	       case WSPACE:
+		 state = DFL;
+		 if(c == '\015' || f->t){ /* handle the space */
+		     GF_8BIT_PUT_QUOTE(f, ' ');
+		     f->t = 0;		/* reset From flag */
+		 }
+		 else
+		   GF_8BIT_PUT(f, ' ');
+
+		 GF_8BIT_DEFAULT(f, c);	/* handle 'c' in the default way */
+		 break;
+	     }
+	 }
+
+	 f->f1 = state;
+	 GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	 switch(f->f1){
+	   case CCR :
+	     GF_8BIT_PUT_QUOTE(f, '\015'); /* write the last cr */
+	     break;
+
+	   case WSPACE :
+	     GF_8BIT_PUT_QUOTE(f, ' ');	/* write the last space */
+	     break;
+	 }
+
+	 GF_FLUSH(f->next);
+	 (*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	 dprint(9, (debugfile, "-- gf_reset 8bit_qp\n"));
+	 f->f1 = DFL;			/* state from last character        */
+	 f->f2 = 1;			/* state of "^NFrom " bitmap        */
+	 f->t  = 0;
+	 f->n  = 0L;			/* number of chars in current line  */
+    }
+}
+
+
+
+/*
+ * RICHTEXT-TO-PLAINTEXT filter
+ */
+
+/*
+ * option to be used by rich2plain (NOTE: if this filter is ever
+ * used more than once in a pipe, all instances will have the same
+ * option value)
+ */
+
+
+/*----------------------------------------------------------------------
+      richtext to plaintext filter
+
+ Args: f --
+	flg  --
+
+  This basically removes all richtext formatting. A cute hack is used
+  to get bold and underlining to work.
+  Further work could be done to handle things like centering and right
+  and left flush, but then it could no longer be done in place. This
+  operates on text *with* CRLF's.
+
+  WARNING: does not wrap lines!
+ ----*/
+void
+gf_rich2plain(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+/* BUG: qoute incoming \255 values */
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	 register unsigned char c;
+	 register int state = f->f1;
+
+	 while(GF_GETC(f, c)){
+
+	     switch(state){
+	       case TOKEN :		/* collect a richtext token */
+		 if(c == '>'){		/* what should we do with it? */
+		     state       = DFL;	/* return to default next time */
+		     *(f->linep) = '\0';	/* cap off token */
+		     if(f->line[0] == 'l' && f->line[1] == 't'){
+			 GF_PUTC(f->next, '<'); /* literal '<' */
+		     }
+		     else if(f->line[0] == 'n' && f->line[1] == 'l'){
+			 GF_PUTC(f->next, '\015');/* newline! */
+			 GF_PUTC(f->next, '\012');
+		     }
+		     else if(!strcmp("comment", f->line)){
+			 (f->f2)++;
+		     }
+		     else if(!strcmp("/comment", f->line)){
+			 f->f2 = 0;
+		     }
+		     else if(!strcmp("/paragraph", f->line)) {
+			 GF_PUTC(f->next, '\r');
+			 GF_PUTC(f->next, '\n');
+			 GF_PUTC(f->next, '\r');
+			 GF_PUTC(f->next, '\n');
+		     }
+		     else if(!f->opt /* gf_rich_plain */){
+			 if(!strcmp(f->line, "bold")) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, TAG_BOLDON);
+			 } else if(!strcmp(f->line, "/bold")) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, TAG_BOLDOFF);
+			 } else if(!strcmp(f->line, "italic")) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, TAG_ULINEON);
+			 } else if(!strcmp(f->line, "/italic")) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, TAG_ULINEOFF);
+			 } else if(!strcmp(f->line, "underline")) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, TAG_ULINEON);
+			 } else if(!strcmp(f->line, "/underline")) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, TAG_ULINEOFF);
+			 }
+		     }
+		     /* else we just ignore the token! */
+
+		     f->linep = f->line;	/* reset token buffer */
+		 }
+		 else{			/* add char to token */
+		     if(f->linep - f->line > 40){
+			 /* What? rfc1341 says 40 char tokens MAX! */
+			 fs_give((void **)&(f->line));
+			 gf_error("Richtext token over 40 characters");
+			 /* NO RETURN */
+		     }
+
+		     *(f->linep)++ = isupper((unsigned char)c) ? c-'A'+'a' : c;
+		 }
+		 break;
+
+	       case CCR   :
+		 state = DFL;		/* back to default next time */
+		 if(c == '\012'){	/* treat as single space?    */
+		     GF_PUTC(f->next, ' ');
+		     break;
+		 }
+		 /* fall thru to process c */
+
+	       case DFL   :
+	       default:
+		 if(c == '<')
+		   state = TOKEN;
+		 else if(c == '\015')
+		   state = CCR;
+		 else if(!f->f2)		/* not in comment! */
+		   GF_PUTC(f->next, c);
+
+		 break;
+	     }
+	 }
+
+	 f->f1 = state;
+	 GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	 if(f->f1 = (f->linep != f->line)){
+	     /* incomplete token!! */
+	     gf_error("Incomplete token in richtext");
+	     /* NO RETURN */
+	 }
+
+	 fs_give((void **)&(f->line));
+	 GF_FLUSH(f->next);
+	 (*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	 dprint(9, (debugfile, "-- gf_reset rich2plain\n"));
+	 f->f1 = DFL;			/* state */
+	 f->f2 = 0;			/* set means we're in a comment */
+	 f->linep = f->line = (char *)fs_get(45 * sizeof(char));
+    }
+}
+
+
+/*
+ * function called from the outside to set
+ * richtext filter's options
+ */
+void *
+gf_rich2plain_opt(plain)
+    int plain;
+{
+    return((void *) plain);
+}
+
+
+
+/*
+ * ENRICHED-TO-PLAIN text filter
+ */
+
+#define	TEF_QUELL	0x01
+#define	TEF_NOFILL	0x02
+
+
+
+/*----------------------------------------------------------------------
+      enriched text to plain text filter (ala rfc1523)
+
+ Args: f -- state and input data
+	flg --
+
+  This basically removes all enriched formatting. A cute hack is used
+  to get bold and underlining to work.
+
+  Further work could be done to handle things like centering and right
+  and left flush, but then it could no longer be done in place. This
+  operates on text *with* CRLF's.
+
+  WARNING: does not wrap lines!
+ ----*/
+void
+gf_enriched2plain(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+/* BUG: qoute incoming \255 values */
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	 register unsigned char c;
+	 register int state = f->f1;
+
+	 while(GF_GETC(f, c)){
+
+	     switch(state){
+	       case TOKEN :		/* collect a richtext token */
+		 if(c == '>'){		/* what should we do with it? */
+		     int   off   = *f->line == '/';
+		     char *token = f->line + (off ? 1 : 0);
+		     state	= DFL;
+		     *f->linep   = '\0';
+		     if(!strcmp("param", token)){
+			 if(off)
+			   f->f2 &= ~TEF_QUELL;
+			 else
+			   f->f2 |= TEF_QUELL;
+		     }
+		     else if(!strcmp("nofill", token)){
+			 if(off)
+			   f->f2 &= ~TEF_NOFILL;
+			 else
+			   f->f2 |= TEF_NOFILL;
+		     }
+		     else if(!f->opt /* gf_enriched_plain */){
+			 /* Following is a cute hack or two to get
+			    bold and underline on the screen.
+			    See Putline0n() where these codes are
+			    interpreted */
+			 if(!strcmp("bold", token)) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, off ? TAG_BOLDOFF : TAG_BOLDON);
+			 } else if(!strcmp("italic", token)) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, off ? TAG_ULINEOFF : TAG_ULINEON);
+			 } else if(!strcmp("underline", token)) {
+			     GF_PUTC(f->next, TAG_EMBED);
+			     GF_PUTC(f->next, off ? TAG_ULINEOFF : TAG_ULINEON);
+			 }
+		     }
+		     /* else we just ignore the token! */
+
+		     f->linep = f->line;	/* reset token buffer */
+		 }
+		 else if(c == '<'){		/* literal '<'? */
+		     if(f->linep == f->line){
+			 GF_PUTC(f->next, '<');
+			 state = DFL;
+		     }
+		     else{
+			 fs_give((void **)&(f->line));
+			 gf_error("Malformed Enriched text: unexpected '<'");
+			 /* NO RETURN */
+		     }
+		 }
+		 else{			/* add char to token */
+		     if(f->linep - f->line > 60){ /* rfc1523 says 60 MAX! */
+			 fs_give((void **)&(f->line));
+			 gf_error("Malformed Enriched text: token too long");
+			 /* NO RETURN */
+		     }
+
+		     *(f->linep)++ = isupper((unsigned char)c) ? c-'A'+'a' : c;
+		 }
+		 break;
+
+	       case CCR   :
+		 if(c != '\012'){	/* treat as single space?    */
+		     state = DFL;	/* lone cr? */
+		     f->f2 &= ~TEF_QUELL;
+		     GF_PUTC(f->next, '\015');
+		     goto df;
+		 }
+
+		 state = CLF;
+		 break;
+
+	       case CLF   :
+		 if(c == '\015'){	/* treat as single space?    */
+		     state = CCR;	/* repeat crlf's mean real newlines */
+		     f->f2 |= TEF_QUELL;
+		     GF_PUTC(f->next, '\r');
+		     GF_PUTC(f->next, '\n');
+		     break;
+		 }
+		 else{
+		     state = DFL;
+		     if(!((f->f2) & TEF_QUELL))
+		       GF_PUTC(f->next, ' ');
+
+		     f->f2 &= ~TEF_QUELL;
+		 }
+
+		 /* fall thru to take care of 'c' */
+
+	       case DFL   :
+	       default :
+	       df :
+		 if(c == '<')
+		   state = TOKEN;
+		 else if(c == '\015' && (!((f->f2) & TEF_NOFILL)))
+		   state = CCR;
+		 else if(!((f->f2) & TEF_QUELL))
+		   GF_PUTC(f->next, c);
+
+		 break;
+	     }
+	 }
+
+	 f->f1 = state;
+	 GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	 if(f->f1 = (f->linep != f->line)){
+	     /* incomplete token!! */
+	     gf_error("Incomplete token in richtext");
+	     /* NO RETURN */
+	 }
+
+	 /* Make sure we end with a newline so everything gets flushed */
+	 GF_PUTC(f->next, '\015');
+	 GF_PUTC(f->next, '\012');
+
+	 fs_give((void **)&(f->line));
+
+	 GF_FLUSH(f->next);
+	 (*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	 dprint(9, (debugfile, "-- gf_reset enriched2plain\n"));
+	 f->f1 = DFL;			/* state */
+	 f->f2 = 0;			/* set means we're in a comment */
+	 f->linep = f->line = (char *)fs_get(65 * sizeof(char));
+    }
+}
+
+
+/*
+ * function called from the outside to set
+ * richtext filter's options
+ */
+void *
+gf_enriched2plain_opt(plain)
+    int plain;
+{
+    return((void *) plain);
+}
+
+
+
+/*
+ * HTML-TO-PLAIN text filter
+ */
+
+
+/* OK, here's the plan:
+
+ * a universal output function handles writing  chars and worries
+ *    about wrapping.
+
+ * a unversal element collector reads chars and collects params
+ * and dispatches the appropriate element handler.
+
+ * element handlers are stacked.  The most recently dispatched gets
+ * first crack at the incoming character stream.  It passes bytes it's
+ * done with or not interested in to the next
+
+ * installs that handler as the current one collecting data...
+
+ * stacked handlers take their params from the element collector and
+ * accept chars or do whatever they need to do.  Sort of a vertical
+ * piping? recursion-like? hmmm.
+
+ * at least I think this is how it'll work. tres simple, non?
+
+ */
+
+
+/*
+ * Some important constants
+ */
+#define	HTML_BUF_LEN	1024		/* max scratch buffer length */
+#define	MAX_ENTITY	20		/* maximum length of an entity */
+#define	MAX_ELEMENT	72		/* maximum length of an element */
+#define	HTML_BADVALUE	0x0100		/* good data, but bad entity value */
+#define	HTML_BADDATA	0x0200		/* bad data found looking for entity */
+#define	HTML_LITERAL	0x0400		/* Literal character value */
+#define	HTML_NEWLINE	0x010A		/* hard newline */
+#define	HTML_DOBOLD	0x0400		/* Start Bold display */
+#define	HTML_ID_GET	0		/* indent func: return current val */
+#define	HTML_ID_SET	1		/* indent func: set to absolute val */
+#define	HTML_ID_INC	2		/* indent func: increment by val */
+#define	HTML_HX_CENTER	0x0001
+#define	HTML_HX_ULINE	0x0002
+
+
+/*
+ * Types used to manage HTML parsing
+ */
+typedef int (*html_f) PROTO(());
+
+/*
+ * Handler data, state information including function that uses it
+ */
+typedef struct handler_s {
+    FILTER_S	     *html_data;
+    struct handler_s *below;
+    html_f	      f;
+    long	      x, y, z;
+    unsigned char    *s;
+} HANDLER_S;
+
+
+/*
+ * to help manage line wrapping.
+ */
+typedef	struct _wrap_line {
+    char *buf;				/* buf to collect wrapped text */
+    int	  used,				/* number of chars in buf */
+	   width,			/* text's width as displayed  */
+	   len;				/* length of allocated buf */
+} WRAPLINE_S;
+
+
+/*
+ * to help manage centered text
+ */
+typedef	struct _center_s {
+    WRAPLINE_S line;			/* buf to assembled centered text */
+    WRAPLINE_S word;			/* word being to append to Line */
+    int	       anchor;
+    short      embedded;
+    short      space;
+} CENTER_S;
+
+
+/*
+ * Collector data and state information
+ */
+typedef	struct collector_s {
+    char        buf[HTML_BUF_LEN];	/* buffer to collect data */
+    int		len;			/* length of that buffer  */
+    unsigned    end_tag:1;		/* collecting a closing tag */
+    unsigned    hit_equal:1;		/* collecting right half of attrib */
+    unsigned	mkup_decl:1;		/* markup declaration */
+    unsigned	start_comment:1;	/* markup declaration comment */
+    unsigned	end_comment:1;		/* legit comment format */
+    unsigned	hyphen:1;		/* markup hyphen read */
+    unsigned	badform:1;		/* malformed markup element */
+    unsigned	overrun:1;		/* Overran buf above */
+    char	quoted;			/* quoted element param value */
+    char       *element;		/* element's collected name */
+    PARAMETER  *attribs;		/* element's collected attributes */
+    PARAMETER  *cur_attrib;		/* attribute now being collected */
+} CLCTR_S;
+
+
+/*
+ * State information for all element handlers
+ */
+typedef struct html_data {
+    HANDLER_S  *h_stack;		/* handler list */
+    CLCTR_S    *el_data;		/* element collector data */
+    CENTER_S   *centered;		/* struct to manage centered text */
+    int	      (*token) PROTO((FILTER_S *, int));
+    char	quoted;			/* quoted, by either ' or ", text */
+    short	indent_level;		/* levels of indention */
+    int		in_anchor;		/* text now being written to anchor */
+    int		blanks;			/* Consecutive blank line count */
+    int		wrapcol;		/* column to wrap lines on */
+    int	       *prefix;			/* buffer containing Anchor prefix */
+    int		prefix_used;
+    COLOR_PAIR *color;
+    unsigned	wrapstate:1;		/* whether or not to wrap output */
+    unsigned	li_pending:1;		/* <LI> next token expected */
+    unsigned	de_pending:1;		/* <DT> or <DD> next token expected */
+    unsigned	bold_on:1;		/* currently bolding text */
+    unsigned	uline_on:1;		/* currently underlining text */
+    unsigned	center:1;		/* center output text */
+    unsigned	bitbucket:1;		/* Ignore input */
+    unsigned	head:1;			/* In doc's HEAD */
+    unsigned	alt_entity:1;		/* use alternative entity values */
+} HTML_DATA_S;
+
+
+/*
+ * HTML filter options
+ */
+typedef	struct _html_opts {
+    char      *base;			/* Base URL for this html file */
+    int	       columns;			/* Display columns */
+    unsigned   strip:1;			/* Hilite TAGs allowed */
+    unsigned   handles:1;		/* Anchors as handles requested? */
+    unsigned   handles_loc:1;		/* Local handles requested? */
+} HTML_OPT_S;
+
+
+/*
+ * Some macros to make life a little easier
+ */
+#define	WRAP_COLS(X)	((X)->opt ? ((HTML_OPT_S *)(X)->opt)->columns : 80)
+#define	HTML_BASE(X)	((X)->opt ? ((HTML_OPT_S *)(X)->opt)->base : NULL)
+#define	STRIP(X)	((X)->opt && ((HTML_OPT_S *)(X)->opt)->strip)
+#define	HANDLES(X)	((X)->opt && ((HTML_OPT_S *)(X)->opt)->handles)
+#define	HANDLES_LOC(X)	((X)->opt && ((HTML_OPT_S *)(X)->opt)->handles_loc)
+#define	MAKE_LITERAL(C)	(HTML_LITERAL | ((C) & 0xff))
+#define	IS_LITERAL(C)	(HTML_LITERAL & (C))
+#define	HD(X)		((HTML_DATA_S *)(X)->data)
+#define	ED(X)		(HD(X)->el_data)
+#define	HTML_ISSPACE(C)	(IS_LITERAL(C) == 0 && isspace((unsigned char) (C)))
+#define	NEW_CLCTR(X)	{						\
+			   ED(X) = (CLCTR_S *)fs_get(sizeof(CLCTR_S));  \
+			   memset(ED(X), 0, sizeof(CLCTR_S));	\
+			   HD(X)->token = html_element_collector;	\
+			 }
+
+#define	FREE_CLCTR(X)	{						\
+			   if(ED(X)->attribs){				\
+			       PARAMETER *p;				\
+			       while(p = ED(X)->attribs){		\
+				   ED(X)->attribs = ED(X)->attribs->next; \
+				   if(p->attribute)			\
+				     fs_give((void **)&p->attribute);	\
+				   if(p->value)				\
+				     fs_give((void **)&p->value);	\
+				   fs_give((void **)&p);		\
+			       }					\
+			   }						\
+			   if(ED(X)->element)				\
+			     fs_give((void **) &ED(X)->element);	\
+			   fs_give((void **) &ED(X));			\
+			   HD(X)->token = NULL;				\
+			 }
+#define	HANDLERS(X)	(HD(X)->h_stack)
+#define	BOLD_BIT(X)	(HD(X)->bold_on)
+#define	ULINE_BIT(X)	(HD(X)->uline_on)
+#define	CENTER_BIT(X)	(HD(X)->center)
+#define	HTML_FLUSH(X)	{						    \
+			   html_write(X, (X)->line, (X)->linep - (X)->line); \
+			   (X)->linep = (X)->line;			    \
+			   (X)->f2 = 0L;				    \
+			 }
+#define	HTML_BOLD(X, S) if(! STRIP(X)){					\
+			   if(S){					\
+			       html_output((X), TAG_EMBED);		\
+			       html_output((X), TAG_BOLDON);		\
+			   }						\
+			   else if(!(S)){				\
+			       html_output((X), TAG_EMBED);		\
+			       html_output((X), TAG_BOLDOFF);		\
+			   }						\
+			 }
+#define	HTML_ULINE(X, S)						\
+			 if(! STRIP(X)){				\
+			   if(S){					\
+			       html_output((X), TAG_EMBED);		\
+			       html_output((X), TAG_ULINEON);		\
+			   }						\
+			   else if(!(S)){				\
+			       html_output((X), TAG_EMBED);		\
+			       html_output((X), TAG_ULINEOFF);		\
+			   }						\
+			 }
+#define WRAPPED_LEN(X)	((HD(f)->centered) \
+			    ? (HD(f)->centered->line.width \
+				+ HD(f)->centered->word.width \
+				+ ((HD(f)->centered->line.width \
+				    && HD(f)->centered->word.width) \
+				    ? 1 : 0)) \
+			    : 0)
+#define	HTML_DUMP_LIT(F, S, L)	{					    \
+				   int i, c;				    \
+				   for(i = 0; i < (L); i++){		    \
+				       c = isspace((S)[i])		    \
+					     ? (S)[i]			    \
+					     : MAKE_LITERAL((S)[i]);	    \
+				       HTML_TEXT(F, c);			    \
+				   }					    \
+				 }
+#define	HTML_PROC(F, C) {						    \
+			   if(HD(F)->token){				    \
+			       int i;					    \
+			       if(i = (*(HD(F)->token))(F, C)){		    \
+				   if(i < 0){				    \
+				       HTML_DUMP_LIT(F, "<", 1);	    \
+				       if(HD(F)->el_data->element){	    \
+					   HTML_DUMP_LIT(F,		    \
+					    HD(F)->el_data->element,	    \
+					    strlen(HD(F)->el_data->element));\
+				       }				    \
+				       if(HD(F)->el_data->len){		    \
+					   HTML_DUMP_LIT(F,		    \
+						    HD(F)->el_data->buf,    \
+						    HD(F)->el_data->len);   \
+				       }				    \
+				       HTML_TEXT(F, C);			    \
+				   }					    \
+				   FREE_CLCTR(F);			    \
+			       }					    \
+			    }						    \
+			    else if((C) == '<'){			    \
+				NEW_CLCTR(F);				    \
+			    }						    \
+			    else					    \
+			      HTML_TEXT(F, C);				    \
+			  }
+#define	HTML_TEXT(F, C)	switch((F)->f1){				    \
+			     case WSPACE :				    \
+			       if(HTML_ISSPACE(C)) /* ignore repeated WS */  \
+				 break;					    \
+			       HTML_TEXT_OUT(F, ' ');	    \
+			       (F)->f1 = DFL;/* stop sending chars here */   \
+			       /* fall thru to process 'c' */		    \
+			     case DFL:					    \
+			       if(HD(F)->bitbucket)			    \
+				 (F)->f1 = DFL;	/* no op */		    \
+			       else if(HTML_ISSPACE(C) && HD(F)->wrapstate)  \
+				 (F)->f1 = WSPACE;/* coalesce white space */ \
+			       else HTML_TEXT_OUT(F, C);		    \
+			       break;					    \
+			 }
+#define	HTML_TEXT_OUT(F, C) if(HANDLERS(F)) /* let handlers see C */	    \
+			       (*HANDLERS(F)->f)(HANDLERS(F),(C),GF_DATA);   \
+			     else					    \
+			       html_output(F, C);
+#ifdef	DEBUG
+#define	HTML_DEBUG_EL(S, D)   {						    \
+				 dprint(2, (debugfile, "-- html %s: %s\n",  \
+					    S, (D)->element		    \
+						 ? (D)->element : "NULL")); \
+				 if(debug > 5){				    \
+				     PARAMETER *p;			    \
+				     for(p = (D)->attribs;		    \
+					 p && p->attribute;		    \
+					 p = p->next)			    \
+				       dprint(6, (debugfile,		    \
+						  " PARM: %s%s%s\n",	    \
+						  p->attribute		    \
+						    ? p->attribute : "NULL",\
+						  p->value ? "=" : "",	    \
+						  p->value ? p->value : ""));\
+				 }					    \
+			       }
+#else
+#define	HTML_DEBUG_EL(S, D)
+#endif
+
+
+/*
+ * Protos for Tag handlers
+ */
+int	html_head PROTO((HANDLER_S *, int, int));
+int	html_base PROTO((HANDLER_S *, int, int));
+int	html_title PROTO((HANDLER_S *, int, int));
+int	html_a PROTO((HANDLER_S *, int, int));
+int	html_br PROTO((HANDLER_S *, int, int));
+int	html_hr PROTO((HANDLER_S *, int, int));
+int	html_p PROTO((HANDLER_S *, int, int));
+int	html_tr PROTO((HANDLER_S *, int, int));
+int	html_td PROTO((HANDLER_S *, int, int));
+int	html_b PROTO((HANDLER_S *, int, int));
+int	html_i PROTO((HANDLER_S *, int, int));
+int	html_img PROTO((HANDLER_S *, int, int));
+int	html_form PROTO((HANDLER_S *, int, int));
+int	html_ul PROTO((HANDLER_S *, int, int));
+int	html_ol PROTO((HANDLER_S *, int, int));
+int	html_menu PROTO((HANDLER_S *, int, int));
+int	html_dir PROTO((HANDLER_S *, int, int));
+int	html_li PROTO((HANDLER_S *, int, int));
+int	html_h1 PROTO((HANDLER_S *, int, int));
+int	html_h2 PROTO((HANDLER_S *, int, int));
+int	html_h3 PROTO((HANDLER_S *, int, int));
+int	html_h4 PROTO((HANDLER_S *, int, int));
+int	html_h5 PROTO((HANDLER_S *, int, int));
+int	html_h6 PROTO((HANDLER_S *, int, int));
+int	html_blockquote PROTO((HANDLER_S *, int, int));
+int	html_address PROTO((HANDLER_S *, int, int));
+int	html_pre PROTO((HANDLER_S *, int, int));
+int	html_center PROTO((HANDLER_S *, int, int));
+int	html_div PROTO((HANDLER_S *, int, int));
+int	html_dl PROTO((HANDLER_S *, int, int));
+int	html_dt PROTO((HANDLER_S *, int, int));
+int	html_dd PROTO((HANDLER_S *, int, int));
+
+/*
+ * Proto's for support routines
+ */
+void	html_pop PROTO((FILTER_S *, html_f));
+void	html_push PROTO((FILTER_S *, html_f));
+int	html_element_collector PROTO((FILTER_S *, int));
+int	html_element_flush PROTO((CLCTR_S *));
+void	html_element_comment PROTO((FILTER_S *, char *));
+void	html_element_output PROTO((FILTER_S *, int));
+int	html_entity_collector PROTO((FILTER_S *, int, char **));
+void	html_a_prefix PROTO((FILTER_S *));
+void	html_a_finish PROTO((HANDLER_S *));
+void	html_a_output_prefix PROTO((FILTER_S *, int));
+void	html_a_relative PROTO((char *, char *, HANDLE_S *));
+int	html_indent PROTO((FILTER_S *, int, int));
+void	html_blank PROTO((FILTER_S *, int));
+void	html_newline PROTO((FILTER_S *));
+void	html_output PROTO((FILTER_S *, int));
+void	html_output_flush PROTO((FILTER_S *));
+void	html_output_centered PROTO((FILTER_S *, int));
+void	html_centered_handle PROTO((int *, char *, int));
+void	html_centered_putc PROTO((WRAPLINE_S *, int));
+void	html_centered_flush PROTO((FILTER_S *));
+void	html_centered_flush_line PROTO((FILTER_S *));
+void	html_write_anchor PROTO((FILTER_S *, int));
+void	html_write_newline PROTO((FILTER_S *));
+void	html_write_indent PROTO((FILTER_S *, int));
+void	html_write PROTO((FILTER_S *, char *, int));
+void	html_putc PROTO((FILTER_S *, int));
+
+
+/*
+ * Named entity table -- most from HTML 2.0 (rfc1866) plus some from
+ *			 W3C doc "Additional named entities for HTML"
+ */
+static struct html_entities {
+    char *name;			/* entity name */
+    unsigned char value;	/* entity value */
+    char  *plain;		/* plain text representation */
+} entity_tab[] = {
+    {"quot",	042},		/* Double quote sign */
+    {"amp",	046},		/* Ampersand */
+    {"bull",	052},		/* Bullet */
+    {"ndash",	055},		/* Dash */
+    {"mdash",	055},		/* Dash */
+    {"lt",	074},		/* Less than sign */
+    {"gt",	076},		/* Greater than sign */
+    {"nbsp",	0240, " "},	/* no-break space */
+    {"iexcl",	0241},		/* inverted exclamation mark */
+    {"cent",	0242},		/* cent sign */
+    {"pound",	0243},		/* pound sterling sign */
+    {"curren",	0244, "CUR"},	/* general currency sign */
+    {"yen",	0245},		/* yen sign */
+    {"brvbar",	0246, "|"},	/* broken (vertical) bar */
+    {"sect",	0247},		/* section sign */
+    {"uml",	0250, "\""},		/* umlaut (dieresis) */
+    {"copy",	0251, "(C)"},	/* copyright sign */
+    {"ordf",	0252, "a"},	/* ordinal indicator, feminine */
+    {"laquo",	0253, "<<"},	/* angle quotation mark, left */
+    {"not",	0254, "NOT"},	/* not sign */
+    {"shy",	0255, "-"},	/* soft hyphen */
+    {"reg",	0256, "(R)"},	/* registered sign */
+    {"macr",	0257},		/* macron */
+    {"deg",	0260, "DEG"},	/* degree sign */
+    {"plusmn",	0261, "+/-"},	/* plus-or-minus sign */
+    {"sup2",	0262},		/* superscript two */
+    {"sup3",	0263},		/* superscript three */
+    {"acute",	0264, "'"},	/* acute accent */
+    {"micro",	0265},		/* micro sign */
+    {"para",	0266},		/* pilcrow (paragraph sign) */
+    {"middot",	0267},		/* middle dot */
+    {"cedil",	0270},		/* cedilla */
+    {"sup1",	0271},		/* superscript one */
+    {"ordm",	0272, "o"},	/* ordinal indicator, masculine */
+    {"raquo",	0273, ">>"},	/* angle quotation mark, right */
+    {"frac14",	0274, " 1/4"},	/* fraction one-quarter */
+    {"frac12",	0275, " 1/2"},	/* fraction one-half */
+    {"frac34",	0276, " 3/4"},	/* fraction three-quarters */
+    {"iquest",	0277},		/* inverted question mark */
+    {"Agrave",	0300, "A"},	/* capital A, grave accent */
+    {"Aacute",	0301, "A"},	/* capital A, acute accent */
+    {"Acirc",	0302, "A"},	/* capital A, circumflex accent */
+    {"Atilde",	0303, "A"},	/* capital A, tilde */
+    {"Auml",	0304, "AE"},	/* capital A, dieresis or umlaut mark */
+    {"Aring",	0305, "A"},	/* capital A, ring */
+    {"AElig",	0306, "AE"},	/* capital AE diphthong (ligature) */
+    {"Ccedil",	0307, "C"},	/* capital C, cedilla */
+    {"Egrave",	0310, "E"},	/* capital E, grave accent */
+    {"Eacute",	0311, "E"},	/* capital E, acute accent */
+    {"Ecirc",	0312, "E"},	/* capital E, circumflex accent */
+    {"Euml",	0313, "E"},	/* capital E, dieresis or umlaut mark */
+    {"Igrave",	0314, "I"},	/* capital I, grave accent */
+    {"Iacute",	0315, "I"},	/* capital I, acute accent */
+    {"Icirc",	0316, "I"},	/* capital I, circumflex accent */
+    {"Iuml",	0317, "I"},	/* capital I, dieresis or umlaut mark */
+    {"ETH",	0320, "DH"},	/* capital Eth, Icelandic */
+    {"Ntilde",	0321, "N"},	/* capital N, tilde */
+    {"Ograve",	0322, "O"},	/* capital O, grave accent */
+    {"Oacute",	0323, "O"},	/* capital O, acute accent */
+    {"Ocirc",	0324, "O"},	/* capital O, circumflex accent */
+    {"Otilde",	0325, "O"},	/* capital O, tilde */
+    {"Ouml",	0326, "OE"},	/* capital O, dieresis or umlaut mark */
+    {"times",	0327, "x"},	/* multiply sign */
+    {"Oslash",	0330, "O"},	/* capital O, slash */
+    {"Ugrave",	0331, "U"},	/* capital U, grave accent */
+    {"Uacute",	0332, "U"},	/* capital U, acute accent */
+    {"Ucirc",	0333, "U"},	/* capital U, circumflex accent */
+    {"Uuml",	0334, "UE"},	/* capital U, dieresis or umlaut mark */
+    {"Yacute",	0335, "Y"},	/* capital Y, acute accent */
+    {"THORN",	0336, "P"},	/* capital THORN, Icelandic */
+    {"szlig",	0337, "ss"},	/* small sharp s, German (sz ligature) */
+    {"agrave",	0340, "a"},	/* small a, grave accent */
+    {"aacute",	0341, "a"},	/* small a, acute accent */
+    {"acirc",	0342, "a"},	/* small a, circumflex accent */
+    {"atilde",	0343, "a"},	/* small a, tilde */
+    {"auml",	0344, "ae"},	/* small a, dieresis or umlaut mark */
+    {"aring",	0345, "a"},	/* small a, ring */
+    {"aelig",	0346, "ae"},	/* small ae diphthong (ligature) */
+    {"ccedil",	0347, "c"},	/* small c, cedilla */
+    {"egrave",	0350, "e"},	/* small e, grave accent */
+    {"eacute",	0351, "e"},	/* small e, acute accent */
+    {"ecirc",	0352, "e"},	/* small e, circumflex accent */
+    {"euml",	0353, "e"},	/* small e, dieresis or umlaut mark */
+    {"igrave",	0354, "i"},	/* small i, grave accent */
+    {"iacute",	0355, "i"},	/* small i, acute accent */
+    {"icirc",	0356, "i"},	/* small i, circumflex accent */
+    {"iuml",	0357, "i"},	/* small i, dieresis or umlaut mark */
+    {"eth",	0360, "dh"},	/* small eth, Icelandic */
+    {"ntilde",	0361, "n"},	/* small n, tilde */
+    {"ograve",	0362, "o"},	/* small o, grave accent */
+    {"oacute",	0363, "o"},	/* small o, acute accent */
+    {"ocirc",	0364, "o"},	/* small o, circumflex accent */
+    {"otilde",	0365, "o"},	/* small o, tilde */
+    {"ouml",	0366, "oe"},	/* small o, dieresis or umlaut mark */
+    {"divide",	0367, "/"},	/* divide sign */
+    {"oslash",	0370, "o"},	/* small o, slash */
+    {"ugrave",	0371, "u"},	/* small u, grave accent */
+    {"uacute",	0372, "u"},	/* small u, acute accent */
+    {"ucirc",	0373, "u"},	/* small u, circumflex accent */
+    {"uuml",	0374, "ue"},	/* small u, dieresis or umlaut mark */
+    {"yacute",	0375, "y"},	/* small y, acute accent */
+    {"thorn",	0376, "p"},	/* small thorn, Icelandic */
+    {"yuml",	0377, "y"},	/* small y, dieresis or umlaut mark */
+    {NULL,	0}
+};
+
+
+/*
+ * Table of supported elements and corresponding handlers
+ */
+static struct element_table {
+    char      *element;
+    int	     (*handler) PROTO(());
+} element_table[] = {
+    {"HTML",		NULL},			/* HTML ignore if seen? */
+    {"HEAD",		html_head},		/* slurp until <BODY> ? */
+    {"TITLE",		html_title},		/* Document Title */
+    {"BASE",		html_base},		/* HREF base */
+    {"BODY",		NULL},			/* (NO OP) */
+    {"A",		html_a},		/* Anchor */
+    {"IMG",		html_img},		/* Image */
+    {"HR",		html_hr},		/* Horizontal Rule */
+    {"BR",		html_br},		/* Line Break */
+    {"P",		html_p},		/* Paragraph */
+    {"OL",		html_ol},		/* Ordered List */
+    {"UL",		html_ul},		/* Unordered List */
+    {"MENU",		html_menu},		/* Menu List */
+    {"DIR",		html_dir},		/* Directory List */
+    {"LI",		html_li},		/*  ... List Item */
+    {"DL",		html_dl},		/* Definition List */
+    {"DT",		html_dt},		/*  ... Def. Term */
+    {"DD",		html_dd},		/*  ... Def. Definition */
+    {"I",		html_i},		/* Italic Text */
+    {"EM",		html_i},		/* Typographic Emphasis */
+    {"STRONG",		html_i},		/* STRONG Typo Emphasis */
+    {"VAR",		html_i},		/* Variable Name */
+    {"B",		html_b},		/* Bold Text */
+    {"BLOCKQUOTE", 	html_blockquote}, 	/* Blockquote */
+    {"ADDRESS",		html_address},		/* Address */
+    {"CENTER",		html_center},		/* Centered Text v3.2 */
+    {"DIV",		html_div},		/* Document Division 3.2 */
+    {"H1",		html_h1},		/* Headings... */
+    {"H2",		html_h2},
+    {"H3",		html_h3},
+    {"H4",		html_h4},
+    {"H5",		html_h5},
+    {"H6",		html_h6},
+    {"PRE",		html_pre},		/* Preformatted Text */
+    {"KBD",		NULL},			/* Keyboard Input (NO OP) */
+    {"TT",		NULL},			/* Typetype (NO OP) */
+    {"SAMP",		NULL},			/* Sample Text (NO OP) */
+
+/*----- Handlers below are NOT DONE OR CHECKED OUT YET -----*/
+
+    {"CITE",		NULL},			/* Citation */
+    {"CODE",		NULL},			/* Code Text */
+
+/*----- Handlers below UNIMPLEMENTED (and won't until later) -----*/
+
+    {"FORM",		html_form},		/* form within a document */
+    {"INPUT",		NULL},			/* One input field, options */
+    {"OPTION",		NULL},			/* One option within Select */
+    {"SELECT",		NULL},			/* Selection from a set */
+    {"TEXTAREA",	NULL},			/* A multi-line input field */
+
+/*----- Handlers below provide limited support for RFC 1942 Tables -----*/
+
+    {"CAPTION",	html_center},		/* Table Caption */
+    {"TR",		html_tr},		/* Table Table Row */
+    {"TD",		html_td},		/* Table Table Data */
+
+    {NULL,		NULL}
+};
+
+
+
+/*
+ * Initialize the given handler, and add it to the stack if it
+ * requests it.
+ */
+void
+html_push(fd, hf)
+    FILTER_S *fd;
+    html_f    hf;
+{
+    HANDLER_S *new;
+
+    new = (HANDLER_S *)fs_get(sizeof(HANDLER_S));
+    memset(new, 0, sizeof(HANDLER_S));
+    new->html_data = fd;
+    new->f	   = hf;
+    if((*hf)(new, 0, GF_RESET)){	/* stack the handler? */
+	 new->below   = HANDLERS(fd);
+	 HANDLERS(fd) = new;		/* push */
+    }
+    else
+      fs_give((void **) &new);
+}
+
+
+/*
+ * Remove the most recently installed the given handler
+ * after letting it accept its demise.
+ */
+void
+html_pop(fd, hf)
+    FILTER_S *fd;
+    html_f    hf;
+{
+    HANDLER_S *tp;
+
+    for(tp = HANDLERS(fd); tp && hf != tp->f; tp = tp->below)
+      ;
+
+    if(tp){
+	(*tp->f)(tp, 0, GF_EOD);	/* may adjust handler list */
+	if(tp != HANDLERS(fd)){
+	    HANDLER_S *p;
+
+	    for(p = HANDLERS(fd); p->below != tp; p = p->below)
+	      ;
+
+	    if(p)
+	      p->below = tp->below;	/* remove from middle of stack */
+	    /* BUG: else programming botch and we should die */
+	}
+	else
+	  HANDLERS(fd) = tp->below;	/* pop */
+
+	fs_give((void **)&tp);
+    }
+    else if(hf == html_p || hf == html_li || hf == html_dt || hf == html_dd){
+	/*
+	 * Possible "special case" tag handling here.
+	 * It's for such tags as Paragraph (`</P>'), List Item
+	 * (`</LI>'), Definition Term (`</DT>'), and Definition Description
+	 * (`</DD>') elements, which may be omitted...
+	 */
+	HANDLER_S hd;
+
+	memset(&hd, 0, sizeof(HANDLER_S));
+	hd.html_data = fd;
+	hd.f	     = hf;
+
+	(*hf)(&hd, 0, GF_EOD);
+    }
+    /* BUG: else, we should bitch */
+}
+
+
+/*
+ * Deal with data passed a hander in its GF_DATA state
+ */
+html_handoff(hd, ch)
+    HANDLER_S *hd;
+    int	       ch;
+{
+    if(hd->below)
+      (*hd->below->f)(hd->below, ch, GF_DATA);
+    else
+      html_output(hd->html_data, ch);
+}
+
+
+/*
+ * HTML <BR> element handler
+ */
+int
+html_br(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET)
+      html_output(hd->html_data, HTML_NEWLINE);
+
+    return(0);				/* don't get linked */
+}
+
+
+/*
+ * HTML <HR> (Horizontal Rule) element handler
+ */
+int
+html_hr(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	int	   i, old_wrap, width, align;
+	PARAMETER *p;
+
+	width = WRAP_COLS(hd->html_data);
+	align = 0;
+	for(p = HD(hd->html_data)->el_data->attribs;
+	    p && p->attribute;
+	    p = p->next)
+	  if(p->value){
+	      if(!strucmp(p->attribute, "ALIGN")){
+		  if(!strucmp(p->value, "LEFT"))
+		    align = 1;
+		  else if(!strucmp(p->value, "RIGHT"))
+		    align = 2;
+	      }
+	      else if(!strucmp(p->attribute, "WIDTH")){
+		  char *cp;
+
+		  width = 0;
+		  for(cp = p->value; *cp; cp++)
+		    if(*cp == '%'){
+			width = (WRAP_COLS(hd->html_data)*min(100,width))/100;
+			break;
+		    }
+		    else if(isdigit((unsigned char) *cp))
+		      width = (width * 10) + (*cp - '0');
+
+		  width = min(width, WRAP_COLS(hd->html_data));
+	      }
+	  }
+
+	html_blank(hd->html_data, 1);	/* at least one blank line */
+
+	old_wrap = HD(hd->html_data)->wrapstate;
+	HD(hd->html_data)->wrapstate = 0;
+	if((i = max(0, WRAP_COLS(hd->html_data) - width))
+	   && ((align == 0) ? i /= 2 : (align == 2)))
+	  for(; i > 0; i--)
+	    html_output(hd->html_data, ' ');
+
+	for(i = 0; i < width; i++)
+	  html_output(hd->html_data, '_');
+
+	html_blank(hd->html_data, 1);
+	HD(hd->html_data)->wrapstate = old_wrap;
+    }
+
+    return(0);				/* don't get linked */
+}
+
+
+/*
+ * HTML <P> (paragraph) element handler
+ */
+int
+html_p(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	/* Make sure there's at least 1 blank line */
+	html_blank(hd->html_data, 1);
+
+	/* adjust indent level if needed */
+	if(HD(hd->html_data)->li_pending){
+	    html_indent(hd->html_data, 4, HTML_ID_INC);
+	    HD(hd->html_data)->li_pending = 0;
+	}
+    }
+    else if(cmd == GF_EOD)
+      /* Make sure there's at least 1 blank line */
+      html_blank(hd->html_data, 1);
+
+    return(0);				/* don't get linked */
+}
+
+
+/*
+ * HTML Table <TR> (paragraph) table row
+ */
+int
+html_tr(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET || cmd == GF_EOD)
+      /* Make sure there's at least 1 blank line */
+      html_blank(hd->html_data, 0);
+
+    return(0);				/* don't get linked */
+}
+
+
+/*
+ * HTML Table <TD> (paragraph) table data
+ */
+int
+html_td(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	PARAMETER *p;
+
+	for(p = HD(hd->html_data)->el_data->attribs;
+	    p && p->attribute;
+	    p = p->next)
+	  if(!strucmp(p->attribute, "nowrap")
+	     && (hd->html_data->f2 || hd->html_data->n)){
+	      HTML_DUMP_LIT(hd->html_data, " | ", 3);
+	      break;
+	  }
+    }
+
+    return(0);				/* don't get linked */
+}
+
+
+/*
+ * HTML <I> (italic text) element handler
+ */
+int
+html_i(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	/* include LITERAL in spaceness test! */
+	if(hd->x && !isspace((unsigned char) (ch & 0xff))){
+	    HTML_ULINE(hd->html_data, 1);
+	    hd->x = 0;
+	}
+
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	hd->x = 1;
+    }
+    else if(cmd == GF_EOD){
+	if(!hd->x)
+	  HTML_ULINE(hd->html_data, 0);
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <b> (Bold text) element handler
+ */
+int
+html_b(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	/* include LITERAL in spaceness test! */
+	if(hd->x && !isspace((unsigned char) (ch & 0xff))){
+	    HTML_ULINE(hd->html_data, 1);
+	    hd->x = 0;
+	}
+
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	hd->x = 1;
+    }
+    else if(cmd == GF_EOD){
+	if(!hd->x)
+	  HTML_ULINE(hd->html_data, 0);
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <IMG> element handler
+ */
+int
+html_img(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	PARAMETER *p;
+	char	  *s = NULL;
+
+	for(p = HD(hd->html_data)->el_data->attribs;
+	    p && p->attribute;
+	    p = p->next)
+	  if(!strucmp(p->attribute, "alt")){
+	      if(p->value && p->value[0]){
+		  HTML_DUMP_LIT(hd->html_data, p->value, strlen(p->value));
+		  HTML_TEXT(hd->html_data, ' ');
+	      }
+
+	      return(0);
+	  }
+
+	for(p = HD(hd->html_data)->el_data->attribs;
+	    p && p->attribute;
+	    p = p->next)
+	  if(!strucmp(p->attribute, "src") && p->value)
+	    if((s = strrindex(p->value, '/')) && *++s != '\0'){
+		HTML_TEXT(hd->html_data, '[');
+		HTML_DUMP_LIT(hd->html_data, s, strlen(s));
+		HTML_TEXT(hd->html_data, ']');
+		HTML_TEXT(hd->html_data, ' ');
+		return(0);
+	    }
+
+	HTML_DUMP_LIT(hd->html_data, "[IMAGE] ", 7);
+    }
+
+    return(0);				/* don't get linked */
+}
+
+
+/*
+ * HTML <FORM> (Form) element handler
+ */
+int
+html_form(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	char *p;
+
+	html_blank(hd->html_data, 0);
+
+	HTML_DUMP_LIT(hd->html_data, "[FORM]", 6);
+
+	html_blank(hd->html_data, 0);
+    }
+
+    return(0);				/* don't get linked */
+}
+
+
+/*
+ * HTML <HEAD> element handler
+ */
+int
+html_head(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	HD(hd->html_data)->head = 1;
+    }
+    else if(cmd == GF_EOD){
+	HD(hd->html_data)->head = 0;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <BASE> element handler
+ */
+int
+html_base(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	if(HD(hd->html_data)->head && !HTML_BASE(hd->html_data)){
+	    PARAMETER *p;
+
+	    for(p = HD(hd->html_data)->el_data->attribs;
+		p && p->attribute && strucmp(p->attribute, "HREF");
+		p = p->next)
+	      ;
+
+	    if(p && p->value && !((HTML_OPT_S *)(hd->html_data)->opt)->base)
+	      ((HTML_OPT_S *)(hd->html_data)->opt)->base = cpystr(p->value);
+	}
+    }
+
+    return(0);				/* DON'T get linked */
+}
+
+
+/*
+ * HTML <TITLE> element handler
+ */
+int
+html_title(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	if(hd->x + 1 >= hd->y){
+	    hd->y += 80;
+	    fs_resize((void **)&hd->s, (size_t)hd->y * sizeof(unsigned char));
+	}
+
+	hd->s[hd->x++] = (unsigned char) ch;
+    }
+    else if(cmd == GF_RESET){
+	hd->x = 0L;
+	hd->y = 80L;
+	hd->s = (unsigned char *)fs_get((size_t)hd->y * sizeof(unsigned char));
+    }
+    else if(cmd == GF_EOD){
+	/* Down the road we probably want to give these bytes to
+	 * someone...
+	 */
+	hd->s[hd->x] = '\0';
+	fs_give((void **)&hd->s);
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <A> (Anchor) element handler
+ */
+int
+html_a(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	int	   i, n, x;
+	char	   buf[256];
+	HANDLE_S  *h;
+	PARAMETER *p, *href = NULL, *name = NULL;
+
+	/*
+	 * Pending Anchor!?!?
+	 * space insertion/line breaking that's yet to get done...
+	 */
+	if(HD(hd->html_data)->prefix){
+	    dprint(1, (debugfile, "-- html_a: NESTED/UNTERMINATED ANCHOR!\n"));
+	    html_a_finish(hd);
+	}
+
+	/*
+	 * Look for valid Anchor data vis the filter installer's parms
+	 * (e.g., Only allow references to our internal URLs if asked)
+	 */
+	for(p = HD(hd->html_data)->el_data->attribs;
+	    p && p->attribute;
+	    p = p->next)
+	  if(!strucmp(p->attribute, "HREF")
+	     && p->value
+	     && (HANDLES_LOC(hd->html_data)
+		 || struncmp(p->value, "x-pine-", 7)))
+	    href = p;
+	  else if(!strucmp(p->attribute, "NAME"))
+	    name = p;
+
+	if(HANDLES(hd->html_data) && (href || name)){
+	    h = new_handle();
+
+	    /*
+	     * Enhancement: we might want to get fancier and parse the
+	     * href a bit further such that we can launch images using
+	     * our image viewer, or browse local files or directories
+	     * with our internal tools.  Of course, having the jump-off
+	     * point into text/html always be the defined "web-browser",
+	     * just might be the least confusing UI-wise...
+	     */
+	    h->type = URL;
+
+	    if(name && name->value)
+	      h->h.url.name = cpystr(name->value);
+
+	    /*
+	     * Prepare to build embedded prefix...
+	     */
+	    HD(hd->html_data)->prefix = (int *) fs_get(64 * sizeof(int));
+	    x = 0;
+
+	    /*
+	     * Is this something that looks like a URL?  If not and
+	     * we were giving some "base" string, proceed ala RFC1808...
+	     */
+	    if(href){
+		if(HTML_BASE(hd->html_data) && !rfc1738_scan(href->value, &n))
+		  html_a_relative(HTML_BASE(hd->html_data), href->value, h);
+		else
+		  h->h.url.path = cpystr(href->value);
+
+		if(pico_usingcolor()){
+		    char *fg = NULL, *bg = NULL, *q;
+
+		    if(ps_global->VAR_SLCTBL_FORE_COLOR
+		       && colorcmp(ps_global->VAR_SLCTBL_FORE_COLOR,
+				   ps_global->VAR_NORM_FORE_COLOR))
+		      fg = ps_global->VAR_SLCTBL_FORE_COLOR;
+
+		    if(ps_global->VAR_SLCTBL_BACK_COLOR
+		       && colorcmp(ps_global->VAR_SLCTBL_BACK_COLOR,
+				   ps_global->VAR_NORM_BACK_COLOR))
+		      bg = ps_global->VAR_SLCTBL_BACK_COLOR;
+
+		    if(fg || bg){
+			COLOR_PAIR *tmp;
+
+			/*
+			 * The blacks are just known good colors for testing
+			 * whether the other color is good.
+			 */
+			tmp = new_color_pair(fg ? fg : colorx(COL_BLACK),
+					     bg ? bg : colorx(COL_BLACK));
+			if(pico_is_good_colorpair(tmp)){
+			    q = color_embed(fg, bg);
+
+			    for(i = 0; q[i]; i++)
+			      HD(hd->html_data)->prefix[x++] = q[i];
+			}
+
+			if(tmp)
+			  free_color_pair(&tmp);
+		    }
+
+		    if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global))
+		      HD(hd->html_data)->prefix[x++] = HTML_DOBOLD;
+		}
+		else
+		  HD(hd->html_data)->prefix[x++] = HTML_DOBOLD;
+	    }
+
+	    HD(hd->html_data)->prefix[x++] = TAG_EMBED;
+	    HD(hd->html_data)->prefix[x++] = TAG_HANDLE;
+
+	    sprintf(buf, "%d", h->key);
+	    HD(hd->html_data)->prefix[x++] = n = strlen(buf);
+	    for(i = 0; i < n; i++)
+	      HD(hd->html_data)->prefix[x++] = buf[i];
+
+	    HD(hd->html_data)->prefix_used = x;
+	}
+    }
+    else if(cmd == GF_EOD){
+	html_a_finish(hd);
+    }
+
+    return(1);				/* get linked */
+}
+
+
+void
+html_a_prefix(f)
+    FILTER_S *f;
+{
+    int *prefix, n;
+
+    /* Do this so we don't visit from html_output... */
+    prefix = HD(f)->prefix;
+    HD(f)->prefix = NULL;
+
+    for(n = 0; n < HD(f)->prefix_used; n++)
+      html_a_output_prefix(f, prefix[n]);
+
+    fs_give((void **) &prefix);
+}
+
+
+/*
+ * html_a_finish - house keeping associated with end of link tag
+ */
+void
+html_a_finish(hd)
+    HANDLER_S *hd;
+{
+    if(HANDLES(hd->html_data)){
+	if(HD(hd->html_data)->prefix)
+	  html_a_prefix(hd->html_data);
+
+	if(pico_usingcolor()){
+	    char *fg = NULL, *bg = NULL, *p;
+	    int   i;
+
+	    if(ps_global->VAR_SLCTBL_FORE_COLOR
+	       && colorcmp(ps_global->VAR_SLCTBL_FORE_COLOR,
+			   ps_global->VAR_NORM_FORE_COLOR))
+	      fg = ps_global->VAR_NORM_FORE_COLOR;
+
+	    if(ps_global->VAR_SLCTBL_BACK_COLOR
+	       && colorcmp(ps_global->VAR_SLCTBL_BACK_COLOR,
+			   ps_global->VAR_NORM_BACK_COLOR))
+	      bg = ps_global->VAR_NORM_BACK_COLOR;
+
+	    if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global))
+	      HTML_BOLD(hd->html_data, 0);	/* turn OFF bold */
+
+	    if(fg || bg){
+		COLOR_PAIR *tmp;
+
+		/*
+		 * The blacks are just known good colors for testing
+		 * whether the other color is good.
+		 */
+		tmp = new_color_pair(fg ? fg : colorx(COL_BLACK),
+				     bg ? bg : colorx(COL_BLACK));
+		if(pico_is_good_colorpair(tmp)){
+		    p = color_embed(fg, bg);
+
+		    for(i = 0; p[i]; i++)
+		      html_output(hd->html_data, p[i]);
+		}
+
+		if(tmp)
+		  free_color_pair(&tmp);
+	    }
+	}
+	else
+	  HTML_BOLD(hd->html_data, 0);	/* turn OFF bold */
+
+	html_output(hd->html_data, TAG_EMBED);
+	html_output(hd->html_data, TAG_HANDLEOFF);
+    }
+}
+
+
+/*
+ * html_output_a_prefix - dump Anchor prefix data
+ */
+void
+html_a_output_prefix(f, c)
+    FILTER_S *f;
+    int	      c;
+{
+    switch(c){
+      case HTML_DOBOLD :
+	HTML_BOLD(f, 1);
+	break;
+
+      default :
+	html_output(f, c);
+	break;
+    }
+}
+
+
+
+/*
+ * relative_url - put full url path in h based on base and relative url
+ */
+void
+html_a_relative(base_url, rel_url, h)
+    char     *base_url, *rel_url;
+    HANDLE_S *h;
+{
+    size_t  len;
+    char    tmp[MAILTMPLEN], *p, *q;
+    char   *scheme = NULL, *net = NULL, *path = NULL,
+	   *parms = NULL, *query = NULL, *frag = NULL,
+	   *base_scheme = NULL, *base_net_loc = NULL,
+	   *base_path = NULL, *base_parms = NULL,
+	   *base_query = NULL, *base_frag = NULL,
+	   *rel_scheme = NULL, *rel_net_loc = NULL,
+	   *rel_path = NULL, *rel_parms = NULL,
+	   *rel_query = NULL, *rel_frag = NULL;
+
+    /* Rough parse of base URL */
+    rfc1808_tokens(base_url, &base_scheme, &base_net_loc, &base_path,
+		   &base_parms, &base_query, &base_frag);
+
+    /* Rough parse of this URL */
+    rfc1808_tokens(rel_url, &rel_scheme, &rel_net_loc, &rel_path,
+		   &rel_parms, &rel_query, &rel_frag);
+
+    scheme = rel_scheme;	/* defaults */
+    net    = rel_net_loc;
+    path   = rel_path;
+    parms  = rel_parms;
+    query  = rel_query;
+    frag   = rel_frag;
+    if(!scheme && base_scheme){
+	scheme = base_scheme;
+	if(!net){
+	    net = base_net_loc;
+	    if(path){
+		if(*path != '/'){
+		    if(base_path){
+			for(p = q = base_path;	/* Drop base path's tail */
+			    p = strchr(p, '/');
+			    q = ++p)
+			  ;
+
+			len = q - base_path;
+		    }
+		    else
+		      len = 0;
+
+		    if(len + strlen(rel_path) < MAILTMPLEN - 1){
+			if(len)
+			  sprintf(path = tmp, "%.*s", len, base_path);
+
+			strcpy(tmp + len, rel_path);
+
+			/* Follow RFC 1808 "Step 6" */
+			for(p = tmp; p = strchr(p, '.'); )
+			  switch(*(p+1)){
+			      /*
+			       * a) All occurrences of "./", where "." is a
+			       *    complete path segment, are removed.
+			       */
+			    case '/' :
+			      if(p > tmp)
+				for(q = p; *q = *(q+2); q++)
+				  ;
+			      else
+				p++;
+
+			      break;
+
+			      /*
+			       * b) If the path ends with "." as a
+			       *    complete path segment, that "." is
+			       *    removed.
+			       */
+			    case '\0' :
+			      if(p == tmp || *(p-1) == '/')
+				*p = '\0';
+			      else
+				p++;
+
+			      break;
+
+			      /*
+			       * c) All occurrences of "<segment>/../",
+			       *    where <segment> is a complete path
+			       *    segment not equal to "..", are removed.
+			       *    Removal of these path segments is
+			       *    performed iteratively, removing the
+			       *    leftmost matching pattern on each
+			       *    iteration, until no matching pattern
+			       *    remains.
+			       *
+			       * d) If the path ends with "<segment>/..",
+			       *    where <segment> is a complete path
+			       *    segment not equal to "..", that
+			       *    "<segment>/.." is removed.
+			       */
+			    case '.' :
+			      if(p > tmp + 1){
+				  for(q = p - 2; q > tmp && *q != '/'; q--)
+				    ;
+
+				  if(*q == '/')
+				    q++;
+
+				  if(q + 1 == p		/* no "//.." */
+				     || (*q == '.'	/* and "../.." */
+					 && *(q+1) == '.'
+					 && *(q+2) == '/')){
+				      p += 2;
+				      break;
+				  }
+
+				  switch(*(p+2)){
+				    case '/' :
+				      len = (p - q) + 3;
+				      p = q;
+				      for(; *q = *(q+len); q++)
+					;
+
+				      break;
+
+				    case '\0':
+				      *(p = q) = '\0';
+				      break;
+
+				    default:
+				      p += 2;
+				      break;
+				  }
+			      }
+			      else
+				p += 2;
+
+			      break;
+
+			    default :
+			      p++;
+			      break;
+			  }
+		    }
+		    else
+		      path = "";		/* lame. */
+		}
+	    }
+	    else{
+		path = base_path;
+		if(!parms){
+		    parms = base_parms;
+		    if(!query)
+		      query = base_query;
+		}
+	    }
+	}
+    }
+
+    len = (scheme ? strlen(scheme) : 0) + (net ? strlen(net) : 0)
+	  + (path ? strlen(path) : 0) + (parms ? strlen(parms) : 0)
+	  + (query ? strlen(query) : 0) + (frag  ? strlen(frag ) : 0) + 8;
+
+    h->h.url.path = (char *) fs_get(len * sizeof(char));
+    sprintf(h->h.url.path, "%s%s%s%s%s%s%s%s%s%s%s%s",
+	    scheme ? scheme : "", scheme ? ":" : "",
+	    net ? "//" : "", net ? net : "",
+	    (path && *path == '/') ? "" : ((path && net) ? "/" : ""),
+	    path ? path : "",
+	    parms ? ";" : "", parms ? parms : "",
+	    query ? "?" : "", query ? query : "",
+	    frag ? "#" : "", frag ? frag : "");
+
+    if(base_scheme)
+      fs_give((void **) &base_scheme);
+
+    if(base_net_loc)
+      fs_give((void **) &base_net_loc);
+
+    if(base_path)
+      fs_give((void **) &base_path);
+
+    if(base_parms)
+      fs_give((void **) &base_parms);
+
+    if(base_query)
+      fs_give((void **) &base_query);
+
+    if(base_frag)
+      fs_give((void **) &base_frag);
+
+    if(rel_scheme)
+      fs_give((void **) &rel_scheme);
+
+    if(rel_net_loc)
+      fs_give((void **) &rel_net_loc);
+
+    if(rel_parms)
+      fs_give((void **) &rel_parms);
+
+    if(rel_query)
+      fs_give((void **) &rel_query);
+
+    if(rel_frag)
+      fs_give((void **) &rel_frag);
+
+    if(rel_path)
+      fs_give((void **) &rel_path);
+}
+
+
+/*
+ * HTML <UL> (Unordered List) element handler
+ */
+int
+html_ul(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	HD(hd->html_data)->li_pending = 1;
+	html_blank(hd->html_data, 0);
+    }
+    else if(cmd == GF_EOD){
+	html_blank(hd->html_data, 0);
+
+	if(!HD(hd->html_data)->li_pending)
+	  html_indent(hd->html_data, -4, HTML_ID_INC);
+	else
+	  HD(hd->html_data)->li_pending = 0;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <OL> (Ordered List) element handler
+ */
+int
+html_ol(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * Signal that we're expecting to see <LI> as our next elemnt
+	 * and set the the initial ordered count.
+	 */
+	HD(hd->html_data)->li_pending = 1;
+	hd->x = 1L;
+	html_blank(hd->html_data, 0);
+    }
+    else if(cmd == GF_EOD){
+	html_blank(hd->html_data, 0);
+
+	if(!HD(hd->html_data)->li_pending)
+	  html_indent(hd->html_data, -4, HTML_ID_INC);
+	else
+	  HD(hd->html_data)->li_pending = 0;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <MENU> (Menu List) element handler
+ */
+int
+html_menu(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	HD(hd->html_data)->li_pending = 1;
+    }
+    else if(cmd == GF_EOD){
+	html_blank(hd->html_data, 0);
+
+	if(!HD(hd->html_data)->li_pending)
+	  html_indent(hd->html_data, -4, HTML_ID_INC);
+	else
+	  HD(hd->html_data)->li_pending = 0;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <DIR> (Directory List) element handler
+ */
+int
+html_dir(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	HD(hd->html_data)->li_pending = 1;
+    }
+    else if(cmd == GF_EOD){
+	html_blank(hd->html_data, 0);
+
+	if(!HD(hd->html_data)->li_pending)
+	  html_indent(hd->html_data, -4, HTML_ID_INC);
+	else
+	  HD(hd->html_data)->li_pending = 0;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <LI> (List Item) element handler
+ */
+int
+html_li(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	HANDLER_S *p, *found = NULL;
+
+	/*
+	 * There better be a an unordered list, ordered list,
+	 * Menu or Directory handler installed
+	 * or else we crap out...
+	 */
+	for(p = HANDLERS(hd->html_data); p; p = p->below)
+	  if(p->f == html_ul || p->f == html_ol
+	     || p->f == html_menu || p->f == html_dir){
+	      found = p;
+	      break;
+	  }
+
+	if(found){
+	    char buf[8], *p;
+	    int  wrapstate;
+
+	    /* Start a new line */
+	    html_blank(hd->html_data, 0);
+
+	    /* adjust indent level if needed */
+	    if(HD(hd->html_data)->li_pending){
+		html_indent(hd->html_data, 4, HTML_ID_INC);
+		HD(hd->html_data)->li_pending = 0;
+	    }
+
+	    if(found->f == html_ul){
+		int l = html_indent(hd->html_data, 0, HTML_ID_GET);
+
+		strcpy(buf, "   ");
+		buf[1] = (l < 5) ? '*' : (l < 9) ? '+' : (l < 17) ? 'o' : '#';
+	    }
+	    else if(found->f == html_ol)
+	      sprintf(buf, "%2ld.", found->x++);
+	    else if(found->f == html_menu)
+	      strcpy(buf, " ->");
+
+	    html_indent(hd->html_data, -4, HTML_ID_INC);
+
+	    /* So we don't munge whitespace */
+	    wrapstate = HD(hd->html_data)->wrapstate;
+	    HD(hd->html_data)->wrapstate = 0;
+
+	    html_write_indent(hd->html_data, HD(hd->html_data)->indent_level);
+	    for(p = buf; *p; p++)
+	      html_output(hd->html_data, (int) *p);
+
+	    HD(hd->html_data)->wrapstate = wrapstate;
+	    html_indent(hd->html_data, 4, HTML_ID_INC);
+	}
+	/* BUG: should really bitch about this */
+    }
+
+    return(0);				/* DON'T get linked */
+}
+
+
+
+/*
+ * HTML <DL> (Definition List) element handler
+ */
+int
+html_dl(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * Set indention level for definition terms and definitions...
+	 */
+	hd->x = html_indent(hd->html_data, 0, HTML_ID_GET);
+	hd->y = hd->x + 2;
+	hd->z = hd->y + 4;
+    }
+    else if(cmd == GF_EOD){
+	html_indent(hd->html_data, (int) hd->x, HTML_ID_SET);
+	html_blank(hd->html_data, 1);
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <DT> (Definition Term) element handler
+ */
+int
+html_dt(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	HANDLER_S *p;
+
+	/*
+	 * There better be a Definition Handler installed
+	 * or else we crap out...
+	 */
+	for(p = HANDLERS(hd->html_data); p && p->f != html_dl; p = p->below)
+	  ;
+
+	if(p){				/* adjust indent level if needed */
+	    html_indent(hd->html_data, (int) p->y, HTML_ID_SET);
+	    html_blank(hd->html_data, 1);
+	}
+	/* BUG: else should really bitch about this */
+    }
+
+    return(0);				/* DON'T get linked */
+}
+
+
+/*
+ * HTML <DD> (Definition Definition) element handler
+ */
+int
+html_dd(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_RESET){
+	HANDLER_S *p;
+
+	/*
+	 * There better be a Definition Handler installed
+	 * or else we crap out...
+	 */
+	for(p = HANDLERS(hd->html_data); p && p->f != html_dl; p = p->below)
+	  ;
+
+	if(p){				/* adjust indent level if needed */
+	    html_indent(hd->html_data, (int) p->z, HTML_ID_SET);
+	    html_blank(hd->html_data, 0);
+	}
+	/* BUG: should really bitch about this */
+    }
+
+    return(0);				/* DON'T get linked */
+}
+
+
+/*
+ * HTML <H1> (Headings 1) element handler.
+ *
+ * Bold, very-large font, CENTERED. One or two blank lines
+ * above and below.  For our silly character cell's that
+ * means centered and ALL CAPS...
+ */
+int
+html_h1(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/* turn ON the centered bit */
+	CENTER_BIT(hd->html_data) = 1;
+    }
+    else if(cmd == GF_EOD){
+	/* turn OFF the centered bit, add blank line */
+	CENTER_BIT(hd->html_data) = 0;
+	html_blank(hd->html_data, 1);
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <H2> (Headings 2) element handler
+ */
+int
+html_h2(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	if((hd->x & HTML_HX_ULINE) && !isspace((unsigned char) (ch & 0xff))){
+	    HTML_ULINE(hd->html_data, 1);
+	    hd->x ^= HTML_HX_ULINE;	/* only once! */
+	}
+
+	html_handoff(hd, (ch < 128 && islower((unsigned char) ch))
+			   ? toupper((unsigned char) ch) : ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * Bold, large font, flush-left. One or two blank lines
+	 * above and below.
+	 */
+	if(CENTER_BIT(hd->html_data)) /* stop centering for now */
+	  hd->x = HTML_HX_CENTER;
+	else
+	  hd->x = 0;
+
+	hd->x |= HTML_HX_ULINE;
+	    
+	CENTER_BIT(hd->html_data) = 0;
+	hd->y = html_indent(hd->html_data, 0, HTML_ID_SET);
+	hd->z = HD(hd->html_data)->wrapcol;
+	HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+	html_blank(hd->html_data, 1);
+    }
+    else if(cmd == GF_EOD){
+	/*
+	 * restore previous centering, and indent level
+	 */
+	if(!(hd->x & HTML_HX_ULINE))
+	  HTML_ULINE(hd->html_data, 0);
+
+	html_indent(hd->html_data, hd->y, HTML_ID_SET);
+	html_blank(hd->html_data, 1);
+	CENTER_BIT(hd->html_data)  = (hd->x & HTML_HX_CENTER) != 0;
+	HD(hd->html_data)->wrapcol = hd->z;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <H3> (Headings 3) element handler
+ */
+int
+html_h3(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	if((hd->x & HTML_HX_ULINE) && !isspace((unsigned char) (ch & 0xff))){
+	    HTML_ULINE(hd->html_data, 1);
+	    hd->x ^= HTML_HX_ULINE;	/* only once! */
+	}
+
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * Italic, large font, slightly indented from the left
+	 * margin. One or two blank lines above and below.
+	 */
+	if(CENTER_BIT(hd->html_data)) /* stop centering for now */
+	  hd->x = HTML_HX_CENTER;
+	else
+	  hd->x = 0;
+
+	hd->x |= HTML_HX_ULINE;
+	CENTER_BIT(hd->html_data) = 0;
+	hd->y = html_indent(hd->html_data, 2, HTML_ID_SET);
+	hd->z = HD(hd->html_data)->wrapcol;
+	HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+	html_blank(hd->html_data, 1);
+    }
+    else if(cmd == GF_EOD){
+	/*
+	 * restore previous centering, and indent level
+	 */
+	if(!(hd->x & HTML_HX_ULINE))
+	  HTML_ULINE(hd->html_data, 0);
+
+	html_indent(hd->html_data, hd->y, HTML_ID_SET);
+	html_blank(hd->html_data, 1);
+	CENTER_BIT(hd->html_data)  = (hd->x & HTML_HX_CENTER) != 0;
+	HD(hd->html_data)->wrapcol = hd->z;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <H4> (Headings 4) element handler
+ */
+int
+html_h4(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * Bold, normal font, indented more than H3. One blank line
+	 * above and below.
+	 */
+	hd->x = CENTER_BIT(hd->html_data); /* stop centering for now */
+	CENTER_BIT(hd->html_data) = 0;
+	hd->y = html_indent(hd->html_data, 4, HTML_ID_SET);
+	hd->z = HD(hd->html_data)->wrapcol;
+	HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+	html_blank(hd->html_data, 1);
+    }
+    else if(cmd == GF_EOD){
+	/*
+	 * restore previous centering, and indent level
+	 */
+	html_indent(hd->html_data, (int) hd->y, HTML_ID_SET);
+	html_blank(hd->html_data, 1);
+	CENTER_BIT(hd->html_data)  = hd->x;
+	HD(hd->html_data)->wrapcol = hd->z;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <H5> (Headings 5) element handler
+ */
+int
+html_h5(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * Italic, normal font, indented as H4. One blank line
+	 * above.
+	 */
+	hd->x = CENTER_BIT(hd->html_data); /* stop centering for now */
+	CENTER_BIT(hd->html_data) = 0;
+	hd->y = html_indent(hd->html_data, 6, HTML_ID_SET);
+	hd->z = HD(hd->html_data)->wrapcol;
+	HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+	html_blank(hd->html_data, 1);
+    }
+    else if(cmd == GF_EOD){
+	/*
+	 * restore previous centering, and indent level
+	 */
+	html_indent(hd->html_data, (int) hd->y, HTML_ID_SET);
+	html_blank(hd->html_data, 1);
+	CENTER_BIT(hd->html_data)  = hd->x;
+	HD(hd->html_data)->wrapcol = hd->z;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <H6> (Headings 6) element handler
+ */
+int
+html_h6(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * Bold, indented same as normal text, more than H5. One
+	 * blank line above.
+	 */
+	hd->x = CENTER_BIT(hd->html_data); /* stop centering for now */
+	CENTER_BIT(hd->html_data) = 0;
+	hd->y = html_indent(hd->html_data, 8, HTML_ID_SET);
+	hd->z = HD(hd->html_data)->wrapcol;
+	HD(hd->html_data)->wrapcol = WRAP_COLS(hd->html_data) - 8;
+	html_blank(hd->html_data, 1);
+    }
+    else if(cmd == GF_EOD){
+	/*
+	 * restore previous centering, and indent level
+	 */
+	html_indent(hd->html_data, (int) hd->y, HTML_ID_SET);
+	html_blank(hd->html_data, 1);
+	CENTER_BIT(hd->html_data)  = hd->x;
+	HD(hd->html_data)->wrapcol = hd->z;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <BlockQuote> element handler
+ */
+int
+html_blockquote(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    int	 j;
+#define	HTML_BQ_INDENT	6
+
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * A typical rendering might be a slight extra left and
+	 * right indent, and/or italic font. The Blockquote element
+	 * causes a paragraph break, and typically provides space
+	 * above and below the quote.
+	 */
+	html_indent(hd->html_data, HTML_BQ_INDENT, HTML_ID_INC);
+	j = HD(hd->html_data)->wrapstate;
+	HD(hd->html_data)->wrapstate = 0;
+	html_blank(hd->html_data, 1);
+	HD(hd->html_data)->wrapstate = j;
+	HD(hd->html_data)->wrapcol  -= HTML_BQ_INDENT;
+    }
+    else if(cmd == GF_EOD){
+	html_blank(hd->html_data, 1);
+
+	j = HD(hd->html_data)->wrapstate;
+	HD(hd->html_data)->wrapstate = 0;
+	html_indent(hd->html_data, -(HTML_BQ_INDENT), HTML_ID_INC);
+	HD(hd->html_data)->wrapstate = j;
+	HD(hd->html_data)->wrapcol  += HTML_BQ_INDENT;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <Address> element handler
+ */
+int
+html_address(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    int	 j;
+#define	HTML_ADD_INDENT	2
+
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/*
+	 * A typical rendering might be a slight extra left and
+	 * right indent, and/or italic font. The Blockquote element
+	 * causes a paragraph break, and typically provides space
+	 * above and below the quote.
+	 */
+	html_indent(hd->html_data, HTML_ADD_INDENT, HTML_ID_INC);
+	j = HD(hd->html_data)->wrapstate;
+	HD(hd->html_data)->wrapstate = 0;
+	html_blank(hd->html_data, 1);
+	HD(hd->html_data)->wrapstate = j;
+    }
+    else if(cmd == GF_EOD){
+	html_blank(hd->html_data, 1);
+
+	j = HD(hd->html_data)->wrapstate;
+	HD(hd->html_data)->wrapstate = 0;
+	html_indent(hd->html_data, -(HTML_ADD_INDENT), HTML_ID_INC);
+	HD(hd->html_data)->wrapstate = j;
+    }
+
+    return(1);				/* get linked */
+}
+
+
+/*
+ * HTML <PRE> (Preformatted Text) element handler
+ */
+int
+html_pre(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	/*
+	 * remove CRLF after '>' in element.
+	 * We see CRLF because wrapstate is off.
+	 */
+	switch(hd->y){
+	  case 2 :
+	    if(ch == '\012'){
+		hd->y = 3;
+		return(1);
+	    }
+	    else
+	      html_handoff(hd, '\015');
+
+	    break;
+
+	  case 1 :
+	    if(ch == '\015'){
+		hd->y = 2;
+		return(1);
+	    }
+
+	  default :
+	    hd->y = 0;
+	    break;
+	}
+
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	html_blank(hd->html_data, 1);
+	hd->x = HD(hd->html_data)->wrapstate;
+	HD(hd->html_data)->wrapstate = 0;
+	hd->y = 1;
+    }
+    else if(cmd == GF_EOD){
+	HD(hd->html_data)->wrapstate = (hd->x != 0);
+	html_blank(hd->html_data, 0);
+    }
+
+    return(1);
+}
+
+
+
+
+/*
+ * HTML <CENTER> (Centerd Text) element handler
+ */
+int
+html_center(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	/* turn ON the centered bit */
+	CENTER_BIT(hd->html_data) = 1;
+    }
+    else if(cmd == GF_EOD){
+	/* turn OFF the centered bit */
+	CENTER_BIT(hd->html_data) = 0;
+    }
+
+    return(1);
+}
+
+
+
+/*
+ * HTML <DIV> (Document Divisions) element handler
+ */
+int
+html_div(hd, ch, cmd)
+    HANDLER_S *hd;
+    int	       ch, cmd;
+{
+    if(cmd == GF_DATA){
+	html_handoff(hd, ch);
+    }
+    else if(cmd == GF_RESET){
+	PARAMETER *p;
+
+	for(p = HD(hd->html_data)->el_data->attribs;
+	    p && p->attribute;
+	    p = p->next)
+	  if(!strucmp(p->attribute, "ALIGN")){
+	      if(p->value){
+		  /* remember previous values */
+		  hd->x = CENTER_BIT(hd->html_data);
+		  hd->y = html_indent(hd->html_data, 0, HTML_ID_GET);
+
+		  html_blank(hd->html_data, 0);
+		  CENTER_BIT(hd->html_data) = !strucmp(p->value, "CENTER");
+		  html_indent(hd->html_data, 0, HTML_ID_SET);
+		  /* NOTE: "RIGHT" not supported yet */
+	      }
+	  }
+    }
+    else if(cmd == GF_EOD){
+	/* restore centered bit and indentiousness */
+	CENTER_BIT(hd->html_data) = hd->y;
+	html_indent(hd->html_data, hd->y, HTML_ID_SET);
+	html_blank(hd->html_data, 0);
+    }
+
+    return(1);
+}
+
+
+
+/*
+ * return the function associated with the given element name
+ */
+html_f
+html_element_func(el_name)
+    char *el_name;
+{
+    register int i;
+
+    for(i = 0; element_table[i].element; i++)
+      if(!strucmp(el_name, element_table[i].element))
+	return(element_table[i].handler);
+
+    return(NULL);
+}
+
+
+/*
+ * collect element's name and any attribute/value pairs then
+ * dispatch to the appropriate handler.
+ *
+ * Returns 1 : got what we wanted
+ *	   0 : we need more data
+ *	  -1 : bogus input
+ */
+int
+html_element_collector(fd, ch)
+    FILTER_S *fd;
+    int	      ch;
+{
+    if(ch == '>'){
+	if(ED(fd)->overrun){
+	    /*
+	     * If problem processing, don't bother doing anything
+	     * internally, just return such that none of what we've
+	     * digested is displayed.
+	     */
+	    HTML_DEBUG_EL("too long", ED(fd));
+	    return(1);			/* Let it go, Jim */
+	}
+	else if(ED(fd)->mkup_decl){
+	    if(ED(fd)->badform){
+		dprint(2, (debugfile, "-- html <!-- BAD: %.*s\n",
+			   ED(fd)->len, ED(fd)->buf));
+		/*
+		 * Invalid comment -- make some guesses as
+		 * to whether we should stop with this greater-than...
+		 */
+		if(ED(fd)->buf[0] != '-'
+		   || ED(fd)->len < 4
+		   || (ED(fd)->buf[1] == '-'
+		       && ED(fd)->buf[ED(fd)->len - 1] == '-'
+		       && ED(fd)->buf[ED(fd)->len - 2] == '-'))
+		  return(1);
+	    }
+	    else{
+		dprint(2, (debugfile, "-- html <!-- OK: %.*s\n",
+			   ED(fd)->len, ED(fd)->buf));
+		if(ED(fd)->start_comment == ED(fd)->end_comment){
+		    if(ED(fd)->len > 10){
+			ED(fd)->buf[ED(fd)->len - 2] = '\0';
+			html_element_comment(fd, ED(fd)->buf + 2);
+		    }
+
+		    return(1);
+		}
+		/* else keep collecting comment below */
+	    }
+	}
+	else if(!ED(fd)->quoted || ED(fd)->badform){
+	    html_f f;
+
+	    /*
+	     * We either have the whole thing or all that we could
+	     * salvage from it.  Try our best...
+	     */
+
+	    if(HD(fd)->bitbucket)
+	      return(1);		/* element inside chtml clause! */
+
+	    if(!ED(fd)->badform && html_element_flush(ED(fd)))
+	      return(1);		/* return without display... */
+
+	    /*
+	     * If we ran into an empty tag or we don't know how to deal
+	     * with it, just go on, ignoring it...
+	     */
+	    if(ED(fd)->element && (f = html_element_func(ED(fd)->element))){
+		/* dispatch the element's handler */
+		if(ED(fd)->end_tag)
+		  html_pop(fd, f);	/* remove it's handler */
+		else
+		  html_push(fd, f);	/* add it's handler */
+
+		HTML_DEBUG_EL(ED(fd)->end_tag ? "POP" : "PUSH", ED(fd));
+	    }
+	    else{			/* else, empty or unrecognized */
+		HTML_DEBUG_EL("?", ED(fd));
+	    }
+
+	    return(1);			/* all done! see, that didn't hurt */
+	}
+    }
+
+    if(ED(fd)->mkup_decl){
+	if((ch &= 0xff) == '-'){
+	    if(ED(fd)->hyphen){
+		ED(fd)->hyphen = 0;
+		if(ED(fd)->start_comment)
+		  ED(fd)->end_comment = 1;
+		else
+		  ED(fd)->start_comment = 1;
+	    }
+	    else
+	      ED(fd)->hyphen = 1;
+	}
+	else{
+	    if(ED(fd)->end_comment)
+	      ED(fd)->start_comment = ED(fd)->end_comment = 0;
+
+	    /*
+	     * no "--" after ! or non-whitespace between comments - bad
+	     */
+	    if(ED(fd)->len < 2 || (!ED(fd)->start_comment
+				   && !isspace((unsigned char) ch)))
+	      ED(fd)->badform = 1;	/* non-comment! */
+
+	    ED(fd)->hyphen = 0;
+	}
+
+	/*
+	 * Remember the comment for possible later processing, if
+	 * it get's too long, remember first and last few chars
+	 * so we know when to terminate (and throw some garbage
+	 * in between when we toss out what's between.
+	 */
+	if(ED(fd)->len == HTML_BUF_LEN){
+	    ED(fd)->buf[2] = ED(fd)->buf[3] = 'X';
+	    ED(fd)->buf[4] = ED(fd)->buf[ED(fd)->len - 2];
+	    ED(fd)->buf[5] = ED(fd)->buf[ED(fd)->len - 1];
+	    ED(fd)->len    = 6;
+	}
+
+	ED(fd)->buf[(ED(fd)->len)++] = ch;
+	return(0);			/* comments go in the bit bucket */
+    }
+    else if(ED(fd)->overrun || ED(fd)->badform){
+	return(0);			/* swallow char's until next '>' */
+    }
+    else if(!ED(fd)->element && !ED(fd)->len){
+	if(ch == '/'){		/* validate leading chars */
+	    ED(fd)->end_tag = 1;
+	    return(0);
+	}
+	else if(ch == '!'){
+	    ED(fd)->mkup_decl = 1;
+	    return(0);
+	}
+	else if(!isalpha((unsigned char) ch))
+	  return(-1);			/* can't be a tag! */
+    }
+    else if(ch == '\"' || ch == '\''){
+	if(!ED(fd)->hit_equal){
+	    ED(fd)->badform = 1;	/* quote in element name?!? */
+	    return(0);
+	}
+
+	if(ED(fd)->quoted){
+	    if(ED(fd)->quoted == (char) ch){
+		ED(fd)->quoted = 0;
+		return(0);		/* continue collecting chars */
+	    }
+	    /* else fall thru writing other quoting char */
+	}
+	else{
+	    ED(fd)->quoted = (char) ch;
+	    return(0);			/* need more data */
+	}
+    }
+
+    ch &= 0xff;			/* strip any "literal" high bits */
+    if(ED(fd)->quoted
+       || isalnum(ch)
+       || strchr("-.!", ch)
+       || (ED(fd)->hit_equal && !isspace((unsigned char) ch))){
+	if(ED(fd)->len < ((ED(fd)->element || !ED(fd)->hit_equal)
+			       ? HTML_BUF_LEN:MAX_ELEMENT)){
+	    ED(fd)->buf[(ED(fd)->len)++] = ch;
+	}
+	else
+	  ED(fd)->overrun = 1;		/* flag it broken */
+    }
+    else if(isspace((unsigned char) ch) || ch == '='){
+	if(html_element_flush(ED(fd))){
+	    ED(fd)->badform = 1;
+	    return(0);		/* else, we ain't done yet */
+	}
+
+	if(!ED(fd)->hit_equal)
+	  ED(fd)->hit_equal = (ch == '=');
+    }
+    else
+      ED(fd)->badform = 1;		/* unrecognized data?? */
+
+    return(0);				/* keep collecting */
+}
+
+
+/*
+ * Element collector found complete string, integrate it and reset
+ * internal collection buffer.
+ *
+ * Returns zero if element collection buffer flushed, error flag otherwise
+ */
+int
+html_element_flush(el_data)
+    CLCTR_S *el_data;
+{
+    int rv = 0;
+
+    if(el_data->hit_equal){		/* adding a value */
+	el_data->hit_equal = 0;
+	if(el_data->cur_attrib){
+	    if(!el_data->cur_attrib->value){
+		el_data->cur_attrib->value = cpystr(el_data->len
+						    ? el_data->buf : "");
+	    }
+	    else{
+		dprint(2, (debugfile,
+			   "** element: unexpected value: %.10s...\n",
+			   el_data->len ? el_data->buf : "\"\""));
+		rv = 1;
+	    }
+	}
+	else{
+	    dprint(2, (debugfile,
+		       "** element: missing attribute name: %.10s...\n",
+		       el_data->len ? el_data->buf : "\"\""));
+	    rv = 2;
+	}
+
+	el_data->len = 0;
+	memset(el_data->buf, 0, HTML_BUF_LEN);
+    }
+    else if(el_data->len){
+	if(!el_data->element){
+	    el_data->element = cpystr(el_data->buf);
+	}
+	else{
+	    PARAMETER *p = (PARAMETER *)fs_get(sizeof(PARAMETER));
+	    memset(p, 0, sizeof(PARAMETER));
+	    if(el_data->attribs){
+		el_data->cur_attrib->next = p;
+		el_data->cur_attrib = p;
+	    }
+	    else
+	      el_data->attribs = el_data->cur_attrib = p;
+
+	    p->attribute = cpystr(el_data->buf);
+	}
+
+	el_data->len = 0;
+	memset(el_data->buf, 0, HTML_BUF_LEN);
+    }
+
+    return(rv);			/* report whatever happened above */
+}
+
+
+/*
+ * html_element_comment - "Special" comment handling here
+ */
+void
+html_element_comment(f, s)
+    FILTER_S *f;
+    char     *s;
+{
+    char *p;
+
+    while(*s && isspace((unsigned char) *s))
+      s++;
+
+    /*
+     * WARNING: "!--chtml" denotes "Conditional HTML", a UW-ism.
+     */
+    if(!struncmp(s, "chtml ", 6)){
+	s += 6;
+	if(!struncmp(s, "if ", 3)){
+	    HD(f)->bitbucket = 1;	/* default is failure! */
+	    switch(*(s += 3)){
+	      case 'P' :
+	      case 'p' :
+		if(!struncmp(s + 1, "inemode=", 8)){
+		    if(!strucmp(s = removing_quotes(s + 9), "function_key")
+		       && F_ON(F_USE_FK, ps_global))
+		      HD(f)->bitbucket = 0;
+		    else if(!strucmp(s, "running"))
+		      HD(f)->bitbucket = 0;
+		    else if(!strucmp(s, "phone_home") && ps_global->phone_home)
+		      HD(f)->bitbucket = 0;
+#ifdef	_WINDOWS
+		    else if(!strucmp(s, "os_windows"))
+		      HD(f)->bitbucket = 0;
+#endif
+		}
+
+		break;
+
+	      case '[' :	/* test */
+		if(p = strindex(++s, ']')){
+		    *p = '\0';		/* tie off test string */
+		    removing_leading_white_space(s);
+		    removing_trailing_white_space(s);
+		    if(*s == '-' && *(s+1) == 'r'){ /* readable file? */
+			for(s += 2; *s && isspace((unsigned char) *s); s++)
+			  ;
+
+
+			HD(f)->bitbucket = (can_access(removing_quotes(s),
+						       READ_ACCESS) != 0);
+		    }
+		}
+
+		break;
+
+	      default :
+		break;
+	    }
+	}
+	else if(!strucmp(s, "else")){
+	    HD(f)->bitbucket = !HD(f)->bitbucket;
+	}
+	else if(!strucmp(s, "endif")){
+	    /* Clean up after chtml here */
+	    HD(f)->bitbucket = 0;
+	}
+    }
+    else if(!HD(f)->bitbucket){
+	if(!struncmp(s, "#include ", 9)){
+	    char  buf[MAILTMPLEN], *bufp;
+	    int   len, end_of_line;
+	    FILE *fp;
+
+	    /* Include the named file */
+	    if(!struncmp(s += 9, "file=", 5)
+	       && (fp = fopen(removing_quotes(s+5), "r"))){
+		html_element_output(f, HTML_NEWLINE);
+
+		while(fgets(buf, MAILTMPLEN, fp)){
+		    if((len = strlen(buf)) && buf[len-1] == '\n'){
+			end_of_line = 1;
+			buf[--len]  = '\0';
+		    }
+		    else
+		      end_of_line = 0;
+
+		    for(bufp = buf; len; bufp++, len--)
+		      html_element_output(f, (int) *bufp);
+
+		    if(end_of_line)
+		      html_element_output(f, HTML_NEWLINE);
+		}
+
+		fclose(fp);
+		html_element_output(f, HTML_NEWLINE);
+		HD(f)->blanks = 0;
+		if(f->f1 == WSPACE)
+		  f->f1 = DFL;
+	    }
+	}
+	else if(!struncmp(s, "#echo ", 6)){
+	    if(!struncmp(s += 6, "var=", 4)){
+		char	*p, buf[MAILTMPLEN];
+		ADDRESS *adr;
+		extern char datestamp[];
+
+		if(!strcmp(s = removing_quotes(s + 4), "PINE_VERSION")){
+		    p = pine_version;
+		}
+		else if(!strcmp(s, "PINE_COMPILE_DATE")){
+		    p = datestamp;
+		}
+		else if(!strcmp(s, "PINE_TODAYS_DATE")){
+		    rfc822_date(p = buf);
+		}
+		else if(!strcmp(s, "_LOCAL_FULLNAME_")){
+		    p = (ps_global->VAR_LOCAL_FULLNAME
+			 && ps_global->VAR_LOCAL_FULLNAME[0])
+			    ? ps_global->VAR_LOCAL_FULLNAME
+			    : "Local Support";
+		}
+		else if(!strcmp(s, "_LOCAL_ADDRESS_")){
+		    p = (ps_global->VAR_LOCAL_ADDRESS
+			 && ps_global->VAR_LOCAL_ADDRESS[0])
+			   ? ps_global->VAR_LOCAL_ADDRESS
+			   : "postmaster";
+		    adr = rfc822_parse_mailbox(&p, ps_global->maildomain);
+		    sprintf(p = buf, "%s@%s", adr->mailbox, adr->host);
+		    mail_free_address(&adr);
+		}
+		else if(!strcmp(s, "_BUGS_FULLNAME_")){
+		    p = (ps_global->VAR_BUGS_FULLNAME
+			 && ps_global->VAR_BUGS_FULLNAME[0])
+			    ? ps_global->VAR_BUGS_FULLNAME
+			    : "Place to report Pine Bugs";
+		}
+		else if(!strcmp(s, "_BUGS_ADDRESS_")){
+		    p = (ps_global->VAR_BUGS_ADDRESS
+			 && ps_global->VAR_BUGS_ADDRESS[0])
+			    ? ps_global->VAR_BUGS_ADDRESS : "postmaster";
+		    adr = rfc822_parse_mailbox(&p, ps_global->maildomain);
+		    sprintf(p = buf, "%s@%s", adr->mailbox, adr->host);
+		    mail_free_address(&adr);
+		}
+		else if(!strcmp(s, "CURRENT_DIR")){
+		    getcwd(p = buf, MAILTMPLEN);
+		}
+		else if(!strcmp(s, "HOME_DIR")){
+		    p = ps_global->home_dir;
+		}
+		else
+		  p = NULL;
+
+		if(p){
+		    if(f->f1 == WSPACE){
+			html_element_output(f, ' ');
+			f->f1 = DFL;			/* clear it */
+		    }
+
+		    while(*p)
+		      html_element_output(f, (int) *p++);
+		}
+	    }
+	}
+    }
+}
+
+
+void
+html_element_output(f, ch)
+    FILTER_S *f;
+    int	      ch;
+{
+    if(HANDLERS(f))
+      (*HANDLERS(f)->f)(HANDLERS(f), ch, GF_DATA);
+    else
+      html_output(f, ch);
+}
+
+
+/*
+ * collect html entities and return its value when done.
+ *
+ * Returns 0		 : we need more data
+ *	   1-255	 : char value of entity collected
+ *	   HTML_BADVALUE : good data, but no named match or out of range
+ *	   HTML_BADDATA  : invalid input
+ *
+ * NOTES:
+ *  - entity format is "'&' tag ';'" and represents a literal char
+ *  - named entities are CASE SENSITIVE.
+ *  - numeric char references (where the tag is prefixed with a '#')
+ *    are a char with that numbers value
+ *  - numeric vals are 0-255 except for the ranges: 0-8, 11-31, 127-159.
+ */
+int
+html_entity_collector(f, ch, alternate)
+    FILTER_S  *f;
+    int	       ch;
+    char     **alternate;
+{
+    static char len = 0;
+    static char buf[MAX_ENTITY];
+    int rv = 0, i;
+
+    if((len == 0)
+	 ? (isalpha((unsigned char) ch) || ch == '#')
+	 : ((isdigit((unsigned char) ch)
+	     || (isalpha((unsigned char) ch) && buf[0] != '#'))
+	    && len < MAX_ENTITY - 1)){
+	buf[len++] = ch;
+    }
+    else if((isspace((unsigned char) ch) || ch == ';') && len){
+	buf[len] = '\0';		/* got something! */
+	switch(buf[0]){
+	  case '#' :
+	    rv = atoi(&buf[1]);
+	    if(F_ON(F_PASS_CONTROL_CHARS, ps_global)
+	       || (rv == '\t' || rv == '\n' || rv == '\r'
+		   || (rv > 31 && rv < 127) || (rv > 159 && rv < 256))){
+		if(alternate)
+		  for(i = 0, *alternate = NULL; entity_tab[i].name; i++)
+		    if(entity_tab[i].value == rv){
+			*alternate = entity_tab[i].plain;
+			break;
+		    }
+	    }
+	    else
+	      rv = HTML_BADVALUE;
+
+	    break;
+
+	  default :
+	    rv = HTML_BADVALUE;		/* in case we fail below */
+	    for(i = 0; entity_tab[i].name; i++)
+	      if(strcmp(entity_tab[i].name, buf) == 0){
+		  rv = entity_tab[i].value;
+		  if(alternate)
+		    *alternate = entity_tab[i].plain;
+
+		  break;
+	      }
+
+	    break;
+	}
+    }
+    else
+      rv = HTML_BADDATA;		/* bogus input! */
+
+    if(rv){				/* nonzero return, clean up */
+	if(rv > 0xff && alternate){	/* provide bogus data to caller */
+	    buf[len] = '\0';
+	    *alternate = buf;
+	}
+
+	len = 0;
+    }
+
+    return(rv);
+}
+
+
+/*----------------------------------------------------------------------
+  HTML text to plain text filter
+
+  This basically tries to do the best it can with HTML 2.0 (RFC1866)
+  with bits of RFC 1942 (plus some HTML 3.2 thrown in as well) text
+  formatting.
+
+ ----*/
+void
+gf_html2plain(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+/* BUG: qoute incoming \255 values (see "yuml" above!) */
+    if(flg == GF_DATA){
+	register int c;
+	GF_INIT(f, f->next);
+
+	while(GF_GETC(f, c)){
+	    /*
+	     * First we have to collect any literal entities...
+	     * that is, IF we're not already collecting one
+	     * AND we're not in element's text or, if we are, we're
+	     * not in quoted text.  Whew.
+	     */
+	    if(f->t){
+		int   i;
+		char *alt = NULL;
+
+		switch(i = html_entity_collector(f, c, &alt)){
+		  case 0:		/* more data required? */
+		    continue;		/* go get another char */
+
+		  case HTML_BADVALUE :
+		  case HTML_BADDATA :
+		    /* if supplied, process bogus data */
+		    HTML_PROC(f, '&');
+		    for(; *alt; alt++)
+		      HTML_PROC(f, *alt);
+
+		    if(c == '&' && !HD(f)->quoted){
+			f->t = '&';
+			continue;
+		    }
+		    else
+		      f->t = 0;		/* don't come back next time */
+
+		    break;
+
+		  default :		/* thing to process */
+		    f->t = 0;		/* don't come back */
+
+		    /*
+		     * Map some of the undisplayable entities?
+		     */
+		    if(HD(f)->alt_entity && i > 127 && alt && alt[0]){
+			for(; *alt; alt++){
+			    c = MAKE_LITERAL(*alt);
+			    HTML_PROC(f, c);
+			}
+
+			continue;
+		    }
+
+		    c = MAKE_LITERAL(i);
+		    break;
+		}
+	    }
+	    else if(c == '&' && !HD(f)->quoted){
+		f->t = '&';
+		continue;
+	    }
+
+	    /*
+	     * then we process whatever we got...
+	     */
+
+	    HTML_PROC(f, c);
+	}
+
+	GF_OP_END(f);			/* clean up our input pointers */
+    }
+    else if(flg == GF_EOD){
+	while(HANDLERS(f))
+	  /* BUG: should complain about "Unexpected end of HTML text." */
+	  html_pop(f, HANDLERS(f)->f);
+
+	html_output(f, HTML_NEWLINE);
+	HTML_FLUSH(f);
+	fs_give((void **)&f->line);
+	if(HD(f)->color)
+	  free_color_pair(&HD(f)->color);
+
+	fs_give(&f->data);
+	if(f->opt){
+	    if(((HTML_OPT_S *)f->opt)->base)
+	      fs_give((void **) &((HTML_OPT_S *)f->opt)->base);
+
+	    fs_give(&f->opt);
+	}
+
+	(*f->next->f)(f->next, GF_DATA);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset html2plain\n"));
+	f->data  = (HTML_DATA_S *) fs_get(sizeof(HTML_DATA_S));
+	memset(f->data, 0, sizeof(HTML_DATA_S));
+	HD(f)->wrapstate = 1;		/* start with flowing text */
+	HD(f)->wrapcol   = WRAP_COLS(f) - 8;
+	f->f1    = DFL;			/* state */
+	f->f2    = 0;			/* chars in wrap buffer */
+	f->n     = 0L;			/* chars on line so far */
+	f->linep = f->line = (char *)fs_get(HTML_BUF_LEN * sizeof(char));
+	HD(f)->alt_entity =  (!ps_global->VAR_CHAR_SET
+			      || strucmp(ps_global->VAR_CHAR_SET,
+					 "iso-8859-1"));
+    }
+}
+
+
+
+/*
+ * html_indent - do the requested indent level function with appropriate
+ *		 flushing and such.
+ *
+ *   Returns: indent level prior to set/increment
+ */
+int
+html_indent(f, val, func)
+    FILTER_S *f;
+    int	      val, func;
+{
+    int old = HD(f)->indent_level;
+
+    /* flush pending data at old indent level */
+    switch(func){
+      case HTML_ID_INC :
+	html_output_flush(f);
+	if((HD(f)->indent_level += val) < 0)
+	  HD(f)->indent_level = 0;
+
+	break;
+
+      case HTML_ID_SET :
+	html_output_flush(f);
+	HD(f)->indent_level = val;
+	break;
+
+      default :
+	break;
+    }
+
+    return(old);
+}
+
+
+
+/*
+ * html_blanks - Insert n blank lines into output
+ */
+void
+html_blank(f, n)
+    FILTER_S *f;
+    int	      n;
+{
+    /* Cap off any flowing text, and then write blank lines */
+    if(f->f2 || f->n || CENTER_BIT(f) || HD(f)->centered || WRAPPED_LEN(f))
+      html_output(f, HTML_NEWLINE);
+
+    if(HD(f)->wrapstate)
+      while(HD(f)->blanks < n)	/* blanks inc'd by HTML_NEWLINE */
+	html_output(f, HTML_NEWLINE);
+}
+
+
+
+/*
+ *  html_newline -- insert a newline mindful of embedded tags
+ */
+void
+html_newline(f)
+    FILTER_S *f;
+{
+    html_write_newline(f);		/* commit an actual newline */
+
+    if(f->n){				/* and keep track of blank lines */
+	HD(f)->blanks = 0;
+	f->n = 0L;
+    }
+    else
+      HD(f)->blanks++;
+}
+
+
+/*
+ * output the given char, handling any requested wrapping.
+ * It's understood that all whitespace handed us is written.  In other
+ * words, junk whitespace is weeded out before it's given to us here.
+ *
+ */
+void
+html_output(f, ch)
+    FILTER_S *f;
+    int	      ch;
+{
+    if(CENTER_BIT(f)){			/* center incoming text */
+	html_output_centered(f, ch);
+    }
+    else{
+	static short embedded = 0; /* BUG: reset on entering filter */
+	static char *color_ptr = NULL;
+
+	if(HD(f)->centered){
+	    html_centered_flush(f);
+	    fs_give((void **) &HD(f)->centered->line.buf);
+	    fs_give((void **) &HD(f)->centered->word.buf);
+	    fs_give((void **) &HD(f)->centered);
+	}
+
+	if(HD(f)->wrapstate){
+	    if(ch == HTML_NEWLINE){		/* hard newline */
+		html_output_flush(f);
+		html_newline(f);
+	    }
+	    else
+	      HD(f)->blanks = 0;		/* reset blank line counter */
+
+	    if(ch == TAG_EMBED){	/* takes up no space */
+		embedded = 1;
+		*(f->linep)++ = TAG_EMBED;
+	    }
+	    else if(embedded){	/* ditto */
+		if(ch == TAG_HANDLE)
+		  embedded = -1;	/* next ch is length */
+		else if(ch == TAG_FGCOLOR || ch == TAG_BGCOLOR){
+		    if(!HD(f)->color)
+		      HD(f)->color = new_color_pair(NULL, NULL);
+
+		    if(ch == TAG_FGCOLOR)
+		      color_ptr = HD(f)->color->fg;
+		    else
+		      color_ptr = HD(f)->color->bg;
+
+		    embedded = 11;
+		}
+		else if(embedded < 0){
+		    embedded = ch;	/* number of embedded chars */
+		}
+		else{
+		    embedded--;
+		    if(color_ptr)
+		      *color_ptr++ = ch;
+
+		    if(embedded == 0 && color_ptr){
+			*color_ptr = '\0';
+			color_ptr = NULL;
+		    }
+		}
+
+		*(f->linep)++ = ch;
+	    }
+	    else if(HTML_ISSPACE(ch)){
+		html_output_flush(f);
+	    }
+	    else{
+		if(HD(f)->prefix)
+		  html_a_prefix(f);
+
+		if(++f->f2 >= WRAP_COLS(f)){
+		    HTML_FLUSH(f);
+		    html_newline(f);
+		    if(HD(f)->in_anchor)
+		      html_write_anchor(f, HD(f)->in_anchor);
+		}
+		else
+		  *(f->linep)++ = ch & 0xff;
+	    }
+	}
+	else{
+	    if(HD(f)->prefix)
+	      html_a_prefix(f);
+
+	    html_output_flush(f);
+
+	    switch(embedded){
+	      case 0 :
+		switch(ch){
+		  default :
+		    f->n++;			/* inc displayed char count */
+		    HD(f)->blanks = 0;		/* reset blank line counter */
+		    html_putc(f, ch & 0xff);
+		    break;
+
+		  case TAG_EMBED :	/* takes up no space */
+		    html_putc(f, TAG_EMBED);
+		    embedded = -2;
+		    break;
+
+		  case HTML_NEWLINE :		/* newline handling */
+		    if(!f->n)
+		      break;
+
+		  case '\n' :
+		    html_newline(f);
+
+		  case '\r' :
+		    break;
+		}
+
+		break;
+
+	      case -2 :
+		embedded = 0;
+		switch(ch){
+		  case TAG_HANDLE :
+		    embedded = -1;	/* next ch is length */
+		    break;
+
+		  case TAG_BOLDON :
+		    BOLD_BIT(f) = 1;
+		    break;
+
+		  case TAG_BOLDOFF :
+		    BOLD_BIT(f) = 0;
+		    break;
+
+		  case TAG_ULINEON :
+		    ULINE_BIT(f) = 1;
+		    break;
+
+		  case TAG_ULINEOFF :
+		    ULINE_BIT(f) = 0;
+		    break;
+
+		  case TAG_FGCOLOR :
+		    if(!HD(f)->color)
+		      HD(f)->color = new_color_pair(NULL, NULL);
+
+		    color_ptr = HD(f)->color->fg;
+		    embedded = 11;
+		    break;
+
+		  case TAG_BGCOLOR :
+		    if(!HD(f)->color)
+		      HD(f)->color = new_color_pair(NULL, NULL);
+
+		    color_ptr = HD(f)->color->bg;
+		    embedded = 11;
+		    break;
+
+		  case TAG_HANDLEOFF :
+		    ch = TAG_INVOFF;
+		    HD(f)->in_anchor = 0;
+		    break;
+
+		  default :
+		    break;
+		}
+
+		html_putc(f, ch);
+		break;
+
+	      case -1 :
+		embedded = ch;	/* number of embedded chars */
+		html_putc(f, ch);
+		break;
+
+	      default :
+		embedded--;
+		if(color_ptr)
+		  *color_ptr++ = ch;
+
+		if(embedded == 0 && color_ptr){
+		    *color_ptr = '\0';
+		    color_ptr = NULL;
+		}
+
+		html_putc(f, ch);
+		break;
+	    }
+	}
+    }
+}
+
+
+/*
+ * flush any buffered chars waiting for wrapping.
+ */
+void
+html_output_flush(f)
+    FILTER_S *f;
+{
+    if(f->f2){
+	if(f->n && ((int) f->n) + f->f2 > HD(f)->wrapcol)
+	  html_newline(f);		/* wrap? */
+
+	if(f->n){			/* text already on the line? */
+	    html_putc(f, ' ');
+	    f->n++;			/* increment count */
+	}
+	else{
+	    /* write at start of new line */
+	    html_write_indent(f, HD(f)->indent_level);
+
+	    if(HD(f)->in_anchor)
+	      html_write_anchor(f, HD(f)->in_anchor);
+	}
+
+	f->n += f->f2;
+	HTML_FLUSH(f);
+    }
+}
+
+
+
+/*
+ * html_output_centered - managed writing centered text
+ */
+void
+html_output_centered(f, ch)
+    FILTER_S *f;
+    int	      ch;
+{
+    if(!HD(f)->centered){		/* new text? */
+	html_output_flush(f);
+	if(f->n)			/* start on blank line */
+	  html_newline(f);
+
+	HD(f)->centered = (CENTER_S *) fs_get(sizeof(CENTER_S));
+	memset(HD(f)->centered, 0, sizeof(CENTER_S));
+	/* and grab a buf to start collecting centered text */
+	HD(f)->centered->line.len  = WRAP_COLS(f);
+	HD(f)->centered->line.buf  = (char *) fs_get(HD(f)->centered->line.len
+							      * sizeof(char));
+	HD(f)->centered->line.used = HD(f)->centered->line.width = 0;
+	HD(f)->centered->word.len  = 32;
+	HD(f)->centered->word.buf  = (char *) fs_get(HD(f)->centered->word.len
+							       * sizeof(char));
+	HD(f)->centered->word.used = HD(f)->centered->word.width = 0;
+    }
+
+    if(ch == HTML_NEWLINE){		/* hard newline */
+	html_centered_flush(f);
+    }
+    else if(ch == TAG_EMBED){		/* takes up no space */
+	HD(f)->centered->embedded = 1;
+	html_centered_putc(&HD(f)->centered->word, TAG_EMBED);
+    }
+    else if(HD(f)->centered->embedded){
+	static char *color_ptr = NULL;
+
+	if(ch == TAG_HANDLE){
+	    HD(f)->centered->embedded = -1; /* next ch is length */
+	}
+	else if(ch == TAG_FGCOLOR || ch == TAG_BGCOLOR){
+	    if(!HD(f)->color)
+	      HD(f)->color = new_color_pair(NULL, NULL);
+	    
+	    if(ch == TAG_FGCOLOR)
+	      color_ptr = HD(f)->color->fg;
+	    else
+	      color_ptr = HD(f)->color->bg;
+
+	    HD(f)->centered->embedded = 11;
+	}
+	else if(HD(f)->centered->embedded < 0){
+	    HD(f)->centered->embedded = ch; /* number of embedded chars */
+	}
+	else{
+	    HD(f)->centered->embedded--;
+	    if(color_ptr)
+	      *color_ptr++ = ch;
+	    
+	    if(HD(f)->centered->embedded == 0 && color_ptr){
+		*color_ptr = '\0';
+		color_ptr = NULL;
+	    }
+	}
+
+	html_centered_putc(&HD(f)->centered->word, ch);
+    }
+    else if(isspace((unsigned char) ch)){
+	if(!HD(f)->centered->space++){	/* end of a word? flush! */
+	    int i;
+
+	    if(WRAPPED_LEN(f) > HD(f)->wrapcol){
+		html_centered_flush_line(f);
+		/* fall thru to put current "word" on blank "line" */
+	    }
+	    else if(HD(f)->centered->line.width){
+		/* put space char between line and appended word */
+		html_centered_putc(&HD(f)->centered->line, ' ');
+		HD(f)->centered->line.width++;
+	    }
+
+	    for(i = 0; i < HD(f)->centered->word.used; i++)
+	      html_centered_putc(&HD(f)->centered->line,
+				 HD(f)->centered->word.buf[i]);
+
+	    HD(f)->centered->line.width += HD(f)->centered->word.width;
+	    HD(f)->centered->word.used  = 0;
+	    HD(f)->centered->word.width = 0;
+	}
+    }
+    else{
+	if(HD(f)->prefix)
+	  html_a_prefix(f);
+
+	/* ch is start of next word */
+	HD(f)->centered->space = 0;
+	if(HD(f)->centered->word.width >= WRAP_COLS(f))
+	  html_centered_flush(f);
+
+	html_centered_putc(&HD(f)->centered->word, ch);
+	HD(f)->centered->word.width++;
+    }
+}
+
+
+/*
+ * html_centered_putc -- add given char to given WRAPLINE_S
+ */
+void
+html_centered_putc(wp, ch)
+    WRAPLINE_S *wp;
+    int		ch;
+{
+    if(wp->used + 1 >= wp->len){
+	wp->len += 64;
+	fs_resize((void **) &wp->buf, wp->len * sizeof(char));
+    }
+
+    wp->buf[wp->used++] = ch;
+}
+
+
+
+/*
+ * html_centered_flush - finish writing any pending centered output
+ */
+void
+html_centered_flush(f)
+    FILTER_S *f;
+{
+    int i, h;
+
+    /*
+     * If word present (what about line?) we need to deal with
+     * appending it...
+     */
+    if(HD(f)->centered->word.width && WRAPPED_LEN(f) > HD(f)->wrapcol)
+      html_centered_flush_line(f);
+
+    if(WRAPPED_LEN(f)){
+	/* figure out how much to indent */
+	if((i = (WRAP_COLS(f) - WRAPPED_LEN(f))/2) > 0)
+	  html_write_indent(f, i);
+
+	if(HD(f)->centered->anchor)
+	  html_write_anchor(f, HD(f)->centered->anchor);
+
+	html_centered_handle(&HD(f)->centered->anchor,
+			     HD(f)->centered->line.buf,
+			     HD(f)->centered->line.used);
+	html_write(f, HD(f)->centered->line.buf, HD(f)->centered->line.used);
+
+	if(HD(f)->centered->word.used){
+	    if(HD(f)->centered->line.width)
+	      html_putc(f, ' ');
+
+	    html_centered_handle(&HD(f)->centered->anchor,
+				 HD(f)->centered->word.buf,
+				 HD(f)->centered->word.used);
+	    html_write(f, HD(f)->centered->word.buf,
+		       HD(f)->centered->word.used);
+	}
+
+	HD(f)->centered->line.used  = HD(f)->centered->word.used  = 0;
+	HD(f)->centered->line.width = HD(f)->centered->word.width = 0;
+    }
+    else
+      HD(f)->blanks++;			/* advance the blank line counter */
+
+    html_newline(f);			/* finish the line */
+}
+
+
+/*
+ * html_centered_handle - scan the line for embedded handles
+ */
+void
+html_centered_handle(h, line, len)
+    int  *h;
+    char *line;
+    int   len;
+{
+    int n;
+
+    while(len-- > 0)
+      if(*line++ == TAG_EMBED && len-- > 0)
+	switch(*line++){
+	  case TAG_HANDLE :
+	    if((n = *line++) >= --len){
+		*h = 0;
+		len -= n;
+		while(n--)
+		  *h = (*h * 10) + (*line++ - '0');
+	    }
+	    break;
+
+	  case TAG_HANDLEOFF :
+	  case TAG_INVOFF :
+	    *h = 0;		/* assumption 23,342: inverse off ends tags */
+	    break;
+
+	  default :
+	    break;
+	}
+}
+
+
+
+/*
+ * html_centered_flush_line - flush the centered "line" only
+ */
+void
+html_centered_flush_line(f)
+    FILTER_S *f;
+{
+    if(HD(f)->centered->line.used){
+	int i, j;
+
+	/* hide "word" from flush */
+	i = HD(f)->centered->word.used;
+	j = HD(f)->centered->word.width;
+	HD(f)->centered->word.used  = 0;
+	HD(f)->centered->word.width = 0;
+	html_centered_flush(f);
+
+	HD(f)->centered->word.used  = i;
+	HD(f)->centered->word.width = j;
+    }
+}
+
+
+/*
+ * html_write_indent - write indention mindful of display attributes
+ */
+void
+html_write_indent(f, indent)
+    FILTER_S *f;
+    int	      indent;
+{
+    if(! STRIP(f)){
+	if(BOLD_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_BOLDOFF);
+	}
+
+	if(ULINE_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_ULINEOFF);
+	}
+    }
+
+    f->n = indent;
+    while(indent-- > 0)
+      html_putc(f, ' ');		/* indent as needed */
+
+    /*
+     * Resume any previous embedded state
+     */
+    if(! STRIP(f)){
+	if(BOLD_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_BOLDON);
+	}
+
+	if(ULINE_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_ULINEON);
+	}
+    }
+}
+
+
+/*
+ *
+ */
+void
+html_write_anchor(f, anchor)
+    FILTER_S *f;
+    int	      anchor;
+{
+    char buf[256];
+    int  i;
+
+    html_putc(f, TAG_EMBED);
+    html_putc(f, TAG_HANDLE);
+    sprintf(buf, "%d", anchor);
+    html_putc(f, (int) strlen(buf));
+
+    for(i = 0; buf[i]; i++)
+      html_putc(f, buf[i]);
+}
+
+
+/*
+ * html_write_newline - write a newline mindful of display attributes
+ */
+void
+html_write_newline(f)
+    FILTER_S *f;
+{
+    if(! STRIP(f)){			/* First tie, off any embedded state */
+	if(HD(f)->in_anchor){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_INVOFF);
+	}
+
+	if(BOLD_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_BOLDOFF);
+	}
+
+	if(ULINE_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_ULINEOFF);
+	}
+
+	if(HD(f)->color && HD(f)->color->fg[0] && HD(f)->color->bg[0]){
+	    char        *p;
+	    int          i;
+
+	    p = color_embed(ps_global->VAR_NORM_FORE_COLOR,
+			    ps_global->VAR_NORM_BACK_COLOR);
+	    for(i = 0; i < 2 * (RGBLEN + 2); i++)
+	      html_putc(f, p[i]);
+	}
+    }
+
+    html_write(f, "\015\012", 2);
+
+    if(! STRIP(f)){			/* First tie, off any embedded state */
+	if(BOLD_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_BOLDON);
+	}
+
+	if(ULINE_BIT(f)){
+	    html_putc(f, TAG_EMBED);
+	    html_putc(f, TAG_ULINEON);
+	}
+
+	if(HD(f)->color && HD(f)->color->fg[0] && HD(f)->color->bg[0]){
+	    char        *p;
+	    int          i;
+	    COLOR_PAIR  *tmp;
+
+	    tmp = new_color_pair(HD(f)->color->fg, HD(f)->color->bg);
+	    if(pico_is_good_colorpair(tmp)){
+		p = color_embed(HD(f)->color->fg, HD(f)->color->bg);
+		for(i = 0; i < 2 * (RGBLEN + 2); i++)
+		  html_putc(f, p[i]);
+	    }
+
+	    HD(f)->color->fg[0] = '\0';
+	    HD(f)->color->bg[0] = '\0';
+
+	    if(tmp)
+	      free_color_pair(&tmp);
+	}
+    }
+}
+
+
+/*
+ * html_write - write given int array to the next filter.
+ */
+void
+html_write(f, s, n)
+    FILTER_S *f;
+    char     *s;
+    int	      n;
+{
+    GF_INIT(f, f->next);
+
+    while(n-- > 0){
+	/* keep track of attribute state?  Not if last char! */
+	if(*s == TAG_EMBED && n-- > 0){
+	    GF_PUTC(f->next, TAG_EMBED);
+	    switch(*++s){
+	      case TAG_BOLDON :
+		BOLD_BIT(f) = 1;
+		break;
+	      case TAG_BOLDOFF :
+		BOLD_BIT(f) = 0;
+		break;
+	      case TAG_ULINEON :
+		ULINE_BIT(f) = 1;
+		break;
+	      case TAG_ULINEOFF :
+		ULINE_BIT(f) = 0;
+		break;
+	      case TAG_HANDLEOFF :
+		HD(f)->in_anchor = 0;
+		GF_PUTC(f->next, TAG_INVOFF);
+		s++;
+		continue;
+	      case TAG_HANDLE :
+		if(n-- > 0){
+		    int i = *++s;
+
+		    GF_PUTC(f->next, TAG_HANDLE);
+		    if(i <= n){
+			n -= i;
+			GF_PUTC(f->next, i);
+			HD(f)->in_anchor = 0;
+			while(1){
+			    HD(f)->in_anchor = (HD(f)->in_anchor * 10)
+								+ (*++s - '0');
+			    if(--i)
+			      GF_PUTC(f->next, *s);
+			    else
+			      break;
+			}
+		    }
+		}
+
+		break;
+	      default:
+		break;
+	    }
+	}
+
+	GF_PUTC(f->next, (*s++) & 0xff);
+    }
+
+    GF_IP_END(f->next);			/* clean up next's input pointers */
+}
+
+
+/*
+ * html_putc -- actual work of writing to next filter.
+ *		NOTE: Small opt not using full GF_END since our input
+ *		      pointers don't need adjusting.
+ */
+void
+html_putc(f, ch)
+    FILTER_S *f;
+    int	      ch;
+{
+    GF_INIT(f, f->next);
+    GF_PUTC(f->next, ch & 0xff);
+    GF_IP_END(f->next);			/* clean up next's input pointers */
+}
+
+
+
+/*
+ * Only current option is to turn on embedded data stripping for text
+ * bound to a printer or composer.
+ */
+void *
+gf_html2plain_opt(base, columns, flags)
+    char *base;
+    int	  columns, flags;
+{
+    HTML_OPT_S *op;
+
+    op = (HTML_OPT_S *) fs_get(sizeof(HTML_OPT_S));
+
+    op->base	    = cpystr(base);
+    op->columns	    = columns;
+    op->strip	    = ((flags & GFHP_STRIPPED) == GFHP_STRIPPED);
+    op->handles	    = ((flags & GFHP_HANDLES) == GFHP_HANDLES);
+    op->handles_loc = ((flags & GFHP_LOCAL_HANDLES) == GFHP_LOCAL_HANDLES);
+    return((void *) op);
+}
+
+
+/* END OF HTML-TO-PLAIN text filter */
+
+/*
+ * ESCAPE CODE FILTER - remove unknown and possibly dangerous escape codes
+ * from the text stream.
+ */
+
+#define	MAX_ESC_LEN	5
+
+/*
+ * the simple filter, removes unknown escape codes from the stream
+ */
+void
+gf_escape_filter(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    register char *p;
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register int state = f->f1;
+
+	while(GF_GETC(f, c)){
+
+	    if(state){
+		if(c == '\033' || f->n == MAX_ESC_LEN){
+		    f->line[f->n] = '\0';
+		    f->n = 0L;
+		    if(!match_escapes(f->line)){
+			GF_PUTC(f->next, '^');
+			GF_PUTC(f->next, '[');
+		    }
+		    else
+		      GF_PUTC(f->next, '\033');
+
+		    p = f->line;
+		    while(*p)
+		      GF_PUTC(f->next, *p++);
+
+		    if(c == '\033')
+		      continue;
+		    else
+		      state = 0;			/* fall thru */
+		}
+		else{
+		    f->line[f->n++] = c;		/* collect */
+		    continue;
+		}
+	    }
+
+	    if(c == '\033')
+	      state = 1;
+	    else
+	      GF_PUTC(f->next, c);
+	}
+
+	f->f1 = state;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	if(f->f1){
+	    if(!match_escapes(f->line)){
+		GF_PUTC(f->next, '^');
+		GF_PUTC(f->next, '[');
+	    }
+	    else
+	      GF_PUTC(f->next, '\033');
+	}
+
+	for(p = f->line; f->n; f->n--, p++)
+	  GF_PUTC(f->next, *p);
+
+	fs_give((void **)&(f->line));	/* free temp line buffer */
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset escape\n"));
+	f->f1    = 0;
+	f->n     = 0L;
+	f->linep = f->line = (char *)fs_get((MAX_ESC_LEN + 1) * sizeof(char));
+    }
+}
+
+
+
+/*
+ * CONTROL CHARACTER FILTER - transmogrify control characters into their
+ * corresponding string representations (you know, ^blah and such)...
+ */
+
+/*
+ * the simple filter transforms unknown control characters in the stream
+ * into harmless strings.
+ */
+void
+gf_control_filter(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+
+	while(GF_GETC(f, c)){
+
+	    if(iscntrl(c & 0x7f)
+	       && !(isspace((unsigned char) c)
+		    || c == '\016' || c == '\017' || c == '\033')){
+		GF_PUTC(f->next, '^');
+		GF_PUTC(f->next, c + '@');
+	    }
+	    else
+	      GF_PUTC(f->next, c);
+	}
+
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+}
+
+
+
+/*
+ * LINEWRAP FILTER - insert CRLF's at end of nearest whitespace before
+ * specified line width
+ */
+
+
+typedef struct wrap_col_s {
+    unsigned	bold:1;
+    unsigned	uline:1;
+    unsigned	inverse:1;
+    unsigned	tags:1;
+    unsigned	do_indent:1;
+    unsigned	on_comma:1;
+    unsigned	quoted:1;
+    COLOR_PAIR *color;
+    short	embedded,
+		space_len;
+    char       *lineendp,
+		space;
+    int		anchor;
+    int		wrap_col,
+		wrap_max,
+		indent;
+    char	special[256];
+} WRAP_S;
+
+
+#define	WRAP_COL(F)	(((WRAP_S *)(F)->opt)->wrap_col)
+#define	WRAP_MAX_COL(F)	(((WRAP_S *)(F)->opt)->wrap_max)
+#define	WRAP_INDENT(F)	(((WRAP_S *)(F)->opt)->indent)
+#define	WRAP_DO_IND(F)	(((WRAP_S *)(F)->opt)->do_indent)
+#define	WRAP_COMMA(F)	(((WRAP_S *)(F)->opt)->on_comma)
+#define	WRAP_QUOTED(F)	(((WRAP_S *)(F)->opt)->quoted)
+#define	WRAP_TAGS(F)	(((WRAP_S *)(F)->opt)->tags)
+#define	WRAP_BOLD(F)	(((WRAP_S *)(F)->opt)->bold)
+#define	WRAP_ULINE(F)	(((WRAP_S *)(F)->opt)->uline)
+#define	WRAP_INVERSE(F)	(((WRAP_S *)(F)->opt)->inverse)
+#define	WRAP_COLOR(F)	(((WRAP_S *)(F)->opt)->color)
+#define	WRAP_LASTC(F)	(((WRAP_S *)(F)->opt)->lineendp)
+#define	WRAP_EMBED(F)	(((WRAP_S *)(F)->opt)->embedded)
+#define	WRAP_ANCHOR(F)	(((WRAP_S *)(F)->opt)->anchor)
+#define	WRAP_SPACE(F)	(((WRAP_S *)(F)->opt)->space)
+#define	WRAP_SPACES(F)	(WRAP_SPACE(F) ? (((WRAP_S *)(F)->opt)->space_len): 0)
+#define	WRAP_SPC_LEN(F)	(((WRAP_S *)(F)->opt)->space_len)
+#define	WRAP_SPEC(S, C)	(S)[C]
+
+#define	WRAP_EOL(F)	{						\
+			    if(WRAP_BOLD(F)){				\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_BOLDOFF);	\
+			    }						\
+			    if(WRAP_ULINE(F)){				\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_ULINEOFF);	\
+			    }						\
+			    if(WRAP_INVERSE(F) || WRAP_ANCHOR(F)){	\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_INVOFF);		\
+			    }						\
+			    if(WRAP_COLOR(F)){				\
+				char *p;				\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_FGCOLOR);	\
+				p = color_to_asciirgb(ps_global->VAR_NORM_FORE_COLOR);\
+				for(; *p; p++)				\
+				  GF_PUTC((F)->next, *p);		\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_BGCOLOR);	\
+				p = color_to_asciirgb(ps_global->VAR_NORM_BACK_COLOR);\
+				for(; *p; p++)				\
+				  GF_PUTC((F)->next, *p);		\
+			    }						\
+			    GF_PUTC((F)->next, '\015');			\
+			    GF_PUTC((F)->next, '\012');			\
+			    f->n = 0L;					\
+			    WRAP_SPACE(F) = 0;				\
+			}
+
+#define	WRAP_BOL(F)	{						\
+			    if(WRAP_BOLD(F)){				\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_BOLDON);		\
+			    }						\
+			    if(WRAP_ULINE(F)){				\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_ULINEON);	\
+			    }						\
+			    if(WRAP_INVERSE(F)){			\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_INVON);		\
+			    }						\
+			    if(WRAP_COLOR(F)){				\
+				char *p;				\
+				if(WRAP_COLOR(F)->fg[0]){		\
+				  GF_PUTC((F)->next, TAG_EMBED);	\
+				  GF_PUTC((F)->next, TAG_FGCOLOR);	\
+				  p = color_to_asciirgb(WRAP_COLOR(F)->fg);\
+				  for(; *p; p++)			\
+				    GF_PUTC((F)->next, *p);		\
+				}					\
+				if(WRAP_COLOR(F)->bg[0]){		\
+				  GF_PUTC((F)->next, TAG_EMBED);	\
+				  GF_PUTC((F)->next, TAG_BGCOLOR);	\
+				  p = color_to_asciirgb(WRAP_COLOR(F)->bg);\
+				  for(; *p; p++)			\
+				    GF_PUTC((F)->next, *p);		\
+				}					\
+			    }						\
+			    if(WRAP_ANCHOR(F)){				\
+				char buf[64]; int i;			\
+				GF_PUTC((F)->next, TAG_EMBED);		\
+				GF_PUTC((F)->next, TAG_HANDLE);		\
+				sprintf(buf, "%d", WRAP_ANCHOR(F));	\
+				GF_PUTC((F)->next, (int) strlen(buf));	\
+				for(i = 0; buf[i]; i++)			\
+				  GF_PUTC((F)->next, buf[i]);		\
+			    }						\
+			}
+
+#define	WRAP_PUTC(F,C)	{						\
+			    if((F)->linep == WRAP_LASTC(F)){		\
+				size_t offset = (F)->linep - (F)->line;	\
+				fs_resize((void **) &(F)->line,		\
+					  (2 * offset) * sizeof(char)); \
+				(F)->linep = &(F)->line[offset];	\
+				WRAP_LASTC(F) = &(F)->line[2*offset-1];	\
+			    }						\
+			    *(F)->linep++ = (C);			\
+			}
+
+#define	WRAP_FLUSH(F)	{						\
+			    register char *s = f->line;			\
+			    register int   n;				\
+			    if(!f->n){					\
+				if(WRAP_DO_IND(F)){			\
+				    if(f->n = (long)(n = WRAP_INDENT(F))) \
+				      while(n-- > 0)			\
+					GF_PUTC((F)->next, ' ');	\
+				    WRAP_DO_IND(F) = 0;			\
+				}					\
+				WRAP_BOL(F);				\
+			    }						\
+			    if(WRAP_SPACE(F)){				\
+				GF_PUTC(f->next, WRAP_SPACE(F));	\
+				WRAP_SPACE(F) = 0;			\
+				f->n += WRAP_SPC_LEN(F);		\
+			    }						\
+			    for(n = f->linep - f->line; n > 0; n--){	\
+				if(*s == TAG_EMBED){			\
+				    if(n-- > 0){			\
+					GF_PUTC(f->next, TAG_EMBED);	\
+					switch(*++s){			\
+					  case TAG_BOLDON :		\
+					    WRAP_BOLD(f) = 1;		\
+					    break;			\
+					  case TAG_BOLDOFF :		\
+					    WRAP_BOLD(f) = 0;		\
+					    break;			\
+					  case TAG_ULINEON :		\
+					    WRAP_ULINE(f) = 1;		\
+					    break;			\
+					  case TAG_ULINEOFF :		\
+					    WRAP_ULINE(f) = 0;		\
+					    break;			\
+					  case TAG_INVOFF :		\
+					    WRAP_ANCHOR(f) = 0;		\
+					    break;			\
+					  case TAG_HANDLE :		\
+					    if(n-- > 0){		\
+						int i = *++s;		\
+						GF_PUTC(f->next, TAG_HANDLE); \
+						if(i <= n){		\
+						    n -= i;		\
+						    GF_PUTC(f->next, i); \
+						    WRAP_ANCHOR(f) = 0;	\
+						    while(1){		\
+							WRAP_ANCHOR(f)	\
+							  = (WRAP_ANCHOR(f) \
+							        * 10)	\
+								+ (*++s-'0');\
+							if(--i)		\
+							  GF_PUTC(f->next,*s);\
+							else		\
+							  break;	\
+						    }			\
+						}			\
+					    }				\
+					    break;			\
+					  case TAG_FGCOLOR :		\
+					    if(pico_usingcolor()	\
+					       && n >= RGBLEN){		\
+					      if(!WRAP_COLOR(f))	\
+						WRAP_COLOR(f)=new_color_pair(NULL,NULL); \
+					      strncpy(WRAP_COLOR(f)->fg, \
+						      s+1, RGBLEN);	\
+					      WRAP_COLOR(f)->fg[RGBLEN]='\0'; \
+					      i = RGBLEN;		\
+					      n -= i;			\
+					      while(i-- > 0)		\
+						GF_PUTC(f->next,	\
+							(*s++) & 0xff);	\
+					    }				\
+					    break;			\
+					  case TAG_BGCOLOR :		\
+					    if(pico_usingcolor()	\
+					       && n >= RGBLEN){		\
+					      if(!WRAP_COLOR(f))	\
+						WRAP_COLOR(f)=new_color_pair(NULL,NULL); \
+					      strncpy(WRAP_COLOR(f)->bg,\
+						      s+1, RGBLEN);	\
+					      WRAP_COLOR(f)->bg[RGBLEN]='\0'; \
+					      i = RGBLEN;		\
+					      n -= i;			\
+					      while(i-- > 0)		\
+						GF_PUTC(f->next,	\
+							(*s++) & 0xff);	\
+					    }				\
+					    break;			\
+					  default :			\
+					    break;			\
+					}				\
+				    }					\
+				}					\
+				else					\
+				  f->n++;				\
+				GF_PUTC(f->next, (*s++) & 0xff);	\
+			    }						\
+			    f->f2    = 0;				\
+			    f->linep = f->line;				\
+			}
+
+
+
+
+/*
+ * the simple filter, breaks lines at end of white space nearest
+ * to global "gf_wrap_width" in length
+ */
+void
+gf_wrap(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    register long i;
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register int state = f->f1;
+	int	     wrap_threshold = WRAP_MAX_COL(f) - WRAP_INDENT(f);
+	char	    *special = ((WRAP_S *) f->opt)->special;
+
+	while(GF_GETC(f, c)){
+
+	    switch(state){
+	      case CCR :
+		state = DFL;			/* CRLF or CR in text ? */
+		WRAP_FLUSH(f);			/* it's a newline to us */
+		WRAP_EOL(f);
+		WRAP_BOL(f);
+		if(c == '\012')			/* process anything but LF */
+		  break;
+
+	      case DFL :
+		if(WRAP_SPEC(special, c))
+		  switch(c){
+		    default :
+		      if(WRAP_QUOTED(f))
+			break;
+
+		      WRAP_FLUSH(f);		/* flush buf */
+		      switch(WRAP_SPACE(f) = c){ /* remember separator */
+			case ' ' :
+			  WRAP_SPC_LEN(f) = 1;
+			  break;
+
+			case TAB :
+			{
+			    int i = (int) f->n;
+			    while(++i & 0x07)
+			      ;
+
+			    WRAP_SPC_LEN(f) = i - (int) f->n;
+			}
+
+			break;
+
+			default :		/* some control char? */
+			  WRAP_SPC_LEN(f) = 2;
+			  break;
+		      }
+
+		      continue;
+
+		    case '\"' :
+		      WRAP_QUOTED(f) = !WRAP_QUOTED(f);
+		      break;
+
+		    case '\015' :		/* already has newline? */
+		      state = CCR;
+		      continue;
+
+		    case '\012' :		/* bare LF in text? */
+		      WRAP_FLUSH(f);		/* they must've meant */
+		      WRAP_EOL(f);		/* newline... */
+		      WRAP_BOL(f);
+		      continue;
+
+		    case (unsigned char) TAG_EMBED :
+		      WRAP_PUTC(f, TAG_EMBED);
+		      state = TAG;
+		      continue;
+
+		    case ',' :
+		      if(!WRAP_QUOTED(f)){
+			  WRAP_PUTC(f, ',');
+			  WRAP_FLUSH(f);
+			  WRAP_SPACE(f) = 0;
+			  continue;
+		      }
+
+		      break;
+		  }
+
+		if(!f->n && (f->f2 >= wrap_threshold)){
+		    char *ep, *space = NULL;
+		    int   cntr, new_f2;
+
+		    /* Flush the buf'd line up to last WS */
+		    if(WRAP_COMMA(f)){
+			char *p;
+
+			new_f2 = cntr = f->f2;
+			for(p = f->line; p < f->linep; p++){
+			    /*
+			     * Don't split at WS which is in the middle
+			     * of a tag.
+			     */
+			    switch((unsigned char)*p){
+			      case (unsigned char)TAG_EMBED:
+				if(++p >= f->linep)
+				  break;
+
+				switch(*p){
+				  case TAG_FGCOLOR:
+				  case TAG_BGCOLOR:
+				    p += RGBLEN;
+				    break;
+
+				  case TAG_HANDLE:
+				    if(++p >= f->linep)
+				      break;
+					
+				    p += (*p);
+				    break;
+
+				  default:
+				    break;
+				}
+
+				continue;
+				break;
+				
+			      default:
+				break;
+			    }
+				
+			    cntr--;
+
+			    if(p < f->linep && isspace((unsigned char)*p)){
+				space = p;
+				new_f2 = cntr;
+			    }
+			}
+
+			if(space){
+			    ep = f->linep;
+			    f->linep = space;
+			}
+		    }
+
+		    WRAP_FLUSH(f);		/* write buffered */
+		    WRAP_EOL(f);		/* write end of line */
+		    WRAP_DO_IND(f) = 1;		/* indent next line */
+
+		    if(space){
+			f->linep = f->line;
+			while(++space < ep)
+			  *f->linep++ = *space;
+
+			f->f2 = new_f2;
+		    }
+		}
+
+		WRAP_PUTC(f, c);
+
+		if(c == '\t' && WRAP_COMMA(f)){
+		    int i = (int) f->n;
+		    while(++i & 0x07)
+		      ;
+
+		    f->f2 += i - (int) f->n;
+		}
+		else
+		  f->f2++;
+
+		if(f->n && (f->n + f->f2 + WRAP_SPACES(f) >= WRAP_COL(f))){
+		    WRAP_EOL(f);		/* write end of line */
+		    WRAP_DO_IND(f) = 1;		/* indent next line */
+		}
+
+		break;
+
+	      case TAG :
+		WRAP_PUTC(f, c);
+		switch(c){
+		  case TAG_HANDLE :
+		    WRAP_EMBED(f) = -1;
+		    state = HANDLE;
+		    break;
+
+		  case TAG_FGCOLOR :
+		  case TAG_BGCOLOR :
+		    WRAP_EMBED(f) = RGBLEN;
+		    state = HDATA;
+		    break;
+
+		  default :
+		    state = DFL;
+		    break;
+		}
+
+		break;
+
+	      case HANDLE :
+		WRAP_PUTC(f, c);
+		WRAP_EMBED(f) = c;
+		state = HDATA;
+		break;
+
+	      case HDATA :
+		WRAP_PUTC(f, c);
+		if(!(WRAP_EMBED(f) -= 1))
+		  state = DFL;
+
+		break;
+	    }
+	}
+
+	f->f1 = state;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	WRAP_FLUSH(f);
+	if(WRAP_COLOR(f))
+	  free_color_pair(&WRAP_COLOR(f));
+
+	fs_give((void **) &f->line);	/* free temp line buffer */
+	fs_give((void **) &f->opt);	/* free wrap widths struct */
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset wrap\n"));
+	f->f1    = DFL;
+	f->n     = 0L;		/* displayed length of line so far */
+	f->f2	 = 0;		/* displayed length of buffered chars */
+	if(! (WRAP_S *) f->opt)
+	  f->opt = gf_wrap_filter_opt(75, 80, 0, 0);
+
+	while(WRAP_INDENT(f) >= WRAP_MAX_COL(f))
+	  WRAP_INDENT(f) /= 2;
+
+	f->line  = (char *) fs_get(WRAP_MAX_COL(f) * sizeof(char));
+	f->linep = f->line;
+	WRAP_LASTC(f) = &f->line[WRAP_MAX_COL(f) - 1];
+
+	for(i = 0; i < 256; i++)
+	  ((WRAP_S *) f->opt)->special[i] = ((i == '\"' && WRAP_COMMA(f))
+					     || i == '\015'
+					     || i == '\012'
+					     || (i == (unsigned char) TAG_EMBED
+						 && WRAP_TAGS(f))
+					     || (i == ',' && WRAP_COMMA(f)
+						 && !WRAP_QUOTED(f))
+					     || (!WRAP_COMMA(f)
+					      && isspace((unsigned char) i)));
+    }
+}
+
+
+/*
+ * function called from the outside to set
+ * wrap filter's width option
+ */
+void *
+gf_wrap_filter_opt(width, width_max, indent, flags)
+    int width, width_max, indent, flags;
+{
+    WRAP_S *wrap;
+
+    wrap = (WRAP_S *) fs_get(sizeof(WRAP_S));
+    memset(wrap, 0, sizeof(WRAP_S));
+    wrap->wrap_col = width;
+    wrap->wrap_max = width_max;
+    wrap->indent   = indent;
+    wrap->tags	   = (GFW_HANDLES & flags) == GFW_HANDLES;
+    wrap->on_comma = (GFW_ONCOMMA & flags) == GFW_ONCOMMA;
+    return((void *) wrap);
+}
+
+
+
+
+/*
+ * LINE PREFIX FILTER - insert given text at beginning of each
+ * line
+ */
+
+
+#define	GF_PREFIX_WRITE(s)	{ \
+				    register char *p; \
+				    if(p = (s)) \
+				      while(*p) \
+					GF_PUTC(f->next, *p++); \
+				}
+
+
+/*
+ * the simple filter, prepends each line with the requested prefix.
+ * if prefix is null, does nothing, and as with all filters, assumes
+ * NVT end of lines.
+ */
+void
+gf_prefix(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register int state = f->f1;
+	register int first = f->f2;
+
+	while(GF_GETC(f, c)){
+
+	    if(first){			/* write initial prefix!! */
+		first = 0;		/* but just once */
+		GF_PREFIX_WRITE((char *) f->opt);
+	    }
+	    else if(state){
+		state = 0;
+		GF_PUTC(f->next, '\015');
+		if(c == '\012'){
+		    GF_PUTC(f->next, '\012');
+		    GF_PREFIX_WRITE((char *) f->opt);
+		    continue;
+		}
+		/* else fall thru to handle 'c' */
+	    }
+
+	    if(c == '\015')		/* already has newline? */
+	      state = 1;
+	    else
+	      GF_PUTC(f->next, c);
+	}
+
+	f->f1 = state;
+	f->f2 = first;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset prefix\n"));
+	f->f1   = 0;
+	f->f2   = 1;			/* nothing written yet */
+    }
+}
+
+
+/*
+ * function called from the outside to set
+ * prefix filter's prefix string
+ */
+void *
+gf_prefix_opt(prefix)
+    char *prefix;
+{
+    return((void *) prefix);
+}
+
+
+/*
+ * LINE TEST FILTER - accumulate lines and offer each to the provided
+ * test function.
+ */
+
+typedef struct _linetest_s {
+    linetest_t	f;
+    void       *local;
+} LINETEST_S;
+
+
+/* accumulator growth increment */
+#define	LINE_TEST_BLOCK	1024
+
+#define	GF_LINE_TEST_EOB(f) \
+			((f)->line + ((f)->f2 - 1))
+
+#define	GF_LINE_TEST_ADD(f, c) \
+			{ \
+				    if(p >= eobuf){ \
+					f->f2 += LINE_TEST_BLOCK; \
+					fs_resize((void **)&f->line, \
+					      (size_t) f->f2 * sizeof(char)); \
+					eobuf = GF_LINE_TEST_EOB(f); \
+					p = eobuf - LINE_TEST_BLOCK; \
+				    } \
+				    *p++ = c; \
+				}
+
+#define	GF_LINE_TEST_TEST(F, D) \
+			{ \
+			    unsigned char  c; \
+			    register char *cp; \
+			    register int   l; \
+			    LT_INS_S	  *ins = NULL, *insp; \
+			    *p = '\0'; \
+			    (D) = (*((LINETEST_S *) (F)->opt)->f)((F)->n++, \
+					   (F)->line, &ins, \
+					   ((LINETEST_S *) (F)->opt)->local); \
+			    if((D) < 2){ \
+				for(insp = ins, cp = (F)->line; cp < p; ){ \
+				    while(insp && cp == insp->where){ \
+					for(l = 0; l < insp->len; l++){ \
+					    c = (unsigned char) insp->text[l];\
+					    GF_PUTC((F)->next, c); \
+					} \
+					insp = insp->next; \
+				    } \
+				    GF_PUTC((F)->next, *cp); \
+				    cp++; \
+				} \
+				while(insp){ \
+				    for(l = 0; l < insp->len; l++){ \
+					c = (unsigned char) insp->text[l]; \
+					GF_PUTC((F)->next, c); \
+				    } \
+				    insp = insp->next; \
+				} \
+				gf_line_test_free_ins(&ins); \
+			    } \
+			}
+
+
+
+/*
+ * this simple filter accumulates characters until a newline, offers it
+ * to the provided test function, and then passes it on.  It assumes
+ * NVT EOLs.
+ */
+void
+gf_line_test(f, flg)
+    FILTER_S *f;
+    int	      flg;
+{
+    register char *p = f->linep;
+    register char *eobuf = GF_LINE_TEST_EOB(f);
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register int state = f->f1;
+
+	while(GF_GETC(f, c)){
+
+	    if(state){
+		state = 0;
+		if(c == '\012'){
+		    int done;
+
+		    GF_LINE_TEST_TEST(f, done);
+
+		    p = (f)->line;
+
+		    if(done == 2)	/* skip this line! */
+		      continue;
+
+		    GF_PUTC(f->next, '\015');
+		    GF_PUTC(f->next, '\012');
+		    /*
+		     * if the line tester returns TRUE, it's
+		     * telling us its seen enough and doesn't
+		     * want to see any more.  Remove ourself
+		     * from the pipeline...
+		     */
+		    if(done){
+			if(gf_master == f){
+			    gf_master = f->next;
+			}
+			else{
+			    FILTER_S *fprev;
+
+			    for(fprev = gf_master;
+				fprev && fprev->next != f;
+				fprev = fprev->next)
+			      ;
+
+			    if(fprev)		/* wha??? */
+			      fprev->next = f->next;
+			    else
+			      continue;
+			}
+
+			while(GF_GETC(f, c))	/* pass input */
+			  GF_PUTC(f->next, c);
+
+			GF_FLUSH(f->next);	/* and drain queue */
+			fs_give((void **)&f->line);
+			fs_give((void **)&f);	/* wax our data */
+			return;
+		    }
+		    else
+		      continue;
+		}
+		else			/* add CR to buffer */
+		  GF_LINE_TEST_ADD(f, '\015');
+	    } /* fall thru to handle 'c' */
+
+	    if(c == '\015')		/* newline? */
+	      state = 1;
+	    else
+	      GF_LINE_TEST_ADD(f, c);
+	}
+
+	f->f1 = state;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	int i;
+
+	GF_LINE_TEST_TEST(f, i);	/* examine remaining data */
+	fs_give((void **) &f->line);	/* free line buffer */
+	fs_give((void **) &f->opt);	/* free test struct */
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset line_test\n"));
+	f->f1 = 0;			/* state */
+	f->n  = 0L;			/* line number */
+	f->f2 = LINE_TEST_BLOCK;	/* size of alloc'd line */
+	f->line = p = (char *) fs_get(f->f2 * sizeof(char));
+    }
+
+    f->linep = p;
+}
+
+
+/*
+ * function called from the outside to operate on accumulated line.
+ */
+void *
+gf_line_test_opt(test_f, local)
+    linetest_t  test_f;
+    void       *local;
+{
+    LINETEST_S *ltp;
+
+    ltp = (LINETEST_S *) fs_get(sizeof(LINETEST_S));
+    memset(ltp, 0, sizeof(LINETEST_S));
+    ltp->f     = test_f;
+    ltp->local = local;
+    return((void *) ltp);
+}
+
+
+
+LT_INS_S **
+gf_line_test_new_ins(ins, p, s, n)
+    LT_INS_S **ins;
+    char      *p, *s;
+    int	       n;
+{
+    *ins = (LT_INS_S *) fs_get(sizeof(LT_INS_S));
+    if((*ins)->len = n)
+      strncpy((*ins)->text = (char *) fs_get(n * sizeof(char)), s, n);
+
+    (*ins)->where = p;
+    (*ins)->next  = NULL;
+    return(&(*ins)->next);
+}
+
+
+void
+gf_line_test_free_ins(ins)
+    LT_INS_S **ins;
+{
+    if(ins && *ins){
+	if((*ins)->next)
+	  gf_line_test_free_ins(&(*ins)->next);
+
+	if((*ins)->text)
+	  fs_give((void **) &(*ins)->text);
+
+	fs_give((void **) ins);
+    }
+}
+
+
+/*
+ * Network virtual terminal to local newline convention filter
+ */
+void
+gf_nvtnl_local(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+	register int state = f->f1;
+
+	while(GF_GETC(f, c)){
+	    if(state){
+		state = 0;
+		if(c == '\012'){
+		    GF_PUTC(f->next, '\012');
+		    continue;
+		}
+		else
+		  GF_PUTC(f->next, '\015');
+		/* fall thru to deal with 'c' */
+	    }
+
+	    if(c == '\015')
+	      state = 1;
+	    else
+	      GF_PUTC(f->next, c);
+	}
+
+	f->f1 = state;
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset nvtnl_local\n"));
+	f->f1 = 0;
+    }
+}
+
+
+/*
+ * local to network newline convention filter
+ */
+void
+gf_local_nvtnl(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+
+	while(GF_GETC(f, c)){
+	    if(c == '\012'){
+		GF_PUTC(f->next, '\015');
+		GF_PUTC(f->next, '\012');
+	    }
+	    else
+	      GF_PUTC(f->next, c);
+	}
+
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset local_nvtnl\n"));
+	/* no op */
+    }
+
+}
+
+#if defined(DOS) || defined(OS2)
+/*
+ * DOS CodePage to Character Set Translation (and back) filters
+ */
+
+/*
+ * Charset and CodePage mapping table pointer and length
+ */
+static unsigned char *gf_xlate_tab;
+static unsigned gf_xlate_tab_len;
+
+/*
+ * the simple filter takes DOS Code Page values and maps them into
+ * the indicated external CharSet mapping or vice-versa.
+ */
+void
+gf_translate(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+
+	while(GF_GETC(f, c))
+	  if((unsigned long) c < ((SIZEDTEXT *) (f->opt))->size)
+	    GF_PUTC(f->next, (int) ((SIZEDTEXT *) (f->opt))->data[c]);
+
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	fs_give((void **) &f->opt);	/* free up table description */
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset translate\n"));
+    }
+}
+
+
+/*
+ * function called from the outside to set
+ * prefix filter's prefix string
+ */
+void *
+gf_translate_opt(xlatetab, xlatetablen)
+    unsigned char *xlatetab;
+    unsigned       xlatetablen;
+{
+    SIZEDTEXT *xlate_tab = (SIZEDTEXT *) fs_get(sizeof(SIZEDTEXT));
+
+    xlate_tab->data = xlatetab;
+    xlate_tab->size = (unsigned long) xlatetablen;
+
+    return((void *) xlate_tab);
+}
+#endif
+
+/*
+ * display something indicating we're chewing on something
+ *
+ * NOTE : IF ANY OTHER FILTERS WRITE THE DISPLAY, THIS WILL NEED FIXING
+ */
+void
+gf_busy(f, flg)
+    FILTER_S *f;
+    int       flg;
+{
+    static short x = 0;
+    GF_INIT(f, f->next);
+
+    if(flg == GF_DATA){
+	register unsigned char c;
+
+	while(GF_GETC(f, c)){
+
+	    if(!((++(f->f1))&0x7ff)){ 	/* ding the bell every 2K chars */
+		MoveCursor(0, 1);
+		f->f1 = 0;
+		if((++x)&0x04) x = 0;
+		Writechar((x == 0) ? '/' : 	/* CHEATING! */
+			  (x == 1) ? '-' :
+			  (x == 2) ? '\\' : '|', 0);
+	    }
+
+	    GF_PUTC(f->next, c);
+	}
+
+	GF_END(f, f->next);
+    }
+    else if(flg == GF_EOD){
+	MoveCursor(0, 1);
+	Writechar(' ', 0);
+	EndInverse();
+	GF_FLUSH(f->next);
+	(*f->next->f)(f->next, GF_EOD);
+    }
+    else if(flg == GF_RESET){
+	dprint(9, (debugfile, "-- gf_reset busy\n"));
+	f->f1 = 0;
+        x = 0;
+	StartInverse();
+    }
+
+    fflush(stdout);
+}
diff --git a/net-mail/pine-maildir/files/os.c b/net-mail/pine-maildir/files/os.c
new file mode 100644
index 000000000000..2fd967904207
--- /dev/null
+++ b/net-mail/pine-maildir/files/os.c
@@ -0,0 +1,5673 @@
+/*----------------------------------------------------------------------
+
+            T H E    P I N E    M A I L   S Y S T E M
+
+   Laurence Lundblade and Mike Seibel
+   Networks and Distributed Computing
+   Computing and Communications
+   University of Washington
+   Administration Builiding, AG-44
+   Seattle, Washington, 98195, USA
+   Internet: lgl@CAC.Washington.EDU
+             mikes@CAC.Washington.EDU
+
+   Please address all bugs and comments to "pine-bugs@cac.washington.edu"
+
+
+   Pine and Pico are registered trademarks of the University of Washington.
+   No commercial use of these trademarks may be made without prior written
+   permission of the University of Washington.
+
+   Pine, Pico, and Pilot software and its included text are Copyright
+   1989-1998 by the University of Washington.
+
+   The full text of our legal notices is contained in the file called
+   CPYRIGHT, included with this distribution.
+
+
+   Pine is in part based on The Elm Mail System:
+    ***********************************************************************
+    *  The Elm Mail System  -  Revision: 2.13                             *
+    *                                                                     *
+    * 			Copyright (c) 1986, 1987 Dave Taylor              *
+    * 			Copyright (c) 1988, 1989 USENET Community Trust   *
+    ***********************************************************************
+ 
+
+  ----------------------------------------------------------------------*/
+
+/*======================================================================
+
+ This contains most of Pine's interface to the local operating system
+and hardware.  Hopefully this file, os-xxx.h and makefile.xxx are the
+only ones that have to be modified for most ports.  Signals.c, ttyin.c,
+and ttyout.c also have some dependencies.  See the doc/tech-notes for
+notes on porting Pine to other platforms.  Here is a list of the functions
+required for an implementation:
+
+
+  File System Access
+     can_access          -- See if a file can be accessed
+     name_file_size      -- Return the number of bytes in the file (by name)
+     fp_file_size        -- Return the number of bytes in the file (by FILE *)
+     name_file_mtime     -- Return the mtime of a file (by name)
+     fp_file_mtime       -- Return the mtime of a file (by FILE *)
+     file_attrib_copy    -- Copy attributes of one file to another.
+     is_writable_dir     -- Check to see if directory exists and is writable
+     create_mail_dir     -- Make a directory
+     rename_file         -- change name of a file
+     build_path          -- Put together a file system path
+     last_cmpnt          -- Returns pointer to last component of path
+     expand_foldername   -- Expand a folder name to full path
+     fnexpand            -- Do filename exansion for csh style "~"
+     filter_filename     -- Make sure file name hasn't got weird chars
+     cntxt_allowed       -- Check whether a pathname is allowed for read/write
+     disk_quota          -- Check the user's disk quota
+     read_file           -- Read whole file into memory (for small files)
+     create_tmpfile      -- Just like ANSI C tmpfile function
+     temp_nam            -- Almost like common tempnam function
+     fget_pos,fset_pos   -- Just like ANSI C fgetpos, fsetpos functions
+
+  Abort
+     coredump            -- Abort running Pine dumping core if possible
+
+  System Name and Domain
+     hostname            -- Figure out the system's host name, only
+                              used internally in this file.
+     getdomainnames      -- Figure out the system's domain name
+     canonical_name      -- Returns canonical form of host name
+
+  Job Control
+     have_job_control    -- Returns 1 if job control exists
+     stop_process        -- What to do to stop process when it's time to stop
+			      (only used if have_job_control returns 1)
+
+  System Error Messages (in case given one is a problem)
+     error_description   -- Returns string describing error
+
+  System Password and Accounts
+     gcos_name           -- Parses full name from system, only used
+			      locally in this file so if you don't use it you
+			      don't need it
+     get_user_info       -- Finds in login name, full name, and homedir
+     local_name_lookup   -- Get full name of user on system
+     change_passwd       -- Calls system password changer
+
+  MIME utilities
+     mime_can_display    -- Can we display this type/subtype?
+     exec_mailcap_cmd    -- Run the mailcap command to view a type/subtype.
+     exec_mailcap_test_cmd -- Run mailcap test= test command.
+
+  Other stuff
+     srandom             -- Dummy srandom if you don't have this function
+     init_debug
+     do_debug
+     save_debug_on_crash
+
+  ====*/
+
+
+#include "headers.h"
+
+
+
+/*----------------------------------------------------------------------
+       Check if we can access a file in a given way
+
+   Args: file      -- The file to check
+         mode      -- The mode ala the access() system call, see ACCESS_EXISTS
+                      and friends in pine.h.
+
+ Result: returns 0 if the user can access the file according to the mode,
+         -1 if he can't (and errno is set).
+ ----*/
+int
+can_access(file, mode)
+    char *file;
+    int   mode;
+{
+    return(access(file, mode));
+}
+
+
+/*----------------------------------------------------------------------
+       Check if we can access a file in a given way in the given path
+
+   Args: path     -- The path to look for "file" in
+	 file      -- The file to check
+         mode      -- The mode ala the access() system call, see ACCESS_EXISTS
+                      and friends in pine.h.
+
+ Result: returns 0 if the user can access the file according to the mode,
+         -1 if he can't (and errno is set).
+ ----*/
+can_access_in_path(path, file, mode)
+    char *path, *file;
+    int   mode;
+{
+    char tmp[MAXPATH], *path_copy, *p, *t;
+    int  rv = -1;
+
+    if(!path || !*path || *file == '/'){
+	rv = access(file, mode);
+    }
+    else if(*file == '~'){
+	strcpy(tmp, file);
+	rv = fnexpand(tmp, sizeof(tmp)) ? access(tmp, mode) : -1;
+    }
+    else{
+	for(p = path_copy = cpystr(path); p && *p; p = t){
+	    if(t = strindex(p, ':'))
+	      *t++ = '\0';
+
+	    sprintf(tmp, "%s/%s", p, file);
+	    if((rv = access(tmp, mode)) == 0)
+	      break;
+	}
+
+	fs_give((void **)&path_copy);
+    }
+
+    return(rv);
+}
+
+/*----------------------------------------------------------------------
+      Return the number of bytes in given file
+
+    Args: file -- file name
+
+  Result: the number of bytes in the file is returned or
+          -1 on error, in which case errno is valid
+ ----*/
+long
+name_file_size(file)
+    char *file;
+{
+    struct stat buffer;
+
+    if(stat(file, &buffer) != 0)
+      return(-1L);
+
+    return((long)buffer.st_size);
+}
+
+
+/*----------------------------------------------------------------------
+      Return the number of bytes in given file
+
+    Args: fp -- FILE * for open file
+
+  Result: the number of bytes in the file is returned or
+          -1 on error, in which case errno is valid
+ ----*/
+long
+fp_file_size(fp)
+    FILE *fp;
+{
+    struct stat buffer;
+
+    if(fstat(fileno(fp), &buffer) != 0)
+      return(-1L);
+
+    return((long)buffer.st_size);
+}
+
+
+/*----------------------------------------------------------------------
+      Return the modification time of given file
+
+    Args: file -- file name
+
+  Result: the time of last modification (mtime) of the file is returned or
+          -1 on error, in which case errno is valid
+ ----*/
+time_t
+name_file_mtime(file)
+    char *file;
+{
+    struct stat buffer;
+
+    if(stat(file, &buffer) != 0)
+      return((time_t)(-1));
+
+    return(buffer.st_mtime);
+}
+
+
+/*----------------------------------------------------------------------
+      Return the modification time of given file
+
+    Args: fp -- FILE * for open file
+
+  Result: the time of last modification (mtime) of the file is returned or
+          -1 on error, in which case errno is valid
+ ----*/
+time_t
+fp_file_mtime(fp)
+    FILE *fp;
+{
+    struct stat buffer;
+
+    if(fstat(fileno(fp), &buffer) != 0)
+      return((time_t)(-1));
+
+    return(buffer.st_mtime);
+}
+
+
+/*----------------------------------------------------------------------
+      Copy the mode, owner, and group of sourcefile to targetfile.
+
+    Args: targetfile -- 
+	  sourcefile --
+    
+    We don't bother keeping track of success or failure because we don't care.
+ ----*/
+void
+file_attrib_copy(targetfile, sourcefile)
+    char *targetfile;
+    char *sourcefile;
+{
+    struct stat buffer;
+
+    if(stat(sourcefile, &buffer) == 0){
+	chmod(targetfile, buffer.st_mode);
+#if !defined(DOS) && !defined(OS2)
+	chown(targetfile, buffer.st_uid, buffer.st_gid);
+#endif
+    }
+}
+
+
+
+/*----------------------------------------------------------------------
+      Check to see if a directory exists and is writable by us
+
+   Args: dir -- directory name
+
+ Result:       returns 0 if it exists and is writable
+                       1 if it is a directory, but is not writable
+                       2 if it is not a directory
+                       3 it doesn't exist.
+  ----*/
+is_writable_dir(dir)
+    char *dir;
+{
+    struct stat sb;
+
+    if(stat(dir, &sb) < 0)
+      /*--- It doesn't exist ---*/
+      return(3);
+
+    if(!(sb.st_mode & S_IFDIR))
+      /*---- it's not a directory ---*/
+      return(2);
+
+    if(can_access(dir, 07))
+      return(1);
+    else
+      return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+      Create the mail subdirectory.
+
+  Args: dir -- Name of the directory to create
+ 
+ Result: Directory is created.  Returns 0 on success, else -1 on error
+	 and errno is valid.
+  ----*/
+create_mail_dir(dir)
+    char *dir;
+{
+    if(mkdir(dir, 0700) < 0)
+      return(-1);
+
+    (void)chmod(dir, 0700);
+    /* Some systems need this, on others we don't care if it fails */
+    (void)chown(dir, getuid(), getgid());
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+      Rename a file
+
+  Args: tmpfname -- Old name of file
+        fname    -- New name of file
+ 
+ Result: File is renamed.  Returns 0 on success, else -1 on error
+	 and errno is valid.
+  ----*/
+rename_file(tmpfname, fname)
+    char *tmpfname, *fname;
+{
+    return(rename(tmpfname, fname));
+}
+
+
+
+/*----------------------------------------------------------------------
+      Paste together two pieces of a file name path
+
+  Args: pathbuf      -- Put the result here
+        first_part   -- of path name
+        second_part  -- of path name
+ 
+ Result: New path is in pathbuf.  No check is made for overflow.  Note that
+	 we don't have to check for /'s at end of first_part and beginning
+	 of second_part since multiple slashes are ok.
+
+BUGS:  This is a first stab at dealing with fs naming dependencies, and others 
+still exist.
+  ----*/
+void
+build_path(pathbuf, first_part, second_part)
+    char *pathbuf, *first_part, *second_part;
+{
+    if(!first_part)
+      strcpy(pathbuf, second_part);
+    else
+      sprintf(pathbuf, "%s%s%s", first_part,
+	      (*first_part && first_part[strlen(first_part)-1] != '/')
+	        ? "/" : "",
+	      second_part);
+}
+
+
+/*----------------------------------------------------------------------
+  Test to see if the given file path is absolute
+
+  Args: file -- file path to test
+
+ Result: TRUE if absolute, FALSE otw
+
+  ----*/
+int
+is_absolute_path(path)
+    char *path;
+{
+    return(path && (*path == '/' || *path == '~'));
+}
+
+
+
+/*----------------------------------------------------------------------
+      Return pointer to last component of pathname.
+
+  Args: filename     -- The pathname.
+ 
+ Result: Returned pointer points to last component in the input argument.
+  ----*/
+char *
+last_cmpnt(filename)
+    char *filename;
+{
+    register char *p = NULL, *q = filename;
+
+    while(q = strchr(q, '/'))
+      if(*++q)
+	p = q;
+
+    return(p);
+}
+
+
+
+/*----------------------------------------------------------------------
+      Expand a folder name, taking account of the folders_dir and `~'.
+
+  Args: filename -- The name of the file that is the folder
+ 
+ Result: The folder name is expanded in place.  
+         Returns 0 and queues status message if unsuccessful.
+         Input string is overwritten with expanded name.
+         Returns 1 if successful.
+
+BUG should limit length to MAXPATH
+  ----*/
+int
+expand_foldername(filename)
+    char *filename;
+{
+    char         temp_filename[MAXPATH+1];
+
+    dprint(5, (debugfile, "=== expand_foldername called (%s) ===\n",filename));
+
+    /*
+     * We used to check for valid filename chars here if "filename"
+     * didn't refer to a remote mailbox.  This has been rethought
+     */
+
+    strcpy(temp_filename, filename);
+    if(strucmp(temp_filename, "inbox") == 0) {
+        strcpy(filename, ps_global->VAR_INBOX_PATH == NULL ? "inbox" :
+               ps_global->VAR_INBOX_PATH);
+    } else if(temp_filename[0] == '{') {
+        strcpy(filename, temp_filename);
+    } else if(ps_global->restricted
+	        && (strindex("./~", temp_filename[0]) != NULL
+		    || srchstr(temp_filename,"/../"))){
+	q_status_message(SM_ORDER, 0, 3, "Can only open local folders");
+	return(0);
+    } else if(temp_filename[0] == '*') {
+        strcpy(filename, temp_filename);
+    } else if(ps_global->VAR_OPER_DIR && srchstr(temp_filename,"..")){
+	q_status_message(SM_ORDER, 0, 3,
+			 "\"..\" not allowed in folder name");
+	return(0);
+    } else if (temp_filename[0] == '~'){
+        if(fnexpand(temp_filename, sizeof(temp_filename)) == NULL) {
+            char *p = strindex(temp_filename, '/');
+    	    if(p != NULL)
+    	      *p = '\0';
+    	    q_status_message1(SM_ORDER, 3, 3,
+                    "Error expanding folder name: \"%s\" unknown user",
+    	       temp_filename);
+    	    return(0);
+        }
+        strcpy(filename, temp_filename);
+    } else if(temp_filename[0] == '/') {
+        strcpy(filename, temp_filename);
+    } else if(F_ON(F_USE_CURRENT_DIR, ps_global)){
+	strcpy(filename, temp_filename);
+    } else if(ps_global->VAR_OPER_DIR){
+	build_path(filename, ps_global->VAR_OPER_DIR, temp_filename);
+    } else {
+	build_path(filename, ps_global->home_dir, temp_filename);
+    }
+    dprint(5, (debugfile, "returning \"%s\"\n", filename));    
+    return(1);
+}
+
+
+
+struct passwd *getpwnam();
+
+/*----------------------------------------------------------------------
+       Expand the ~ in a file ala the csh (as home directory)
+
+   Args: buf --  The filename to expand (nothing happens unless begins with ~)
+         len --  The length of the buffer passed in (expansion is in place)
+
+ Result: Expanded string is returned using same storage as passed in.
+         If expansion fails, NULL is returned
+ ----*/
+char *
+fnexpand(buf, len)
+    char *buf;
+    int len;
+{
+    struct passwd *pw;
+    register char *x,*y;
+    char name[20];
+    
+    if(*buf == '~') {
+        for(x = buf+1, y = name; *x != '/' && *x != '\0'; *y++ = *x++);
+        *y = '\0';
+        if(x == buf + 1) 
+          pw = getpwuid(getuid());
+        else
+          pw = getpwnam(name);
+        if(pw == NULL)
+          return((char *)NULL);
+        if(strlen(pw->pw_dir) + strlen(buf) > len) {
+          return((char *)NULL);
+        }
+        rplstr(buf, x - buf, pw->pw_dir);
+    }
+    return(len ? buf : (char *)NULL);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Filter file names for strange characters
+
+   Args:  file  -- the file name to check
+ 
+ Result: Returns NULL if file name is OK
+         Returns formatted error message if it is not
+  ----*/
+char *
+filter_filename(file, fatal)
+    char *file;
+    int  *fatal;
+{
+#ifdef ALLOW_WEIRD
+    static char illegal[] = {'\177', '\0'};
+#else
+    static char illegal[] = {'"', '#', '$', '%', '&', '\'','(', ')','*',
+                          ',', ':', ';', '<', '=', '>', '?', '[', ']',
+                          '\\', '^', '|', '\177', '\0'};
+#endif
+    static char error[100];
+    char ill_file[MAXPATH+1], *ill_char, *ptr, e2[10];
+    int i;
+
+    for(ptr = file; *ptr == ' '; ptr++) ; /* leading spaces gone */
+
+    while(*ptr && (unsigned char)(*ptr) >= ' ' && strindex(illegal, *ptr) == 0)
+      ptr++;
+
+    *fatal = TRUE;
+    if(*ptr != '\0') {
+        if(*ptr == '\n') {
+            ill_char = "<newline>";
+        } else if(*ptr == '\r') {
+            ill_char = "<carriage return>";
+        } else if(*ptr == '\t') {
+    	    ill_char = "<tab>";
+	    *fatal = FALSE;		/* just whitespace */
+        } else if(*ptr < ' ') {
+            sprintf(e2, "control-%c", *ptr + '@');
+            ill_char = e2;
+        } else if (*ptr == '\177') {
+    	    ill_char = "<del>";
+        } else {
+    	    e2[0] = *ptr;
+    	    e2[1] = '\0';
+    	    ill_char = e2;
+	    *fatal = FALSE;		/* less offensive? */
+        }
+	if(!*fatal){
+	    strcpy(error, ill_char);
+	}
+        else if(ptr != file) {
+            strncpy(ill_file, file, ptr - file);
+            ill_file[ptr - file] = '\0';
+	    sprintf(error,
+		    "Character \"%s\" after \"%s\" not allowed in file name",
+		    ill_char, ill_file);
+        } else {
+            sprintf(error,
+                    "First character, \"%s\", not allowed in file name",
+                    ill_char);
+        }
+            
+        return(error);
+    }
+
+    if((i=is_writable_dir(file)) == 0 || i == 1){
+	sprintf(error, "\"%s\" is a directory", file);
+        return(error);
+    }
+
+    if(ps_global->restricted || ps_global->VAR_OPER_DIR){
+	for(ptr = file; *ptr == ' '; ptr++) ;	/* leading spaces gone */
+
+	if((ptr[0] == '.' && ptr[1] == '.') || srchstr(ptr, "/../")){
+	    sprintf(error, "\"..\" not allowed in filename");
+	    return(error);
+	}
+    }
+
+    return((char *)NULL);
+}
+
+
+/*----------------------------------------------------------------------
+    Check to see if user is allowed to read or write this folder.
+
+   Args:  s  -- the name to check
+ 
+ Result: Returns 1 if OK
+         Returns 0 and posts an error message if access is denied
+  ----*/
+int
+cntxt_allowed(s)
+    char *s;
+{
+    struct variable *vars = ps_global->vars;
+    int retval = 1;
+    MAILSTREAM stream; /* fake stream for error message in mm_notify */
+
+    if(ps_global->restricted
+         && (strindex("./~", s[0]) || srchstr(s, "/../"))){
+	stream.mailbox = s;
+	mm_notify(&stream, "Restricted mode doesn't allow operation", WARN);
+	retval = 0;
+    }
+    else if(VAR_OPER_DIR
+	    && s[0] != '{' && !(s[0] == '*' && s[1] == '{')
+	    && strucmp(s,ps_global->inbox_name) != 0
+	    && strcmp(s, ps_global->VAR_INBOX_PATH) != 0){
+	char *p, *free_this = NULL;
+
+	p = s;
+	if(strindex(s, '~')){
+	    p = strindex(s, '~');
+	    free_this = (char *)fs_get(strlen(p) + 200);
+	    strcpy(free_this, p);
+	    fnexpand(free_this, strlen(p)+200);
+	    p = free_this;
+	}
+	else if(p[0] != '/'){  /* add home dir to relative paths */
+	    free_this = p = (char *)fs_get(strlen(s)
+					    + strlen(ps_global->home_dir) + 2);
+	    build_path(p, ps_global->home_dir, s);
+	}
+	
+	if(!in_dir(VAR_OPER_DIR, p)){
+	    char err[200];
+
+	    sprintf(err, "Not allowed outside of %s", VAR_OPER_DIR);
+	    stream.mailbox = p;
+	    mm_notify(&stream, err, WARN);
+	    retval = 0;
+	}
+	else if(srchstr(p, "/../")){  /* check for .. in path */
+	    stream.mailbox = p;
+	    mm_notify(&stream, "\"..\" not allowed in name", WARN);
+	    retval = 0;
+	}
+
+	if(free_this)
+	  fs_give((void **)&free_this);
+    }
+    
+    return retval;
+}
+
+
+
+#if defined(USE_QUOTAS)
+
+/*----------------------------------------------------------------------
+   This system doesn't have disk quotas.
+   Return space left in disk quota on file system which given path is in.
+
+    Args: path - Path name of file or directory on file system of concern
+          over - pointer to flag that is set if the user is over quota
+
+ Returns: If *over = 0, the number of bytes free in disk quota as per
+          the soft limit.
+	  If *over = 1, the number of bytes *over* quota.
+          -1 is returned on an error looking up quota
+           0 is returned if there is no quota
+
+BUG:  If there's more than 2.1Gb free this function will break
+  ----*/
+long
+disk_quota(path, over)
+    char *path;
+    int  *over;
+{
+    return(0L);
+}
+#endif /* USE_QUOTAS */
+
+
+
+/*----------------------------------------------------------------------
+    Read whole file into memory
+
+  Args: filename -- path name of file to read
+
+  Result: Returns pointer to malloced memory with the contents of the file
+          or NULL
+
+This won't work very well if the file has NULLs in it and is mostly
+intended for fairly small text files.
+ ----*/
+char *
+read_file(filename)
+    char *filename;
+{
+    int         fd;
+    struct stat statbuf;
+    char       *buf;
+    int         nb;
+
+    fd = open(filename, O_RDONLY);
+    if(fd < 0)
+      return((char *)NULL);
+
+    fstat(fd, &statbuf);
+
+    buf = fs_get((size_t)statbuf.st_size + 1);
+
+    /*
+     * On some systems might have to loop here, if one read isn't guaranteed
+     * to get the whole thing.
+     */
+    if((nb = read(fd, buf, (int)statbuf.st_size)) < 0)
+      fs_give((void **)&buf);		/* NULL's buf */
+    else
+      buf[nb] = '\0';
+
+    close(fd);
+    return(buf);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Create a temporary file, the name of which we don't care about 
+and that goes away when it is closed.  Just like ANSI C tmpfile.
+  ----*/
+FILE  *
+create_tmpfile()
+{
+    return(tmpfile());
+}
+
+
+
+/*----------------------------------------------------------------------
+     Abort with a core dump
+ ----*/
+void
+coredump()
+{
+    abort();
+}
+
+
+
+/*----------------------------------------------------------------------
+       Call system gethostname
+
+  Args: hostname -- buffer to return host name in 
+        size     -- Size of buffer hostname is to be returned in
+
+ Result: returns 0 if the hostname is correctly set,
+         -1 if not (and errno is set).
+ ----*/
+hostname(hostname,size) 
+    char *hostname;
+    int size;
+{
+    return(gethostname(hostname, size));
+}
+
+
+
+/*----------------------------------------------------------------------
+       Get the current host and domain names
+
+    Args: hostname   -- buffer to return the hostname in
+          hsize      -- size of buffer above
+          domainname -- buffer to return domain name in
+          dsize      -- size of buffer above
+
+  Result: The system host and domain names are returned. If the full host
+          name is akbar.cac.washington.edu then the domainname is
+          cac.washington.edu.
+
+On Internet connected hosts this look up uses /etc/hosts and DNS to
+figure all this out. On other less well connected machines some other
+file may be read. If there is no notion of a domain name the domain
+name may be left blank. On a PC where there really isn't a host name
+this should return blank strings. The .pinerc will take care of
+configuring the domain names. That is, this should only return the
+native system's idea of what the names are if the system has such
+a concept.
+ ----*/
+void
+getdomainnames(hostname, hsize, domainname, dsize)
+    char *hostname, *domainname;
+    int   hsize, dsize;
+{
+    char           *dn, hname[MAX_ADDRESS+1];
+    struct hostent *he;
+    char          **alias;
+    char           *maybe = NULL;
+
+    gethostname(hname, MAX_ADDRESS);
+    he = gethostbyname(hname);
+    hostname[0] = '\0';
+
+    if(he == NULL)
+      strncpy(hostname, hname, hsize-1);
+    else{
+	/*
+	 * If no dot in hostname it may be the case that there
+	 * is an alias which is really the fully-qualified
+	 * hostname. This could happen if the administrator has
+	 * (incorrectly) put the unqualified name first in the
+	 * hosts file, for example. The problem with looking for
+	 * an alias with a dot is that now we're guessing, since
+	 * the aliases aren't supposed to be the official hostname.
+	 * We'll compromise and only use an alias if the primary
+	 * name has no dot and exactly one of the aliases has a
+	 * dot.
+	 */
+	strncpy(hostname, he->h_name, hsize-1);
+	if(strindex(hostname, '.') == NULL){		/* no dot in hostname */
+	    for(alias = he->h_aliases; *alias; alias++){
+		if(strindex(*alias, '.') != NULL){	/* found one */
+		    if(maybe){		/* oops, this is the second one */
+			maybe = NULL;
+			break;
+		    }
+		    else
+		      maybe = *alias;
+		}
+	    }
+
+	    if(maybe)
+	      strncpy(hostname, maybe, hsize-1);
+	}
+    }
+
+    hostname[hsize-1] = '\0';
+
+
+    if((dn = strindex(hostname, '.')) != NULL)
+      strncpy(domainname, dn+1, dsize-1);
+    else
+      strncpy(domainname, hostname, dsize-1);
+
+    domainname[dsize-1] = '\0';
+}
+
+
+
+/*----------------------------------------------------------------------
+       Return canonical form of host name ala c-client (UNIX version).
+
+   Args: host      -- The host name
+
+ Result: Canonical form, or input argument (worst case)
+ ----*/
+char *
+canonical_name(host)
+    char *host;
+{
+    struct hostent *hent;
+    char hostname[MAILTMPLEN];
+    char tmp[MAILTMPLEN];
+    extern char *lcase();
+                                /* domain literal is easy */
+    if (host[0] == '[' && host[(strlen (host))-1] == ']')
+      return host;
+
+    strcpy (hostname,host);       /* UNIX requires lowercase */
+                                /* lookup name, return canonical form */
+    return (hent = gethostbyname (lcase (strcpy (tmp,host)))) ?
+      hent->h_name : host;
+}
+
+
+
+/*----------------------------------------------------------------------
+     This routine returns 1 if job control is available.  Note, thiis
+     could be some type of fake job control.  It doesn't have to be
+     real BSD-style job control.
+  ----*/
+have_job_control()
+{
+    return 1;
+}
+
+
+/*----------------------------------------------------------------------
+    If we don't have job control, this routine is never called.
+  ----*/
+stop_process()
+{
+    SigType (*save_usr2) SIG_PROTO((int));
+    
+    /*
+     * Since we can't respond to KOD while stopped, the process that sent 
+     * the KOD is going to go read-only.  Therefore, we can safely ignore
+     * any KODs that come in before we are ready to respond...
+     */
+    save_usr2 = signal(SIGUSR2, SIG_IGN);
+    kill(0, SIGSTOP); 
+    (void)signal(SIGUSR2, save_usr2);
+}
+
+
+
+/*----------------------------------------------------------------------
+       Return string describing the error
+
+   Args: errnumber -- The system error number (errno)
+
+ Result:  long string describing the error is returned
+  ----*/
+char *
+error_description(errnumber)
+    int errnumber;
+{
+    static char buffer[50+1];
+
+    if(errnumber >= 0 && errnumber < sys_nerr)
+      sprintf(buffer, "%.*s", 50, sys_errlist[errnumber]);
+    else
+      sprintf(buffer, "Unknown error #%d", errnumber);
+
+    return ( (char *) buffer);
+}
+
+
+
+/*----------------------------------------------------------------------
+      Pull the name out of the gcos field if we have that sort of /etc/passwd
+
+   Args: gcos_field --  The long name or GCOS field to be parsed
+         logname    --  Replaces occurances of & with logname string
+
+ Result: returns pointer to buffer with name
+  ----*/
+static char *
+gcos_name(gcos_field, logname)
+    char *logname, *gcos_field;
+{
+    static char fullname[MAX_FULLNAME+1];
+    register char *fncp, *gcoscp, *lncp, *end;
+
+    /* full name is all chars up to first ',' (or whole gcos, if no ',') */
+    /* replace any & with logname in upper case */
+
+    for(fncp = fullname, gcoscp= gcos_field, end = fullname + MAX_FULLNAME - 1;
+        (*gcoscp != ',' && *gcoscp != '\0' && fncp != end);
+	gcoscp++) {
+
+	if(*gcoscp == '&') {
+	    for(lncp = logname; *lncp; fncp++, lncp++)
+		*fncp = toupper((unsigned char)(*lncp));
+	} else {
+	    *fncp++ = *gcoscp;
+	}
+    }
+    
+    *fncp = '\0';
+    return(fullname);
+}
+
+
+/*----------------------------------------------------------------------
+      Fill in homedir, login, and fullname for the logged in user.
+      These are all pointers to static storage so need to be copied
+      in the caller.
+
+ Args: ui    -- struct pointer to pass back answers
+
+ Result: fills in the fields
+  ----*/
+void
+get_user_info(ui)
+    struct user_info *ui;
+{
+    struct passwd *unix_pwd;
+
+    unix_pwd = getpwuid(getuid());
+    if(unix_pwd == NULL) {
+      ui->homedir = cpystr("");
+      ui->login = cpystr("");
+      ui->fullname = cpystr("");
+    }else {
+      ui->homedir = cpystr(unix_pwd->pw_dir);
+      ui->login = cpystr(unix_pwd->pw_name);
+      ui->fullname = cpystr(gcos_name(unix_pwd->pw_gecos, unix_pwd->pw_name));
+    }
+}
+
+
+/*----------------------------------------------------------------------
+      Look up a userid on the local system and return rfc822 address
+
+ Args: name  -- possible login name on local system
+
+ Result: returns NULL or pointer to alloc'd string rfc822 address.
+  ----*/
+char *
+local_name_lookup(name)
+    char *name;
+{
+    struct passwd *pw = getpwnam(name);
+
+    if(pw == NULL){
+	char *p;
+
+	for(p = name; *p; p++)
+	  if(isupper((unsigned char)*p))
+	    break;
+
+	/* try changing it to all lower case */
+	if(p && *p){
+	    char *lcase;
+
+	    lcase = cpystr(name);
+	    for(p = lcase; *p; p++)
+	      if(isupper((unsigned char)*p))
+		*p = tolower((unsigned char)*p);
+
+	    pw = getpwnam(lcase);
+
+	    if(pw)
+	      strcpy(name, lcase);
+
+	    fs_give((void **)&lcase);
+	}
+    }
+
+    if(pw == NULL)
+      return((char *)NULL);
+
+    return(cpystr(gcos_name(pw->pw_gecos, name)));
+}
+
+
+
+/*----------------------------------------------------------------------
+       Call the system to change the passwd
+ 
+It would be nice to talk to the passwd program via a pipe or ptty so the
+user interface could be consistent, but we can't count on the the prompts
+and responses from the passwd program to be regular so we just let the user 
+type at the passwd program with some screen space, hope he doesn't scroll 
+off the top and repaint when he's done.
+ ----*/        
+change_passwd()
+{
+    char cmd_buf[100];
+
+    ClearLines(1, ps_global->ttyo->screen_rows - 1);
+
+    MoveCursor(5, 0);
+    fflush(stdout);
+
+    PineRaw(0);
+    strcpy(cmd_buf, PASSWD_PROG);
+    system(cmd_buf);
+    sleep(3);
+    PineRaw(1);
+}
+
+
+
+/*----------------------------------------------------------------------
+       Can we display this type/subtype?
+
+   Args: type       -- the MIME type to check
+         subtype    -- the MIME subtype
+         params     -- parameters
+	 use_viewer -- tell caller he should run external viewer cmd to view
+
+ Result: Returns:
+
+	 MCD_NONE	if we can't display this type at all
+	 MCD_INTERNAL	if we can display it internally
+	 MCD_EXTERNAL	if it can be displayed via an external viewer
+
+ ----*/
+mime_can_display(type, subtype, params)
+    int       type;
+    char      *subtype;
+    PARAMETER *params;
+{
+    return((mailcap_can_display(type, subtype, params)
+	      ? MCD_EXTERNAL : MCD_NONE)
+	   | ((type == TYPETEXT || type == TYPEMESSAGE
+	       || MIME_VCARD(type,subtype))
+	        ? MCD_INTERNAL : MCD_NONE));
+}
+
+
+
+/*======================================================================
+    pipe
+    
+    Initiate I/O to and from a process.  These functions are similar to 
+    popen and pclose, but both an incoming stream and an output file are 
+    provided.
+   
+ ====*/
+
+#ifndef	STDIN_FILENO
+#define	STDIN_FILENO	0
+#endif
+#ifndef	STDOUT_FILENO
+#define	STDOUT_FILENO	1
+#endif
+#ifndef	STDERR_FILENO
+#define	STDERR_FILENO	2
+#endif
+
+
+/*
+ * Defs to help fish child's exit status out of wait(2)
+ */
+#ifdef	HAVE_WAIT_UNION
+#define WaitType	union wait
+#ifndef	WIFEXITED
+#define	WIFEXITED(X)	(!(X).w_termsig)	/* child exit by choice */
+#endif
+#ifndef	WEXITSTATUS
+#define	WEXITSTATUS(X)	(X).w_retcode		/* childs chosen exit value */
+#endif
+#else
+#define	WaitType	int
+#ifndef	WIFEXITED
+#define	WIFEXITED(X)	(!((X) & 0xff))		/* low bits tell how it died */
+#endif
+#ifndef	WEXITSTATUS
+#define	WEXITSTATUS(X)	(((X) >> 8) & 0xff)	/* high bits tell exit value */
+#endif
+#endif
+
+
+/*
+ * Global's to helpsignal handler tell us child's status has changed...
+ */
+short	child_signalled;
+short	child_jump = 0;
+jmp_buf child_state;
+int	child_pid;
+
+
+/*
+ * Internal Protos
+ */
+void pipe_error_cleanup PROTO((PIPE_S **, char *, char *, char *));
+void zot_pipe PROTO((PIPE_S **));
+static SigType pipe_alarm SIG_PROTO((int));
+
+
+
+
+/*----------------------------------------------------------------------
+     Spawn a child process and optionally connect read/write pipes to it
+
+  Args: command -- string to hand the shell
+	outfile -- address of pointer containing file to receive output
+	errfile -- address of pointer containing file to receive error output
+	mode -- mode for type of shell, signal protection etc...
+  Returns: pointer to alloc'd PIPE_S on success, NULL otherwise
+
+  The outfile is either NULL, a pointer to a NULL value, or a pointer
+  to the requested name for the output file.  In the pointer-to-NULL case
+  the caller doesn't care about the name, but wants to see the pipe's
+  results so we make one up.  It's up to the caller to make sure the
+  free storage containing the name is cleaned up.
+
+  Mode bits serve several purposes.
+    PIPE_WRITE tells us we need to open a pipe to write the child's
+	stdin.
+    PIPE_READ tells us we need to open a pipe to read from the child's
+	stdout/stderr.  *NOTE*  Having neither of the above set means 
+	we're not setting up any pipes, just forking the child and exec'ing
+	the command.  Also, this takes precedence over any named outfile.
+    PIPE_STDERR means we're to tie the childs stderr to the same place
+	stdout is going.  *NOTE* This only makes sense then if PIPE_READ
+	or an outfile is provided.  Also, this takes precedence over any
+	named errfile.
+    PIPE_PROT means to protect the child from the usual nasty signals
+	that might cause premature death.  Otherwise, the default signals are
+	set so the child can deal with the nasty signals in its own way.     
+    PIPE_NOSHELL means we're to exec the command without the aid of
+	a system shell.  *NOTE* This negates the affect of PIPE_USER.
+    PIPE_USER means we're to try executing the command in the user's
+	shell.  Right now we only look in the environment, but that may get
+	more sophisticated later.
+    PIPE_RESET means we reset the terminal mode to what it was before
+	we started pine and then exec the command.
+ ----*/
+PIPE_S *
+open_system_pipe(command, outfile, errfile, mode, timeout)
+    char  *command;
+    char **outfile, **errfile;
+    int    mode, timeout;
+{
+    PIPE_S *syspipe = NULL;
+    char    shellpath[32], *shell;
+    int     p[2], oparentd = -1, ochildd = -1, iparentd = -1, ichildd = -1;
+
+    dprint(5, (debugfile, "Opening pipe: \"%s\" (%s%s%s%s%s%s)\n", command,
+	       (mode & PIPE_WRITE)   ? "W":"", (mode & PIPE_READ)  ? "R":"",
+	       (mode & PIPE_NOSHELL) ? "N":"", (mode & PIPE_PROT)  ? "P":"",
+	       (mode & PIPE_USER)    ? "U":"", (mode & PIPE_RESET) ? "T":""));
+
+    syspipe = (PIPE_S *)fs_get(sizeof(PIPE_S));
+    memset(syspipe, 0, sizeof(PIPE_S));
+
+    /*
+     * If we're not using the shell's command parsing smarts, build
+     * argv by hand...
+     */
+    if(mode & PIPE_NOSHELL){
+	char   **ap, *p;
+	size_t   n;
+
+	/* parse the arguments into argv */
+	for(p = command; *p && isspace((unsigned char)(*p)); p++)
+	  ;					/* swallow leading ws */
+
+	if(*p){
+	    syspipe->args = cpystr(p);
+	}
+	else{
+	    pipe_error_cleanup(&syspipe, "<null>", "execute",
+			       "No command name found");
+	    return(NULL);
+	}
+
+	for(p = syspipe->args, n = 2; *p; p++)	/* count the args */
+	  if(isspace((unsigned char)(*p))
+	     && *(p+1) && !isspace((unsigned char)(*(p+1))))
+	    n++;
+
+	syspipe->argv = ap = (char **)fs_get(n * sizeof(char *));
+	memset(syspipe->argv, 0, n * sizeof(char *));
+
+	for(p = syspipe->args; *p; ){		/* collect args */
+	    while(*p && isspace((unsigned char)(*p)))
+	      *p++ = '\0';
+
+	    *ap++ = (*p) ? p : NULL;
+	    while(*p && !isspace((unsigned char)(*p)))
+	      p++;
+	}
+
+	/* make sure argv[0] exists in $PATH */
+	if(can_access_in_path(getenv("PATH"), syspipe->argv[0],
+			      EXECUTE_ACCESS) < 0){
+	    pipe_error_cleanup(&syspipe, syspipe->argv[0], "access",
+			       error_description(errno));
+	    return(NULL);
+	}
+    }
+
+    /* fill in any output filenames */
+    if(!(mode & PIPE_READ)){
+	if(outfile && !*outfile)
+	  *outfile = temp_nam(NULL, "pine_p");	/* asked for, but not named? */
+
+	if(errfile && !*errfile)
+	  *errfile = temp_nam(NULL, "pine_p");	/* ditto */
+    }
+
+    /* create pipes */
+    if(mode & (PIPE_WRITE | PIPE_READ)){
+	if(mode & PIPE_WRITE){
+	    pipe(p);				/* alloc pipe to write child */
+	    oparentd = p[STDOUT_FILENO];
+	    ichildd  = p[STDIN_FILENO];
+	}
+
+	if(mode & PIPE_READ){
+	    pipe(p);				/* alloc pipe to read child */
+	    iparentd = p[STDIN_FILENO];
+	    ochildd  = p[STDOUT_FILENO];
+	}
+    }
+    else if(!(mode & PIPE_SILENT)){
+	flush_status_messages(0);		/* just clean up display */
+	ClearScreen();
+	fflush(stdout);
+    }
+
+    if((syspipe->mode = mode) & PIPE_RESET)
+      PineRaw(0);
+
+#ifdef	SIGCHLD
+    /*
+     * Prepare for demise of child.  Use SIGCHLD if it's available so
+     * we can do useful things, like keep the IMAP stream alive, while
+     * we're waiting on the child.
+     */
+    child_signalled = child_jump = 0;
+#endif
+
+    if((syspipe->pid = vfork()) == 0){
+ 	/* reset child's handlers in requested fashion... */
+	(void)signal(SIGINT,  (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
+	(void)signal(SIGQUIT, (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
+	(void)signal(SIGHUP,  (mode & PIPE_PROT) ? SIG_IGN : SIG_DFL);
+#ifdef	SIGCHLD
+	(void) signal(SIGCHLD,  SIG_DFL);
+#endif
+
+	/* if parent isn't reading, and we have a filename to write */
+	if(!(mode & PIPE_READ) && outfile){	/* connect output to file */
+	    int output = creat(*outfile, 0600);
+	    dup2(output, STDOUT_FILENO);
+	    if(mode & PIPE_STDERR)
+	      dup2(output, STDERR_FILENO);
+	    else if(errfile)
+	      dup2(creat(*errfile, 0600), STDERR_FILENO);
+	}
+
+	if(mode & PIPE_WRITE){			/* connect process input */
+	    close(oparentd);
+	    dup2(ichildd, STDIN_FILENO);	/* tie stdin to pipe */
+	    close(ichildd);
+	}
+
+	if(mode & PIPE_READ){			/* connect process output */
+	    close(iparentd);
+	    dup2(ochildd, STDOUT_FILENO);	/* tie std{out,err} to pipe */
+	    if(mode & PIPE_STDERR)
+	      dup2(ochildd, STDERR_FILENO);
+	    else if(errfile)
+	      dup2(creat(*errfile, 0600), STDERR_FILENO);
+
+	    close(ochildd);
+	}
+
+	if(mode & PIPE_NOSHELL){
+	    execvp(syspipe->argv[0], syspipe->argv);
+	}
+	else{
+	    if(mode & PIPE_USER){
+		char *env, *sh;
+		if((env = getenv("SHELL")) && (sh = strrchr(env, '/'))){
+		    shell = sh + 1;
+		    strcpy(shellpath, env);
+		}
+		else{
+		    shell = "csh";
+		    strcpy(shellpath, "/bin/csh");
+		}
+	    }
+	    else{
+		shell = "sh";
+		strcpy(shellpath, "/bin/sh");
+	    }
+
+	    execl(shellpath, shell, command ? "-c" : 0, command, 0);
+	}
+
+	fprintf(stderr, "Can't exec %s\nReason: %s",
+		command, error_description(errno));
+	_exit(-1);
+    }
+
+    if((child_pid = syspipe->pid) > 0){
+	syspipe->isig = signal(SIGINT,  SIG_IGN); /* Reset handlers to make */
+	syspipe->qsig = signal(SIGQUIT, SIG_IGN); /* sure we don't come to  */
+	syspipe->hsig = signal(SIGHUP,  SIG_IGN); /* a premature end...     */
+	if((syspipe->timeout = timeout) != 0){
+	    syspipe->alrm      = signal(SIGALRM,  pipe_alarm);
+	    syspipe->old_timeo = alarm(timeout);
+	}
+
+	if(mode & PIPE_WRITE){
+	    close(ichildd);
+	    if(mode & PIPE_DESC)
+	      syspipe->out.d = oparentd;
+	    else
+	      syspipe->out.f = fdopen(oparentd, "w");
+	}
+
+	if(mode & PIPE_READ){
+	    close(ochildd);
+	    if(mode & PIPE_DESC)
+	      syspipe->in.d = iparentd;
+	    else
+	      syspipe->in.f = fdopen(iparentd, "r");
+	}
+
+	dprint(5, (debugfile, "PID: %d, COMMAND: %s\n",syspipe->pid,command));
+    }
+    else{
+	if(mode & (PIPE_WRITE | PIPE_READ)){
+	    if(mode & PIPE_WRITE){
+		close(oparentd);
+		close(ichildd);
+	    }
+
+	    if(mode & PIPE_READ){
+		close(iparentd);
+		close(ochildd);
+	    }
+	}
+	else if(!(mode & PIPE_SILENT)){
+	    ClearScreen();
+	    ps_global->mangled_screen = 1;
+	}
+
+	if(mode & PIPE_RESET)
+	  PineRaw(1);
+
+#ifdef	SIGCHLD
+	(void) signal(SIGCHLD,  SIG_DFL);
+#endif
+	if(outfile)
+	  fs_give((void **) outfile);
+
+	pipe_error_cleanup(&syspipe, command, "fork",error_description(errno));
+    }
+
+    return(syspipe);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Write appropriate error messages and cleanup after pipe error
+
+  Args: syspipe -- address of pointer to struct to clean up
+	cmd -- command we were trying to exec
+	op -- operation leading up to the exec
+	res -- result of that operation
+
+ ----*/
+void
+pipe_error_cleanup(syspipe, cmd, op, res)
+    PIPE_S **syspipe;
+    char    *cmd, *op, *res;
+{
+    q_status_message3(SM_ORDER, 3, 3, "Pipe can't %s \"%.20s\": %s",
+		      op, cmd, res);
+    dprint(1, (debugfile, "* * PIPE CAN'T %s(%s): %s\n", op, cmd, res));
+    zot_pipe(syspipe);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Free resources associated with the given pipe struct
+
+  Args: syspipe -- address of pointer to struct to clean up
+
+ ----*/
+void
+zot_pipe(syspipe)
+    PIPE_S **syspipe;
+{
+    if((*syspipe)->args)
+      fs_give((void **) &(*syspipe)->args);
+
+    if((*syspipe)->argv)
+      fs_give((void **) &(*syspipe)->argv);
+
+    if((*syspipe)->tmp)
+      fs_give((void **) &(*syspipe)->tmp);
+
+    fs_give((void **)syspipe);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Close pipe previously allocated and wait for child's death
+
+  Args: syspipe -- address of pointer to struct returned by open_system_pipe
+  Returns: returns exit status of child or -1 if invalid syspipe
+ ----*/
+int
+close_system_pipe(syspipe)
+    PIPE_S **syspipe;
+{
+    WaitType stat;
+    int	     status;
+
+    if(!(syspipe && *syspipe))
+      return(-1);
+
+    if(((*syspipe)->mode) & PIPE_WRITE){
+	if(((*syspipe)->mode) & PIPE_DESC){
+	    if((*syspipe)->out.d >= 0)
+	      close((*syspipe)->out.d);
+	}
+	else if((*syspipe)->out.f)
+	  fclose((*syspipe)->out.f);
+    }
+
+    if(((*syspipe)->mode) & PIPE_READ){
+	if(((*syspipe)->mode) & PIPE_DESC){
+	    if((*syspipe)->in.d >= 0)
+	      close((*syspipe)->in.d);
+	}
+	else if((*syspipe)->in.f)
+	  fclose((*syspipe)->in.f);
+    }
+
+#ifdef	SIGCHLD
+    {
+	SigType (*alarm_sig)();
+	int	old_cue = F_ON(F_SHOW_DELAY_CUE, ps_global);
+
+	/*
+	 * remember the current SIGALRM handler, and make sure it's
+	 * installed when we're finished just in case the longjmp
+	 * out of the SIGCHLD handler caused sleep() to lose it.
+	 * Don't pay any attention to that man behind the curtain.
+	 */
+	alarm_sig = signal(SIGALRM, SIG_IGN);
+	F_SET(F_SHOW_DELAY_CUE, ps_global, 0);
+	ps_global->noshow_timeout = 1;
+	while(!child_signalled){
+	    /* wake up and prod server */
+	    new_mail(0, 2, ((*syspipe)->mode & PIPE_RESET)
+			      ? NM_NONE : NM_DEFER_SORT);
+
+	    if(!child_signalled){
+		if(setjmp(child_state) == 0){
+		    child_jump = 1;	/* prepare to wake up */
+		    sleep(600);		/* give it 5mins to happend */
+		}
+		else
+		  our_sigunblock(SIGCHLD);
+	    }
+
+	    child_jump = 0;
+	}
+
+	ps_global->noshow_timeout = 0;
+	F_SET(F_SHOW_DELAY_CUE, ps_global, old_cue);
+	(void) signal(SIGALRM, alarm_sig);
+    }
+#endif
+
+    /*
+     * Call c-client's pid reaper to wait() on the demise of our child,
+     * then fish out its exit status...
+     */
+    grim_pid_reap_status((*syspipe)->pid, 0, &stat);
+    status = WIFEXITED(stat) ? WEXITSTATUS(stat) : -1;
+
+    /*
+     * restore original handlers...
+     */
+    (void)signal(SIGINT,  (*syspipe)->isig);
+    (void)signal(SIGHUP,  (*syspipe)->hsig);
+    (void)signal(SIGQUIT, (*syspipe)->qsig);
+
+    if((*syspipe)->timeout){
+	(void)signal(SIGALRM, (*syspipe)->alrm);
+	alarm((*syspipe)->old_timeo);
+	child_pid = 0;
+    }
+
+    if((*syspipe)->mode & PIPE_RESET)		/* restore our tty modes */
+      PineRaw(1);
+
+    if(!((*syspipe)->mode & (PIPE_WRITE | PIPE_READ | PIPE_SILENT))){
+	ClearScreen();				/* No I/O to forked child */
+	ps_global->mangled_screen = 1;
+    }
+
+    zot_pipe(syspipe);
+
+    return(status);
+}
+
+
+
+static SigType
+pipe_alarm SIG_PROTO((int sig))
+{
+    if(child_pid)
+      kill(child_pid, SIGINT);
+}
+
+/*======================================================================
+    post_reap
+    
+    Manage exit status collection of a child spawned to handle posting
+ ====*/
+
+
+
+#if	defined(BACKGROUND_POST) && defined(SIGCHLD)
+/*----------------------------------------------------------------------
+    Check to see if we have any posting processes to clean up after
+
+  Args: none
+  Returns: any finished posting process reaped
+ ----*/
+post_reap()
+{
+    WaitType stat;
+    int	     r;
+
+    if(ps_global->post && ps_global->post->pid){
+	r = waitpid(ps_global->post->pid, &stat, WNOHANG);
+	if(r == ps_global->post->pid){
+	    ps_global->post->status = WIFEXITED(stat) ? WEXITSTATUS(stat) : -1;
+	    ps_global->post->pid = 0;
+	    return(1);
+	}
+	else if(r < 0 && errno != EINTR){ /* pid's become bogus?? */
+	    fs_give((void **) &ps_global->post);
+	}
+    }
+
+    return(0);
+}
+#endif
+
+/*----------------------------------------------------------------------
+    Routines used to hand off messages to local agents for sending/posting
+
+ The two exported routines are:
+
+    1) smtp_command()  -- used to get local transport agent to invoke
+    2) post_handoff()  -- used to pass messages to local posting agent
+
+ ----*/
+
+
+
+/*
+ * Protos for "sendmail" internal functions
+ */
+static char *mta_parse_post PROTO((METAENV *, BODY *, char *, char *));
+static long  pine_pipe_soutr_nl PROTO((void *, char *));
+
+
+
+/* ----------------------------------------------------------------------
+   Figure out command to start local SMTP agent
+
+  Args: errbuf   -- buffer for reporting errors (assumed non-NULL)
+
+  Returns an alloc'd copy of the local SMTP agent invocation or NULL
+
+  ----*/
+char *
+smtp_command(errbuf)
+    char *errbuf;
+{
+#if	defined(SENDMAIL) && defined(SENDMAILFLAGS)
+    char tmp[256];
+
+    sprintf(tmp, "%s %s", SENDMAIL, SENDMAILFLAGS);
+    return(cpystr(tmp));
+#else
+    strcpy(errbuf, "No default posting command.");
+    return(NULL);
+#endif
+}
+
+
+
+/*----------------------------------------------------------------------
+   Hand off given message to local posting agent
+
+  Args: envelope -- The envelope for the BCC and debugging
+        header   -- The text of the message header
+        errbuf   -- buffer for reporting errors (assumed non-NULL)
+     
+   ----*/
+int
+mta_handoff(header, body, errbuf)
+    METAENV    *header;
+    BODY       *body;
+    char       *errbuf;
+{
+    char cmd_buf[256], *cmd = NULL;
+
+    /*
+     * A bit of complicated policy implemented here.
+     * There are two posting variables sendmail-path and smtp-server.
+     * Precedence is in that order.
+     * They can be set one of 4 ways: fixed, command-line, user, or globally.
+     * Precedence is in that order.
+     * Said differently, the order goes something like what's below.
+     * 
+     * NOTE: the fixed/command-line/user precendence handling is also
+     *	     indicated by what's pointed to by ps_global->VAR_*, but since
+     *	     that also includes the global defaults, it's not sufficient.
+     */
+
+    if(ps_global->FIX_SENDMAIL_PATH
+       && ps_global->FIX_SENDMAIL_PATH[0]){
+	cmd = ps_global->FIX_SENDMAIL_PATH;
+    }
+    else if(!(ps_global->FIX_SMTP_SERVER
+	      && ps_global->FIX_SMTP_SERVER[0])){
+	if(ps_global->COM_SENDMAIL_PATH
+	   && ps_global->COM_SENDMAIL_PATH[0]){
+	    cmd = ps_global->COM_SENDMAIL_PATH;
+	}
+	else if(!(ps_global->COM_SMTP_SERVER
+		  && ps_global->COM_SMTP_SERVER[0])){
+	    if(ps_global->USR_SENDMAIL_PATH
+	       && ps_global->USR_SENDMAIL_PATH[0]){
+		cmd = ps_global->USR_SENDMAIL_PATH;
+	    }
+	    else if(!(ps_global->USR_SMTP_SERVER
+		      && ps_global->USR_SMTP_SERVER[0])){
+		if(ps_global->GLO_SENDMAIL_PATH
+		   && ps_global->GLO_SENDMAIL_PATH[0]){
+		    cmd = ps_global->GLO_SENDMAIL_PATH;
+		}
+#ifdef	DF_SENDMAIL_PATH
+		/*
+		 * This defines the default method of posting.  So,
+		 * unless we're told otherwise use it...
+		 */
+		else if(!(ps_global->GLO_SMTP_SERVER
+			  && ps_global->GLO_SMTP_SERVER[0])){
+		    strcpy(cmd = cmd_buf, DF_SENDMAIL_PATH);
+		}
+#endif
+	    }
+	}
+    }
+
+    *errbuf = '\0';
+    if(cmd){
+	dprint(4, (debugfile, "call_mailer via cmd: %s\n", cmd));
+
+	(void) mta_parse_post(header, body, cmd, errbuf);
+	return(1);
+    }
+    else
+      return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Hand off given message to local posting agent
+
+  Args: envelope -- The envelope for the BCC and debugging
+        header   -- The text of the message header
+        errbuf   -- buffer for reporting errors (assumed non-NULL)
+     
+  Fork off mailer process and pipe the message into it
+  Called to post news via Inews when NNTP is unavailable
+  
+   ----*/
+char *
+post_handoff(header, body, errbuf)
+    METAENV    *header;
+    BODY       *body;
+    char       *errbuf;
+{
+    char *err = NULL;
+#ifdef	SENDNEWS
+    char *s;
+
+    if(s = strstr(header->env->date," (")) /* fix the date format for news */
+      *s = '\0';
+
+    if(err = mta_parse_post(header, body, SENDNEWS, errbuf))
+      sprintf(err = errbuf, "News not posted: \"%s\": %s", SENDNEWS, err);
+
+    if(s)
+      *s = ' ';				/* restore the date */
+
+#else /* !SENDNEWS */  /* this is the default case */
+    sprintf(err = errbuf, "Can't post, NNTP-server must be defined!");
+#endif /* !SENDNEWS */
+    return(err);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Hand off message to local MTA; it parses recipients from 822 header
+
+  Args: header -- struct containing header data
+        body  -- struct containing message body data
+	cmd -- command to use for handoff (%s says where file should go)
+	errs -- pointer to buf to hold errors
+
+   ----*/
+static char *
+mta_parse_post(header, body, cmd, errs)
+    METAENV *header;
+    BODY    *body;
+    char    *cmd;
+    char    *errs;
+{
+    char   *result = NULL;
+    PIPE_S *pipe;
+
+    dprint(1, (debugfile, "=== mta_parse_post(%s) ===\n", cmd));
+
+    if(pipe = open_system_pipe(cmd, &result, NULL,
+		 PIPE_STDERR|PIPE_WRITE|PIPE_PROT|PIPE_NOSHELL|PIPE_DESC, 0)){
+	if(!pine_rfc822_output(header, body, pine_pipe_soutr_nl,
+			       (TCPSTREAM *) pipe))
+	  strcpy(errs, "Error posting.");
+
+	if(close_system_pipe(&pipe) && !*errs){
+	    sprintf(errs, "Posting program %s returned error", cmd);
+	    if(result)
+	      display_output_file(result, "POSTING ERRORS", errs, 1);
+	}
+    }
+    else
+      sprintf(errs, "Error running \"%s\"", cmd);
+
+    if(result){
+	unlink(result);
+	fs_give((void **)&result);
+    }
+
+    return(*errs ? errs : NULL);
+}
+
+
+/* 
+ * pine_pipe_soutr - Replacement for tcp_soutr that writes one of our
+ *		     pipes rather than a tcp stream
+ */
+static long
+pine_pipe_soutr_nl (stream,s)
+     void *stream;
+     char *s;
+{
+    long    rv = T;
+    char   *p;
+    size_t  n;
+
+    while(*s && rv){
+	if(n = (p = strstr(s, "\015\012")) ? p - s : strlen(s))
+	  while((rv = write(((PIPE_S *)stream)->out.d, s, n)) != n)
+	    if(rv < 0){
+		if(errno != EINTR){
+		    rv = 0;
+		    break;
+		}
+	    }
+	    else{
+		s += rv;
+		n -= rv;
+	    }
+
+	if(p && rv){
+	    s = p + 2;			/* write UNIX EOL */
+	    while((rv = write(((PIPE_S *)stream)->out.d,"\n",1)) != 1)
+	      if(rv < 0 && errno != EINTR){
+		  rv = 0;
+		  break;
+	      }
+	}
+	else
+	  break;
+    }
+
+    return(rv);
+}
+
+/* ----------------------------------------------------------------------
+   Execute the given mailcap command
+
+  Args: cmd           -- the command to execute
+	image_file    -- the file the data is in
+	needsterminal -- does this command want to take over the terminal?
+  ----*/
+void
+exec_mailcap_cmd(cmd, image_file, needsterminal)
+char *cmd;
+char *image_file;
+int   needsterminal;
+{
+    char   *command = NULL,
+	   *result_file = NULL,
+	   *p;
+    char  **r_file_h;
+    PIPE_S *syspipe;
+    int     mode;
+
+    p = command = (char *)fs_get((32 + strlen(cmd) + (2*strlen(image_file)))
+			     * sizeof(char));
+    if(!needsterminal)  /* put in background if it doesn't need terminal */
+      *p++ = '(';
+    sprintf(p, "%s ; rm -f %s", cmd, image_file);
+    p += strlen(p);
+    if(!needsterminal){
+	*p++ = ')';
+	*p++ = ' ';
+	*p++ = '&';
+    }
+    *p++ = '\n';
+    *p   = '\0';
+    dprint(9, (debugfile, "exec_mailcap_cmd: command=%s\n", command));
+
+    mode = PIPE_RESET;
+    if(needsterminal == 1)
+      r_file_h = NULL;
+    else{
+	mode       |= PIPE_WRITE | PIPE_STDERR;
+	result_file = temp_nam(NULL, "pine_cmd");
+	r_file_h    = &result_file;
+    }
+
+    if(syspipe = open_system_pipe(command, r_file_h, NULL, mode, 0)){
+	close_system_pipe(&syspipe);
+	if(needsterminal == 1)
+	  q_status_message(SM_ORDER, 0, 4, "VIEWER command completed");
+	else if(needsterminal == 2)
+	  display_output_file(result_file, "VIEWER", " command result", 1);
+	else
+	  display_output_file(result_file, "VIEWER", " command launched", 1);
+    }
+    else
+      q_status_message1(SM_ORDER, 3, 4, "Cannot spawn command : %s", cmd);
+
+    fs_give((void **)&command);
+    if(result_file)
+      fs_give((void **)&result_file);
+}
+
+
+/* ----------------------------------------------------------------------
+   Execute the given mailcap test= cmd
+
+  Args: cmd -- command to execute
+  Returns exit status
+  
+  ----*/
+int
+exec_mailcap_test_cmd(cmd)
+    char *cmd;
+{
+    PIPE_S *syspipe;
+
+    return((syspipe = open_system_pipe(cmd, NULL, NULL, PIPE_SILENT, 0))
+	     ? close_system_pipe(&syspipe) : -1);
+}
+
+
+
+/*======================================================================
+    print routines
+   
+    Functions having to do with printing on paper and forking of spoolers
+
+    In general one calls open_printer() to start printing. One of
+    the little print functions to send a line or string, and then
+    call print_end() when complete. This takes care of forking off a spooler
+    and piping the stuff down it. No handles or anything here because there's
+    only one printer open at a time.
+
+ ====*/
+
+
+
+static char *trailer;  /* so both open and close_printer can see it */
+
+/*----------------------------------------------------------------------
+       Open the printer
+
+  Args: desc -- Description of item to print. Should have one trailing blank.
+
+  Return value: < 0 is a failure.
+		0 a success.
+
+This does most of the work of popen so we can save the standard output of the
+command we execute and send it back to the user.
+  ----*/
+int
+open_printer(desc)
+    char     *desc;
+{
+    char command[201], prompt[200];
+    int  cmd, rc, just_one;
+    char *p, *init, *nick;
+    char aname[100];
+    char *printer;
+    int	 done = 0, i, lastprinter, cur_printer = 0;
+    HelpType help;
+    char   **list;
+    static ESCKEY_S ekey[] = {
+	{'y', 'y', "Y", "Yes"},
+	{'n', 'n', "N", "No"},
+	{ctrl('P'), 10, "^P", "Prev Printer"},
+	{ctrl('N'), 11, "^N", "Next Printer"},
+	{-2,   0,   NULL, NULL},
+	{'c', 'c', "C", "CustomPrint"},
+	{KEY_UP,    10, "", ""},
+	{KEY_DOWN,  11, "", ""},
+	{-1, 0, NULL, NULL}};
+#define PREV_KEY   2
+#define NEXT_KEY   3
+#define CUSTOM_KEY 5
+#define UP_KEY     6
+#define DOWN_KEY   7
+
+    trailer      = NULL;
+    init         = NULL;
+    nick         = NULL;
+    command[200] = '\0';
+
+    if(ps_global->VAR_PRINTER == NULL){
+        q_status_message(SM_ORDER | SM_DING, 3, 5,
+	"No printer has been chosen.  Use SETUP on main menu to make choice.");
+	return(-1);
+    }
+
+    /* Is there just one print command available? */
+    just_one = (ps_global->printer_category!=3&&ps_global->printer_category!=2)
+	       || (ps_global->printer_category == 2
+		   && !(ps_global->VAR_STANDARD_PRINTER
+			&& ps_global->VAR_STANDARD_PRINTER[0]
+			&& ps_global->VAR_STANDARD_PRINTER[1]))
+	       || (ps_global->printer_category == 3
+		   && !(ps_global->VAR_PERSONAL_PRINT_COMMAND
+			&& ps_global->VAR_PERSONAL_PRINT_COMMAND[0]
+			&& ps_global->VAR_PERSONAL_PRINT_COMMAND[1]));
+
+    if(F_ON(F_CUSTOM_PRINT, ps_global))
+      ekey[CUSTOM_KEY].ch = 'c'; /* turn this key on */
+    else
+      ekey[CUSTOM_KEY].ch = -2;  /* turn this key off */
+
+    if(just_one){
+	ekey[PREV_KEY].ch = -2;  /* turn these keys off */
+	ekey[NEXT_KEY].ch = -2;
+	ekey[UP_KEY].ch   = -2;
+	ekey[DOWN_KEY].ch = -2;
+    }
+    else{
+	ekey[PREV_KEY].ch = ctrl('P'); /* turn these keys on */
+	ekey[NEXT_KEY].ch = ctrl('N');
+	ekey[UP_KEY].ch   = KEY_UP;
+	ekey[DOWN_KEY].ch = KEY_DOWN;
+	/*
+	 * count how many printers in list and find the default in the list
+	 */
+	if(ps_global->printer_category == 2)
+	  list = ps_global->VAR_STANDARD_PRINTER;
+	else
+	  list = ps_global->VAR_PERSONAL_PRINT_COMMAND;
+
+	for(i = 0; list[i]; i++)
+	  if(strcmp(ps_global->VAR_PRINTER, list[i]) == 0)
+	    cur_printer = i;
+	
+	lastprinter = i - 1;
+    }
+
+    help = NO_HELP;
+    ps_global->mangled_footer = 1;
+
+    while(!done){
+	if(init)
+	  fs_give((void **)&init);
+
+	if(trailer)
+	  fs_give((void **)&trailer);
+
+	if(just_one)
+	  printer = ps_global->VAR_PRINTER;
+	else
+	  printer = list[cur_printer];
+
+	parse_printer(printer, &nick, &p, &init, &trailer, NULL, NULL);
+	strncpy(command, p, 200);
+	fs_give((void **)&p);
+	sprintf(prompt, "Print %.50s%susing \"%.50s\" ? ",
+		desc ? desc : "",
+		(desc && *desc && desc[strlen(desc) - 1] != ' ') ? " " : "",
+		*nick ? nick : command);
+
+	fs_give((void **)&nick);
+	
+	cmd = radio_buttons(prompt, -FOOTER_ROWS(ps_global),
+				 ekey, 'y', 'x', help, RB_NORM);
+	
+	switch(cmd){
+	  case 'y':
+	    q_status_message1(SM_ORDER, 0, 9,
+		"Printing with command \"%s\"", command);
+	    done++;
+	    break;
+
+	  case 10:
+	    cur_printer = (cur_printer>0)
+				? (cur_printer-1)
+				: lastprinter;
+	    break;
+
+	  case 11:
+	    cur_printer = (cur_printer<lastprinter)
+				? (cur_printer+1)
+				: 0;
+	    break;
+
+	  case 'n':
+	  case 'x':
+	    done++;
+	    break;
+
+	  case 'c':
+	    done++;
+	    break;
+
+	  default:
+	    break;
+	}
+    }
+
+    if(cmd == 'c'){
+	if(init)
+	  fs_give((void **)&init);
+
+	if(trailer)
+	  fs_give((void **)&trailer);
+
+	sprintf(prompt, "Enter custom command : ");
+	command[0] = '\0';
+	rc = 1;
+	help = NO_HELP;
+	while(rc){
+	    int flags = OE_APPEND_CURRENT;
+
+	    rc = optionally_enter(command, -FOOTER_ROWS(ps_global), 0,
+		200, prompt, NULL, help, &flags);
+	    
+	    if(rc == 1){
+		cmd = 'x';
+		rc = 0;
+	    }
+	    else if(rc == 3)
+	      help = (help == NO_HELP) ? h_custom_print : NO_HELP;
+	    else if(rc == 0){
+		removing_trailing_white_space(command);
+		removing_leading_white_space(command);
+		q_status_message1(SM_ORDER, 0, 9,
+		    "Printing with command \"%s\"", command);
+	    }
+	}
+    }
+
+    if(cmd == 'x' || cmd == 'n'){
+	q_status_message(SM_ORDER, 0, 2, "Print cancelled");
+	if(init)
+	  fs_give((void **)&init);
+
+	if(trailer)
+	  fs_give((void **)&trailer);
+
+	return(-1);
+    }
+
+    display_message('x');
+
+    ps_global->print = (PRINT_S *)fs_get(sizeof(PRINT_S));
+    memset(ps_global->print, 0, sizeof(PRINT_S));
+
+    strcat(strcpy(aname, ANSI_PRINTER), "-no-formfeed");
+    if(strucmp(command, ANSI_PRINTER) == 0
+       || strucmp(command, aname) == 0){
+        /*----------- Printer attached to ansi device ---------*/
+        q_status_message(SM_ORDER, 0, 9,
+	    "Printing to attached desktop printer...");
+        display_message('x');
+	xonxoff_proc(1);			/* make sure XON/XOFF used */
+	crlf_proc(1);				/* AND LF->CR xlation */
+        fputs("\033[5i", stdout);
+        ps_global->print->fp = stdout;
+        if(strucmp(command, ANSI_PRINTER) == 0){
+	    /* put formfeed at the end of the trailer string */
+	    if(trailer){
+		int len = strlen(trailer);
+
+		fs_resize((void **)&trailer, len+2);
+		trailer[len] = '\f';
+		trailer[len+1] = '\0';
+	    }
+	    else
+	      trailer = cpystr("\f");
+	}
+    }
+    else{
+        /*----------- Print by forking off a UNIX command ------------*/
+        dprint(4, (debugfile, "Printing using command \"%s\"\n", command));
+	ps_global->print->result = temp_nam(NULL, "pine_prt");
+	if(ps_global->print->pipe = open_system_pipe(command,
+					 &ps_global->print->result, NULL,
+					 PIPE_WRITE | PIPE_STDERR, 0)){
+	    ps_global->print->fp = ps_global->print->pipe->out.f;
+	}
+	else{
+	    fs_give((void **)&ps_global->print->result);
+            q_status_message1(SM_ORDER | SM_DING, 3, 4,
+			      "Error opening printer: %s",
+                              error_description(errno));
+            dprint(2, (debugfile, "Error popening printer \"%s\"\n",
+                      error_description(errno)));
+	    if(init)
+	      fs_give((void **)&init);
+
+	    if(trailer)
+	      fs_give((void **)&trailer);
+	    
+	    return(-1);
+        }
+    }
+
+    ps_global->print->err = 0;
+    if(init){
+	if(*init)
+	  fputs(init, ps_global->print->fp);
+
+	fs_give((void **)&init);
+    }
+
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+     Close printer
+  
+  If we're piping to a spooler close down the pipe and wait for the process
+to finish. If we're sending to an attached printer send the escape sequence.
+Also let the user know the result of the print
+ ----*/
+void
+close_printer()
+{
+    if(trailer){
+	if(*trailer)
+	  fputs(trailer, ps_global->print->fp);
+
+	fs_give((void **)&trailer);
+    }
+
+    if(ps_global->print->fp == stdout) {
+        fputs("\033[4i", stdout);
+        fflush(stdout);
+	if(F_OFF(F_PRESERVE_START_STOP, ps_global))
+	  xonxoff_proc(0);			/* turn off XON/XOFF */
+
+	crlf_proc(0);				/* turn off CF->LF xlantion */
+    } else {
+	(void) close_system_pipe(&ps_global->print->pipe);
+	display_output_file(ps_global->print->result, "PRINT", NULL, 1);
+	fs_give((void **)&ps_global->print->result);
+    }
+
+    fs_give((void **)&ps_global->print);
+
+    q_status_message(SM_ASYNC, 0, 3, "Print command completed");
+    display_message('x');
+}
+
+
+
+/*----------------------------------------------------------------------
+     Print a single character
+
+  Args: c -- char to print
+  Returns: 1 on success, 0 on ps_global->print->err
+ ----*/
+int
+print_char(c)
+    int c;
+{
+    if(!ps_global->print->err && putc(c, ps_global->print->fp) == EOF)
+      ps_global->print->err = 1;
+
+    return(!ps_global->print->err);
+}
+
+
+
+/*----------------------------------------------------------------------
+     Send a line of text to the printer
+
+  Args:  line -- Text to print
+
+  ----*/
+    
+void
+print_text(line)
+    char *line;
+{
+    if(!ps_global->print->err && fputs(line, ps_global->print->fp) == EOF)
+      ps_global->print->err = 1;
+}
+
+
+
+/*----------------------------------------------------------------------
+      printf style formatting with one arg for printer
+
+ Args: line -- The printf control string
+       a1   -- The 1st argument for printf
+ ----*/
+void
+print_text1(line, a1)
+    char *line, *a1;
+{
+    if(!ps_global->print->err
+       && fprintf(ps_global->print->fp, line, a1) < 0)
+      ps_global->print->err = 1;
+}
+
+
+
+/*----------------------------------------------------------------------
+      printf style formatting with one arg for printer
+
+ Args: line -- The printf control string
+       a1   -- The 1st argument for printf
+       a2   -- The 2nd argument for printf
+ ----*/
+void
+print_text2(line, a1, a2)
+    char *line, *a1, *a2;
+{
+    if(!ps_global->print->err
+       && fprintf(ps_global->print->fp, line, a1, a2) < 0)
+      ps_global->print->err = 1;
+}
+
+
+
+/*----------------------------------------------------------------------
+      printf style formatting with one arg for printer
+
+ Args: line -- The printf control string
+       a1   -- The 1st argument for printf
+       a2   -- The 2nd argument for printf
+       a3   -- The 3rd argument for printf
+ ----*/
+void
+print_text3(line, a1, a2, a3)
+    char *line, *a1, *a2, *a3;
+{
+    if(!ps_global->print->err
+       && fprintf(ps_global->print->fp, line, a1, a2, a3) < 0)
+      ps_global->print->err = 1;
+}
+
+#ifdef DEBUG
+/*----------------------------------------------------------------------
+     Initialize debugging - open the debug log file
+
+  Args: none
+
+ Result: opens the debug logfile for dprints
+
+   Opens the file "~/.pine-debug1. Also maintains .pine-debug[2-4]
+   by renaming them each time so the last 4 sessions are saved.
+  ----*/
+void
+init_debug()
+{
+    char nbuf[5];
+    char newfname[MAXPATH+1], filename[MAXPATH+1];
+    int i, fd;
+
+    if(!(debug || ps_global->debug_imap))
+      return;
+
+    for(i = ps_global->debug_nfiles - 1; i > 0; i--){
+        build_path(filename, ps_global->home_dir, DEBUGFILE);
+        strcpy(newfname, filename);
+        sprintf(nbuf, "%d", i);
+        strcat(filename, nbuf);
+        sprintf(nbuf, "%d", i+1);
+        strcat(newfname, nbuf);
+        (void)rename_file(filename, newfname);
+    }
+
+    build_path(filename, ps_global->home_dir, DEBUGFILE);
+    strcat(filename, "1");
+
+    debugfile = NULL;
+    if((fd = open(filename, O_TRUNC|O_RDWR|O_CREAT, 0600)) >= 0)
+      debugfile = fdopen(fd, "w+");
+
+    if(debugfile != NULL){
+	time_t now = time((time_t *)0);
+	if(ps_global->debug_flush)
+	  setbuf(debugfile, NULL);
+
+	if(ps_global->debug_nfiles == 0){
+	    /*
+	     * If no debug files are asked for, make filename a tempfile
+	     * to be used for a record should pine later crash...
+	     */
+	    if(debug < 9 && !ps_global->debug_flush && ps_global->debug_imap<4)
+	      unlink(filename);
+	}
+
+	dprint(0, (debugfile,
+  "Debug output of the Pine program (debug=%d debug_imap=%d). Version %s\n%s\n",
+	       debug, ps_global->debug_imap, pine_version, ctime(&now)));
+    }
+}
+
+
+/*----------------------------------------------------------------------
+     Try to save the debug file if we crash in a controlled way
+
+  Args: dfile:  pointer to open debug file
+
+ Result: tries to move the appropriate .pine-debugx file to .pine-crash
+
+   Looks through the four .pine-debug files hunting for the one that is
+   associated with this pine, and then renames it.
+  ----*/
+void
+save_debug_on_crash(dfile)
+FILE *dfile;
+{
+    char nbuf[5], crashfile[MAXPATH+1], filename[MAXPATH+1];
+    int i;
+    struct stat dbuf, tbuf;
+    time_t now = time((time_t *)0);
+
+    if(!(dfile && fstat(fileno(dfile), &dbuf) != 0))
+      return;
+
+    fprintf(dfile, "\nsave_debug_on_crash: Version %s: debug level %d\n",
+	pine_version, debug);
+    fprintf(dfile, "\n                   : %s\n", ctime(&now));
+
+    build_path(crashfile, ps_global->home_dir, ".pine-crash");
+
+    fprintf(dfile, "\nAttempting to save debug file to %s\n", crashfile);
+    fprintf(stderr,
+	"\n\n       Attempting to save debug file to %s\n\n", crashfile);
+
+    /* Blat out last n keystrokes */
+    fputs("========== Latest keystrokes ==========\n", dfile);
+    while((i = key_playback(0)) != -1)
+      fprintf(dfile, "\t%s\t(0x%04.4x)\n", pretty_command(i), i);
+
+    /* look for existing debug file */
+    for(i = 1; i <= ps_global->debug_nfiles; i++){
+	build_path(filename, ps_global->home_dir, DEBUGFILE);
+	sprintf(nbuf, "%d", i);
+	strcat(filename, nbuf);
+	if(stat(filename, &tbuf) != 0)
+	  continue;
+
+	/* This must be the current debug file */
+	if(tbuf.st_dev == dbuf.st_dev && tbuf.st_ino == dbuf.st_ino){
+	    rename_file(filename, crashfile);
+	    break;
+	}
+    }
+
+    /* if current debug file name not found, write it by hand */
+    if(i > ps_global->debug_nfiles){
+	FILE *cfp;
+	char  buf[1025];
+
+	/*
+	 * Copy the debug temp file into the 
+	 */
+	if(cfp = fopen(crashfile, "w")){
+	    buf[1024] = '\0';
+	    fseek(dfile, 0L, 0);
+	    while(fgets(buf, 1025, dfile) && fputs(buf, cfp) != EOF)
+	      ;
+
+	    fclose(cfp);
+	}
+    }
+
+    fclose(dfile);
+}
+
+
+#define CHECK_EVERY_N_TIMES 100
+#define MAX_DEBUG_FILE_SIZE 200000L
+/*
+ * This is just to catch runaway Pines that are looping spewing out
+ * debugging (and filling up a file system).  The stop doesn't have to be
+ * at all precise, just soon enough to hopefully prevent filling the
+ * file system.  If the debugging level is high (9 for now), then we're
+ * presumably looking for some problem, so don't truncate.
+ */
+int
+do_debug(debug_fp)
+FILE *debug_fp;
+{
+    static int counter = CHECK_EVERY_N_TIMES;
+    static int ok = 1;
+    long filesize;
+
+    if(debug == DEFAULT_DEBUG
+       && !ps_global->debug_flush
+       && !ps_global->debug_timestamp
+       && ps_global->debug_imap < 2
+       && ok
+       && --counter <= 0){
+	if((filesize = fp_file_size(debug_fp)) != -1L)
+	  ok = (unsigned long)filesize < (unsigned long)MAX_DEBUG_FILE_SIZE;
+
+	counter = CHECK_EVERY_N_TIMES;
+	if(!ok){
+	    fprintf(debug_fp, "\n\n --- No more debugging ---\n");
+	    fprintf(debug_fp,
+		"     (debug file growing too large - over %ld bytes)\n\n",
+		MAX_DEBUG_FILE_SIZE);
+	    fflush(debug_fp);
+	}
+    }
+
+    if(ok && ps_global->debug_timestamp)
+      fprintf(debug_fp, "\n%s\n", debug_time(0));
+
+    return(ok);
+}
+
+
+/*
+ * Returns a pointer to static string for a timestamp.
+ *
+ * If timestamp is set .subseconds are added if available.
+ * If include_date is set the date is appended.
+ */
+char *
+debug_time(include_date)
+    int include_date;
+{
+    time_t          t;
+    struct tm      *tm_now;
+    struct timeval  tp;
+    struct timezone tzp;
+    static char     timestring[23];
+    char            subsecond[8];
+    char            datestr[7];
+
+    if(gettimeofday(&tp, &tzp) == 0){
+	t = (time_t)tp.tv_sec;
+	if(include_date){
+	    tm_now = localtime(&t);
+	    sprintf(datestr, " %d/%d", tm_now->tm_mon+1, tm_now->tm_mday);
+	}
+	else
+	  datestr[0] = '\0';
+
+	if(ps_global->debug_timestamp)
+	  sprintf(subsecond, ".%06ld", tp.tv_usec);
+	else
+	  subsecond[0] = '\0';
+
+	sprintf(timestring, "%.8s%s%s", ctime(&t)+11, subsecond, datestr);
+    }
+    else
+      timestring[0] = '\0';
+
+    return(timestring);
+}
+#endif /* DEBUG */
+
+
+/*
+ * Fills in the passed in structure with the current time.
+ *
+ * Returns 0 if ok
+ *        -1 if can't do it
+ */
+int
+get_time(our_time_val)
+    TIMEVAL_S *our_time_val;
+{
+    struct timeval  tp;
+    struct timezone tzp;
+
+    if(gettimeofday(&tp, &tzp) == 0){
+	our_time_val->sec  = tp.tv_sec;
+	our_time_val->usec = tp.tv_usec;
+	return 0;
+    }
+    else
+      return -1;
+}
+
+
+/*
+ * Returns the difference between the two values, in microseconds.
+ * Value returned is first - second.
+ */
+long
+time_diff(first, second)
+    TIMEVAL_S *first,
+              *second;
+{
+    return(1000000L*(first->sec - second->sec) + (first->usec - second->usec));
+}
+
+
+
+/*======================================================================
+       Things having to do with reading from the tty driver and keyboard
+          - initialize tty driver and reset tty driver
+          - read a character from terminal with keyboard escape seqence mapping
+          - initialize keyboard (keypad or such) and reset keyboard
+          - prompt user for a line of input
+          - read a command from keyboard with timeouts.
+
+ ====*/
+
+
+/*
+ * Helpful definitions
+ */
+#define	RETURN_CH(X)	return(key_recorder((X)))
+/*
+ * Should really be using pico's TERM's t_getchar to read a character but
+ * we're just calling ttgetc directly for now. Ttgetc is the same as
+ * t_getchar whenever we use it so we're avoiding the trouble of initializing
+ * the TERM struct and calling ttgetc directly.
+ */
+#define READ_A_CHAR()	ttgetc(NO_OP_COMMAND, key_recorder, read_bail)
+
+
+/*
+ * Internal prototypes
+ */
+int  pine_simple_ttgetc PROTO((int (*)(), void (*)()));
+void line_paint PROTO((int, int *));
+int  process_config_input PROTO((int *));
+int  check_for_timeout PROTO((int));
+void read_bail PROTO((void));
+
+
+/*----------------------------------------------------------------------
+    Initialize the tty driver to do single char I/O and whatever else  (UNIX)
+
+   Args:  struct pine
+
+ Result: tty driver is put in raw mode so characters can be read one
+         at a time. Returns -1 if unsuccessful, 0 if successful.
+
+Some file descriptor voodoo to allow for pipes across vforks. See 
+open_mailer for details.
+  ----------------------------------------------------------------------*/
+init_tty_driver(ps)
+     struct pine *ps;
+{
+#ifdef	MOUSE
+    if(F_ON(F_ENABLE_MOUSE, ps_global))
+      init_mouse();
+#endif	/* MOUSE */
+
+    /* turn off talk permission by default */
+    
+    if(F_ON(F_ALLOW_TALK, ps))
+      allow_talk(ps);
+    else
+      disallow_talk(ps);
+
+    return(PineRaw(1));
+}
+
+
+
+/*----------------------------------------------------------------------
+   Set or clear the specified tty mode
+
+   Args: ps --  struct pine
+	 mode -- mode bits to modify
+	 clear -- whether or not to clear or set
+
+ Result: tty driver mode change. 
+  ----------------------------------------------------------------------*/
+void
+tty_chmod(ps, mode, func)
+    struct pine *ps;
+    int		 mode;
+    int		 func;
+{
+    char	*tty_name;
+    int		 new_mode;
+    struct stat  sbuf;
+    static int   saved_mode = -1;
+
+    /* if no problem figuring out tty's name & mode? */
+    if((((tty_name = (char *) ttyname(STDIN_FD)) != NULL
+	 && fstat(STDIN_FD, &sbuf) == 0)
+	|| ((tty_name = (char *) ttyname(STDOUT_FD)) != NULL
+	    && fstat(STDOUT_FD, &sbuf) == 0))
+       && !(func == TMD_RESET && saved_mode < 0)){
+	new_mode = (func == TMD_RESET)
+		     ? saved_mode
+		     : (func == TMD_CLEAR)
+			? (sbuf.st_mode & ~mode)
+			: (sbuf.st_mode | mode);
+	/* assign tty new mode */
+	if(chmod(tty_name, new_mode) == 0){
+	    if(func == TMD_RESET)		/* forget we knew */
+	      saved_mode = -1;
+	    else if(saved_mode < 0)
+	      saved_mode = sbuf.st_mode;	/* remember original */
+	}
+    }
+}
+
+
+
+/*----------------------------------------------------------------------
+       End use of the tty, put it back into it's normal mode     (UNIX)
+
+   Args: ps --  struct pine
+
+ Result: tty driver mode change. 
+  ----------------------------------------------------------------------*/
+void
+end_tty_driver(ps)
+     struct pine *ps;
+{
+    ps = ps; /* get rid of unused parameter warning */
+
+#ifdef	MOUSE
+    end_mouse();
+#endif	/* MOUSE */
+    fflush(stdout);
+    dprint(2, (debugfile, "about to end_tty_driver\n"));
+
+    tty_chmod(ps, 0, TMD_RESET);
+    PineRaw(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Actually set up the tty driver                             (UNIX)
+
+   Args: state -- which state to put it in. 1 means go into raw, 0 out of
+
+  Result: returns 0 if successful and < 0 if not.
+  ----*/
+
+PineRaw(state)
+int state;
+{
+    int result;
+
+    result = Raw(state);
+    
+    if(result == 0 && state == 1){
+	/*
+	 * Only go into 8 bit mode if we are doing something other
+	 * than plain ASCII. This will save the folks that have
+	 * their parity on their serial lines wrong thr trouble of
+	 * getting it right
+	 */
+        if(ps_global->VAR_CHAR_SET && ps_global->VAR_CHAR_SET[0] &&
+	   strucmp(ps_global->VAR_CHAR_SET, "us-ascii"))
+	  bit_strip_off();
+
+#ifdef	DEBUG
+	if(debug < 9)			/* only on if full debugging set */
+#endif
+	quit_char_off();
+	ps_global->low_speed = ttisslow();
+	crlf_proc(0);
+	xonxoff_proc(F_ON(F_PRESERVE_START_STOP, ps_global));
+    }
+
+    return(result);
+}
+
+
+#ifdef RESIZING
+jmp_buf winch_state;
+int     winch_occured = 0;
+int     ready_for_winch = 0;
+#endif
+
+/*----------------------------------------------------------------------
+     This checks whether or not a character			(UNIX)
+     is ready to be read, or it times out.
+
+    Args:  time_out --  number of seconds before it will timeout
+
+  Result: Returns a NO_OP_IDLE or a NO_OP_COMMAND if the timeout expires
+	  before input is available, or a KEY_RESIZE if a resize event
+	  occurs, or READY_TO_READ if input is available before the timeout.
+  ----*/
+int
+check_for_timeout(time_out)
+    int time_out;
+{
+    int res;
+
+    fflush(stdout);
+
+#ifdef RESIZING
+    if(!winch_occured){
+	if(setjmp(winch_state) != 0){
+	    winch_occured = 1;
+	    ready_for_winch = 0;
+
+	    /*
+	     * Need to unblock signal after longjmp from handler, because
+	     * signal is normally unblocked upon routine exit from the handler.
+	     */
+	    our_sigunblock(SIGWINCH);
+	}
+	else
+	  ready_for_winch = 1;
+    }
+
+    if(winch_occured){
+	winch_occured = ready_for_winch = 0;
+	fix_windsize(ps_global);
+	return(KEY_RESIZE);
+    }
+#endif /* RESIZING */
+
+    switch(res = input_ready(time_out)){
+      case BAIL_OUT:
+	read_bail();			/* non-tragic exit */
+	/* NO RETURN */
+
+      case PANIC_NOW:
+	panic1("Select error: %s\n", error_description(errno));
+	/* NO RETURN */
+
+      case READ_INTR:
+	res = NO_OP_COMMAND;
+	/* fall through */
+
+      case NO_OP_IDLE:
+      case NO_OP_COMMAND:
+      case READY_TO_READ:
+#ifdef RESIZING
+	ready_for_winch = 0;
+#endif
+	return(res);
+    }
+}
+
+
+
+/*----------------------------------------------------------------------
+  Read input characters with lots of processing for arrow keys and such  (UNIX)
+
+ Args:  time_out -- The timeout to for the reads 
+
+ Result: returns the character read. Possible special chars.
+
+    This deals with function and arrow keys as well. 
+
+  The idea is that this routine handles all escape codes so it done in
+  only one place. Especially so the back arrow key can work when entering
+  things on a line. Also so all function keys can be disabled and not
+  cause weird things to happen.
+  ---*/
+int
+read_char(time_out)
+    int time_out;
+{
+    int ch, status, cc;
+
+    /* Get input from initial-keystrokes */
+    if(process_config_input(&ch))
+      return(ch);
+
+    /*
+     * We only check for timeouts at the start of read_char, not in the
+     * middle of escape sequences.
+     */
+    if((ch = check_for_timeout(time_out)) != READY_TO_READ)
+      goto done;
+    
+    ps_global->time_of_last_input = time((time_t *)0);
+
+    switch(status = kbseq(pine_simple_ttgetc, key_recorder, read_bail, &ch)){
+      case KEY_DOUBLE_ESC:
+	/*
+	 * Special hack to get around comm devices eating control characters.
+	 */
+	if(check_for_timeout(5) != READY_TO_READ){
+	    ch = KEY_JUNK;		/* user typed ESC ESC, then stopped */
+	    goto done;
+	}
+	else
+	  ch = READ_A_CHAR();
+
+	ch &= 0x7f;
+	if(isdigit((unsigned char)ch)){
+	    int n = 0, i = ch - '0';
+
+	    if(i < 0 || i > 2){
+		ch = KEY_JUNK;
+		goto done;		/* bogus literal char value */
+	    }
+
+	    while(n++ < 2){
+		if(check_for_timeout(5) != READY_TO_READ
+		   || (!isdigit((unsigned char) (ch = READ_A_CHAR()))
+		       || (n == 1 && i == 2 && ch > '5')
+		       || (n == 2 && i == 25 && ch > '5'))){
+		    ch = KEY_JUNK;	/* user typed ESC ESC #, stopped */
+		    goto done;
+		}
+
+		i = (i * 10) + (ch - '0');
+	    }
+
+	    ch = i;
+	}
+	else{
+	    if(islower((unsigned char)ch))	/* canonicalize if alpha */
+	      ch = toupper((unsigned char)ch);
+
+	    ch = (isalpha((unsigned char)ch) || ch == '@'
+		  || (ch >= '[' && ch <= '_'))
+		   ? ctrl(ch) : ((ch == SPACE) ? ctrl('@'): ch);
+	}
+
+	goto done;
+
+#ifdef MOUSE
+      case KEY_XTERM_MOUSE:
+	if(mouseexist()){
+	    /*
+	     * Special hack to get mouse events from an xterm.
+	     * Get the details, then pass it past the keymenu event
+	     * handler, and then to the installed handler if there
+	     * is one...
+	     */
+	    static int down = 0;
+	    int        x, y, button;
+	    unsigned   cmd;
+
+	    clear_cursor_pos();
+	    button = READ_A_CHAR() & 0x03;
+
+	    x = READ_A_CHAR() - '!';
+	    y = READ_A_CHAR() - '!';
+
+	    ch = NO_OP_COMMAND;
+	    if(button == 0){		/* xterm button 1 down */
+		down = 1;
+		if(checkmouse(&cmd, 1, x, y))
+		  ch = (int)cmd;
+	    }
+	    else if (down && button == 3){
+		down = 0;
+		if(checkmouse(&cmd, 0, x, y))
+		  ch = (int)cmd;
+	    }
+
+	    goto done;
+	}
+
+	break;
+#endif /* MOUSE */
+
+      case  KEY_UP	:
+      case  KEY_DOWN	:
+      case  KEY_RIGHT	:
+      case  KEY_LEFT	:
+      case  KEY_PGUP	:
+      case  KEY_PGDN	:
+      case  KEY_HOME	:
+      case  KEY_END	:
+      case  KEY_DEL	:
+      case  PF1		:
+      case  PF2		:
+      case  PF3		:
+      case  PF4		:
+      case  PF5		:
+      case  PF6		:
+      case  PF7		:
+      case  PF8		:
+      case  PF9		:
+      case  PF10	:
+      case  PF11	:
+      case  PF12	:
+        dprint(9, (debugfile, "Read char returning: %d %s\n",
+                   status, pretty_command(status)));
+	return(status);
+
+      case KEY_SWALLOW_Z:
+	status = KEY_JUNK;
+      case KEY_SWAL_UP:
+      case KEY_SWAL_DOWN:
+      case KEY_SWAL_LEFT:
+      case KEY_SWAL_RIGHT:
+	do
+	  if(check_for_timeout(2) != READY_TO_READ){
+	      status = KEY_JUNK;
+	      break;
+	  }
+	while(!strchr("~qz", READ_A_CHAR()));
+	ch = (status == KEY_JUNK) ? status : status - (KEY_SWAL_UP - KEY_UP);
+	goto done;
+
+      case KEY_KERMIT:
+	do{
+	    cc = ch;
+	    if(check_for_timeout(2) != READY_TO_READ){
+		status = KEY_JUNK;
+		break;
+	    }
+	    else
+	      ch = READ_A_CHAR();
+	}while(cc != '\033' && ch != '\\');
+
+	ch = KEY_JUNK;
+	goto done;
+
+      case BADESC:
+	ch = KEY_JUNK;
+	goto done;
+
+      case 0: 	/* regular character */
+      default:
+	/*
+	 * we used to strip (ch &= 0x7f;), but this seems much cleaner
+	 * in the face of line noise and has the benefit of making it
+	 * tougher to emit mistakenly labeled MIME...
+	 */
+	if((ch & 0x80) && (!ps_global->VAR_CHAR_SET
+			   || !strucmp(ps_global->VAR_CHAR_SET, "US-ASCII"))){
+	    dprint(9, (debugfile, "Read char returning: %d %s\n",
+		       status, pretty_command(status)));
+	    return(KEY_JUNK);
+	}
+	else if(ch == ctrl('Z')){
+	    dprint(9, (debugfile, "Read char calling do_suspend\n"));
+	    return(do_suspend());
+	}
+
+
+      done:
+        dprint(9, (debugfile, "Read char returning: %d %s\n",
+                   ch, pretty_command(ch)));
+        return(ch);
+    }
+}
+
+
+/*----------------------------------------------------------------------
+  Reading input somehow failed and we need to shutdown now
+
+ Args:  none
+
+ Result: pine exits
+
+  ---*/
+void
+read_bail()
+{
+    end_signals(1);
+    if(ps_global->inbox_stream){
+	if(ps_global->inbox_stream == ps_global->mail_stream)
+	  ps_global->mail_stream = NULL;
+
+	if(!ps_global->inbox_stream->lock)		/* shouldn't be... */
+	  pine_close_stream(ps_global->inbox_stream);
+    }
+
+    if(ps_global->mail_stream && !ps_global->mail_stream->lock)
+      pine_close_stream(ps_global->mail_stream);
+
+    end_keyboard(F_ON(F_USE_FK,ps_global));
+    end_tty_driver(ps_global);
+    if(filter_data_file(0))
+      unlink(filter_data_file(0));
+
+    exit(0);
+}
+
+
+int
+pine_simple_ttgetc(fi, fv)
+    int	 (*fi)();
+    void (*fv)();
+{
+    int ch;
+
+#ifdef RESIZING
+    if(!winch_occured){
+	if(setjmp(winch_state) != 0){
+	    winch_occured = 1;
+	    ready_for_winch = 0;
+
+	    /*
+	     * Need to unblock signal after longjmp from handler, because
+	     * signal is normally unblocked upon routine exit from the handler.
+	     */
+	    our_sigunblock(SIGWINCH);
+	}
+	else
+	  ready_for_winch = 1;
+    }
+
+    if(winch_occured){
+	winch_occured = ready_for_winch = 0;
+	fix_windsize(ps_global);
+	return(KEY_RESIZE);
+    }
+#endif /* RESIZING */
+
+    ch = simple_ttgetc(fi, fv);
+
+#ifdef RESIZING
+    ready_for_winch = 0;
+#endif
+
+    return(ch);
+}
+
+
+
+extern char term_name[];
+/* -------------------------------------------------------------------
+     Set up the keyboard -- usually enable some function keys  (UNIX)
+
+    Args: struct pine 
+
+So far all we do here is turn on keypad mode for certain terminals
+
+Hack for NCSA telnet on an IBM PC to put the keypad in the right mode.
+This is the same for a vtXXX terminal or [zh][12]9's which we have 
+a lot of at UW
+  ----*/
+void
+init_keyboard(use_fkeys)
+     int use_fkeys;
+{
+    if(use_fkeys && (!strucmp(term_name,"vt102")
+		     || !strucmp(term_name,"vt100")))
+      printf("\033\133\071\071\150");
+}
+
+
+
+/*----------------------------------------------------------------------
+     Clear keyboard, usually disable some function keys           (UNIX)
+
+   Args:  pine state (terminal type)
+
+ Result: keyboard state reset
+  ----*/
+void
+end_keyboard(use_fkeys)
+     int use_fkeys;
+{
+    if(use_fkeys && (!strcmp(term_name, "vt102")
+		     || !strcmp(term_name, "vt100"))){
+	printf("\033\133\071\071\154");
+	fflush(stdout);
+    }
+}
+
+
+#ifdef	_WINDOWS
+#line 3 "osdep/termin.gen"
+
+static int g_mc_row, g_mc_col;
+
+int	pcpine_oe_cursor PROTO((int, long));
+#endif
+
+
+/*
+ *     Generic tty input routines
+ */
+
+
+/*----------------------------------------------------------------------
+        Read a character from keyboard with timeout
+ Input:  none
+
+ Result: Returns command read via read_char
+         Times out and returns a null command every so often
+
+  Calculates the timeout for the read, and does a few other house keeping 
+things.  The duration of the timeout is set in pine.c.
+  ----------------------------------------------------------------------*/
+int
+read_command()
+{
+    int ch, tm = 0;
+    long dtime; 
+
+    cancel_busy_alarm(-1);
+    tm = (messages_queued(&dtime) > 1) ? (int)dtime : timeo;
+
+    /*
+     * Before we sniff at the input queue, make sure no external event's
+     * changed our picture of the message sequence mapping.  If so,
+     * recalculate the dang thing and run thru whatever processing loop
+     * we're in again...
+     */
+    if(ps_global->expunge_count){
+	q_status_message3(SM_ORDER, 3, 3,
+			  "%s message%s expunged from folder \"%s\"",
+			  long2string(ps_global->expunge_count),
+			  plural(ps_global->expunge_count),
+			  pretty_fn(ps_global->cur_folder));
+	ps_global->expunge_count = 0L;
+	display_message('x');
+    }
+
+    if(ps_global->inbox_expunge_count){
+	q_status_message3(SM_ORDER, 3, 3,
+			  "%s message%s expunged from folder \"%s\"",
+			  long2string(ps_global->inbox_expunge_count),
+			  plural(ps_global->inbox_expunge_count),
+			  pretty_fn(ps_global->inbox_name));
+	ps_global->inbox_expunge_count = 0L;
+	display_message('x');
+    }
+
+    if(ps_global->mail_box_changed && ps_global->new_mail_count){
+        dprint(2, (debugfile, "Noticed %ld new msgs! \n",
+		   ps_global->new_mail_count));
+	return(NO_OP_COMMAND);		/* cycle thru so caller can update */
+    }
+
+    ch = read_char(tm);
+    dprint(9, (debugfile, "Read command returning: %d %s\n", ch,
+              pretty_command(ch)));
+    if(ch != NO_OP_COMMAND && ch != NO_OP_IDLE && ch != KEY_RESIZE)
+      zero_new_mail_count();
+
+#ifdef	BACKGROUND_POST
+    /*
+     * Any expired children to report on?
+     */
+    if(ps_global->post && ps_global->post->pid == 0){
+	int   winner = 0;
+
+	if(ps_global->post->status < 0){
+	    q_status_message(SM_ORDER | SM_DING, 3, 3, "Abysmal failure!");
+	}
+	else{
+	    (void) pine_send_status(ps_global->post->status,
+				    ps_global->post->fcc, tmp_20k_buf,
+				    &winner);
+	    q_status_message(SM_ORDER | (winner ? 0 : SM_DING), 3, 3,
+			     tmp_20k_buf);
+
+	}
+
+	if(!winner)
+	  q_status_message(SM_ORDER, 0, 3,
+	  "Re-send via \"Compose\" then \"Yes\" to \"Continue INTERRUPTED?\"");
+
+	if(ps_global->post->fcc)
+	  fs_give((void **) &ps_global->post->fcc);
+
+	fs_give((void **) &ps_global->post);
+    }
+#endif
+
+    return(ch);
+}
+
+
+
+
+/*
+ *
+ */
+static struct display_line {
+    int   row, col;			/* where display starts		 */
+    int   dlen;				/* length of display line	 */
+    char *dl;				/* line on display		 */
+    char *vl;				/* virtual line 		 */
+    int   vlen;				/* length of virtual line        */
+    int   vused;			/* length of virtual line in use */
+    int   vbase;			/* first virtual char on display */
+} dline;
+
+
+
+static struct key oe_keys[] =
+       {{"^G","Help",KS_SCREENHELP},	{"^C","Cancel",KS_NONE},
+	{"^T","xxx",KS_NONE},		{"Ret","Accept",KS_NONE},
+	{NULL,NULL,KS_NONE},		{NULL,NULL,KS_NONE},
+	{NULL,NULL,KS_NONE},		{NULL,NULL,KS_NONE},
+	{NULL,NULL,KS_NONE},		{NULL,NULL,KS_NONE},
+	{NULL,NULL,KS_NONE},		{NULL,NULL,KS_NONE}};
+INST_KEY_MENU(oe_keymenu, oe_keys);
+#define	OE_HELP_KEY	0
+#define	OE_CANCEL_KEY	1
+#define	OE_CTRL_T_KEY	2
+#define	OE_ENTER_KEY	3
+
+
+/*---------------------------------------------------------------------- 
+       Prompt user for a string in status line with various options
+
+  Args: string -- the buffer result is returned in, and original string (if 
+                   any) is passed in.
+        y_base -- y position on screen to start on. 0,0 is upper left
+                    negative numbers start from bottom
+        x_base -- column position on screen to start on. 0,0 is upper left
+        field_len -- Maximum length of string to accept
+        prompt -- The string to prompt with
+	escape_list -- pointer to array of ESCKEY_S's.  input chars matching
+                       those in list return value from list.
+        help   -- Arrary of strings for help text in bottom screen lines
+        flags  -- pointer (because some are return values) to flags
+		  OE_USER_MODIFIED       - Set on return if user modified buffer
+		  OE_DISALLOW_CANCEL     - No cancel in menu.
+		  OE_DISALLOW_HELP       - No help in menu.
+		  OE_KEEP_TRAILING_SPACE - Allow trailing space.
+		  OE_SEQ_SENSITIVE       - Caller is sensitive to sequence
+					   number changes.
+		  OE_APPEND_CURRENT      - String should not be truncated
+					   before accepting user input.
+		  OE_PASSWD              - Don't echo on screen.
+
+  Result:  editing input string
+            returns -1 unexpected errors
+            returns 0  normal entry typed (editing and return or PF2)
+            returns 1  typed ^C or PF2 (cancel)
+            returns 3  typed ^G or PF1 (help)
+            returns 4  typed ^L for a screen redraw
+
+  WARNING: Care is required with regard to the escape_list processing.
+           The passed array is terminated with an entry that has ch = -1.
+           Function key labels and key strokes need to be setup externally!
+	   Traditionally, a return value of 2 is used for ^T escapes.
+
+   Unless in escape_list, tabs are trapped by isprint().
+This allows near full weemacs style editing in the line
+   ^A beginning of line
+   ^E End of line
+   ^R Redraw line
+   ^G Help
+   ^F forward
+   ^B backward
+   ^D delete
+----------------------------------------------------------------------*/
+
+optionally_enter(string, y_base, x_base, field_len,
+                 prompt, escape_list, help, flags)
+     char       *string, *prompt;
+     ESCKEY_S   *escape_list;
+     HelpType	 help;
+     int         x_base, y_base, field_len;
+     int	*flags;
+{
+    register char *s2;
+    register int   field_pos;
+    int            i, j, return_v, cols, ch, prompt_len, too_thin,
+                   real_y_base, km_popped, passwd;
+    char          *saved_original = NULL, *k, *kb;
+    char          *kill_buffer = NULL;
+    char         **help_text;
+    int		   fkey_table[12];
+    struct	   key_menu *km;
+    bitmap_t	   bitmap;
+    COLOR_PAIR    *lastc = NULL, *promptc = NULL;
+    struct variable *vars = ps_global->vars;
+#ifdef	_WINDOWS
+    int		   cursor_shown;
+#endif
+
+    dprint(5, (debugfile, "=== optionally_enter called ===\n"));
+    dprint(9, (debugfile, "string:\"%s\"  y:%d  x:%d  length: %d append: %d\n",
+               string, x_base, y_base, field_len,
+	       (flags && *flags & OE_APPEND_CURRENT)));
+    dprint(9, (debugfile, "passwd:%d   prompt:\"%s\"   label:\"%s\"\n",
+               (flags && *flags & OE_PASSWD),
+	       prompt, (escape_list && escape_list[0].ch != -1)
+				 ? escape_list[0].label: ""));
+
+#ifdef _WINDOWS
+    if (mswin_usedialog ()) {
+	MDlgButton		button_list[12];
+	int			b;
+	int			i;
+
+	memset (&button_list, 0, sizeof (MDlgButton) * 12);
+	b = 0;
+	for (i = 0; escape_list && escape_list[i].ch != -1 && i < 11; ++i) {
+	    if (escape_list[i].name != NULL
+		&& escape_list[i].ch > 0 && escape_list[i].ch < 256) {
+		button_list[b].ch = escape_list[i].ch;
+		button_list[b].rval = escape_list[i].rval;
+		button_list[b].name = escape_list[i].name;
+		button_list[b].label = escape_list[i].label;
+		++b;
+	    }
+	}
+	button_list[b].ch = -1;
+
+
+	help_text = get_help_text (help);
+	return_v = mswin_dialog (prompt, string, field_len, 
+				 (flags && *flags & OE_APPEND_CURRENT),
+				 (flags && *flags & OE_PASSWD),
+				 button_list,
+				 help_text, flags ? *flags : OE_NONE);
+	free_list_array (&help_text);
+        return (return_v);
+    }
+#endif
+
+    suspend_busy_alarm();
+    cols       = ps_global->ttyo->screen_cols;
+    prompt_len = strlen(prompt);
+    too_thin   = 0;
+    km_popped  = 0;
+    if(y_base > 0) {
+        real_y_base = y_base;
+    } else {
+        real_y_base=  y_base + ps_global->ttyo->screen_rows;
+        if(real_y_base < 2)
+          real_y_base = ps_global->ttyo->screen_rows;
+    }
+
+    flush_ordered_messages();
+    mark_status_dirty();
+    if(flags && *flags & OE_APPEND_CURRENT) /* save a copy in case of cancel */
+      saved_original = cpystr(string);
+
+    /*
+     * build the function key mapping table, skipping predefined keys...
+     */
+    memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(int));
+    for(i = 0, j = 0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
+	if(i+j == OE_HELP_KEY)
+	  j++;
+
+	if(i+j == OE_CANCEL_KEY)
+	  j++;
+
+	if(i+j == OE_ENTER_KEY)
+	  j++;
+
+	fkey_table[i+j] = escape_list[i].ch;
+    }
+
+#if defined(HELPFILE)
+    help_text = (help != NO_HELP) ? get_help_text(help) : (char **)NULL;
+#else
+    help_text = help;
+#endif
+    if(help_text){			/*---- Show help text -----*/
+	int width = ps_global->ttyo->screen_cols - x_base;
+
+	if(FOOTER_ROWS(ps_global) == 1){
+	    km_popped++;
+	    FOOTER_ROWS(ps_global) = 3;
+	    clearfooter(ps_global);
+
+	    y_base = -3;
+	    real_y_base = y_base + ps_global->ttyo->screen_rows;
+	}
+
+	for(j = 0; j < 2 && help_text[j]; j++){
+	    MoveCursor(real_y_base + 1 + j, x_base);
+	    CleartoEOLN();
+
+	    if(width < strlen(help_text[j])){
+		char *tmp = fs_get((width + 1) * sizeof(char));
+		strncpy(tmp, help_text[j], width);
+		tmp[width] = '\0';
+		PutLine0(real_y_base + 1 + j, x_base, tmp);
+		fs_give((void **)&tmp);
+	    }
+	    else
+	      PutLine0(real_y_base + 1 + j, x_base, help_text[j]);
+	}
+
+#if defined(HELPFILE)
+	free_list_array(&help_text);
+#endif
+
+    } else {
+	clrbitmap(bitmap);
+	clrbitmap((km = &oe_keymenu)->bitmap);		/* force formatting */
+	if(!(flags && (*flags) & OE_DISALLOW_HELP))
+	  setbitn(OE_HELP_KEY, bitmap);
+
+	setbitn(OE_ENTER_KEY, bitmap);
+	if(!(flags && (*flags) & OE_DISALLOW_CANCEL))
+	  setbitn(OE_CANCEL_KEY, bitmap);
+
+	setbitn(OE_CTRL_T_KEY, bitmap);
+
+        /*---- Show the usual possible keys ----*/
+	for(i=0,j=0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
+	    if(i+j == OE_HELP_KEY)
+	      j++;
+
+	    if(i+j == OE_CANCEL_KEY)
+	      j++;
+
+	    if(i+j == OE_ENTER_KEY)
+	      j++;
+
+	    oe_keymenu.keys[i+j].label = escape_list[i].label;
+	    oe_keymenu.keys[i+j].name = escape_list[i].name;
+	    setbitn(i+j, bitmap);
+	}
+
+	for(i = i+j; i < 12; i++)
+	  if(!(i == OE_HELP_KEY || i == OE_ENTER_KEY || i == OE_CANCEL_KEY))
+	    oe_keymenu.keys[i].name = NULL;
+
+	draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global), 0, FirstMenu);
+    }
+    
+    if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR &&
+       VAR_PROMPT_BACK_COLOR &&
+       pico_is_good_color(VAR_PROMPT_FORE_COLOR) &&
+       pico_is_good_color(VAR_PROMPT_BACK_COLOR)){
+	lastc = pico_get_cur_color();
+	if(lastc){
+	    promptc = new_color_pair(VAR_PROMPT_FORE_COLOR,
+				     VAR_PROMPT_BACK_COLOR);
+	    (void)pico_set_colorp(promptc, PSC_NONE);
+	}
+    }
+    else
+      StartInverse();
+
+    /*
+     * if display length isn't wide enough to support input,
+     * shorten up the prompt...
+     */
+    if((dline.dlen = cols - (x_base + prompt_len + 1)) < 5){
+	prompt_len += (dline.dlen - 5);	/* adding negative numbers */
+	prompt     -= (dline.dlen - 5);	/* subtracting negative numbers */
+	dline.dlen  = 5;
+    }
+
+    dline.dl    = fs_get((size_t)dline.dlen + 1);
+    memset((void *)dline.dl, 0, (size_t)(dline.dlen + 1) * sizeof(char));
+    dline.row   = real_y_base;
+    dline.col   = x_base + prompt_len;
+    dline.vl    = string;
+    dline.vlen  = --field_len;		/* -1 for terminating NULL */
+    dline.vbase = field_pos = 0;
+
+#ifdef	_WINDOWS
+    cursor_shown = mswin_showcaret(1);
+#endif
+    
+    PutLine0(real_y_base, x_base, prompt);
+    /* make sure passed in string is shorter than field_len */
+    /* and adjust field_pos..                               */
+
+    while((flags && *flags & OE_APPEND_CURRENT) &&
+          field_pos < field_len && string[field_pos] != '\0')
+      field_pos++;
+
+    string[field_pos] = '\0';
+    dline.vused = (int)(&string[field_pos] - string);
+    passwd = (flags && *flags & OE_PASSWD) ? 1 : 0;
+    line_paint(field_pos, &passwd);
+
+    /*----------------------------------------------------------------------
+      The main loop
+   
+    here field_pos is the position in the string.
+    s always points to where we are in the string.
+    loops until someone sets the return_v.
+      ----------------------------------------------------------------------*/
+    return_v = -10;
+
+    while(return_v == -10) {
+
+#ifdef	MOUSE
+	mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0);
+	register_mfunc(mouse_in_content, 
+		       real_y_base, x_base + prompt_len,
+		       real_y_base, ps_global->ttyo->screen_cols);
+#endif
+#ifdef	_WINDOWS
+	mswin_allowpaste(MSWIN_PASTE_LINE);
+	g_mc_row = real_y_base;
+	g_mc_col = x_base + prompt_len;
+	mswin_mousetrackcallback(pcpine_oe_cursor);
+#endif
+
+	/* Timeout 10 min to keep imap mail stream alive */
+        ch = read_char(600);
+
+#ifdef	MOUSE
+	clear_mfunc(mouse_in_content);
+#endif
+#ifdef	_WINDOWS
+	mswin_allowpaste(MSWIN_PASTE_DISABLE);
+	mswin_mousetrackcallback(NULL);
+#endif
+
+	/*
+	 * Don't want to intercept all characters if typing in passwd.
+	 * We select an ad hoc set that we will catch and let the rest
+	 * through.  We would have caught the set below in the big switch
+	 * but we skip the switch instead.  Still catch things like ^K,
+	 * DELETE, ^C, RETURN.
+	 */
+	if(passwd)
+	  switch(ch) {
+            case ctrl('F'):  
+	    case KEY_RIGHT:
+            case ctrl('B'):
+	    case KEY_LEFT:
+            case ctrl('U'):
+            case ctrl('A'):
+	    case KEY_HOME:
+            case ctrl('E'):
+	    case KEY_END:
+	    case TAB:
+	      goto ok_for_passwd;
+	  }
+
+        if(too_thin && ch != KEY_RESIZE && ch != ctrl('Z') && ch != ctrl('C'))
+          goto bleep;
+
+	switch(ch) {
+
+	    /*--------------- KEY RIGHT ---------------*/
+          case ctrl('F'):  
+	  case KEY_RIGHT:
+	    if(field_pos >= field_len || string[field_pos] == '\0')
+              goto bleep;
+
+	    line_paint(++field_pos, &passwd);
+	    break;
+
+	    /*--------------- KEY LEFT ---------------*/
+          case ctrl('B'):
+	  case KEY_LEFT:
+	    if(field_pos <= 0)
+	      goto bleep;
+
+	    line_paint(--field_pos, &passwd);
+	    break;
+
+          /*-------------------- WORD SKIP --------------------*/
+	  case ctrl('@'):
+	    /*
+	     * Note: read_char *can* return NO_OP_COMMAND which is
+	     * the def'd with the same value as ^@ (NULL), BUT since
+	     * read_char has a big timeout (>25 secs) it won't.
+	     */
+
+	    /* skip thru current word */
+	    while(string[field_pos]
+		  && isalnum((unsigned char) string[field_pos]))
+	      field_pos++;
+
+	    /* skip thru current white space to next word */
+	    while(string[field_pos]
+		  && !isalnum((unsigned char) string[field_pos]))
+	      field_pos++;
+
+	    line_paint(field_pos, &passwd);
+	    break;
+
+          /*--------------------  RETURN --------------------*/
+	  case PF4:
+	    if(F_OFF(F_USE_FK,ps_global)) goto bleep;
+	  case ctrl('J'): 
+	  case ctrl('M'): 
+	    return_v = 0;
+	    break;
+
+          /*-------------------- Destructive backspace --------------------*/
+	  case '\177': /* DEL */
+	  case ctrl('H'):
+            /*   Try and do this with by telling the terminal to delete a
+                 a character. If that fails, then repaint the rest of the
+                 line, acheiving the same much less efficiently
+             */
+	    if(field_pos <= 0)
+	      goto bleep;
+
+	    field_pos--;
+	    /* drop thru to pull line back ... */
+
+          /*-------------------- Delete char --------------------*/
+	  case ctrl('D'): 
+	  case KEY_DEL: 
+            if(field_pos >= field_len || !string[field_pos])
+	      goto bleep;
+
+	    dline.vused--;
+	    for(s2 = &string[field_pos]; *s2 != '\0'; s2++)
+	      *s2 = s2[1];
+
+	    *s2 = '\0';			/* Copy last NULL */
+	    line_paint(field_pos, &passwd);
+	    if(flags)		/* record change if requested  */
+	      *flags |= OE_USER_MODIFIED;
+
+	    break;
+
+
+            /*--------------- Kill line -----------------*/
+          case ctrl('K'):
+            if(kill_buffer != NULL)
+              fs_give((void **)&kill_buffer);
+
+	    if(field_pos != 0 || string[0]){
+		if(!passwd && F_ON(F_DEL_FROM_DOT, ps_global))
+		  dline.vused -= strlen(&string[i = field_pos]);
+		else
+		  dline.vused = i = 0;
+
+		kill_buffer = cpystr(&string[field_pos = i]);
+		string[field_pos] = '\0';
+		line_paint(field_pos, &passwd);
+		if(flags)		/* record change if requested  */
+		  *flags |= OE_USER_MODIFIED;
+
+	    }
+
+            break;
+
+            /*------------------- Undelete line --------------------*/
+          case ctrl('U'):
+            if(kill_buffer == NULL)
+              goto bleep;
+
+            /* Make string so it will fit */
+            kb = cpystr(kill_buffer);
+            dprint(2, (debugfile,
+		       "Undelete: %d %d\n", strlen(string), field_len));
+            if(strlen(kb) + strlen(string) > field_len) 
+                kb[field_len - strlen(string)] = '\0';
+            dprint(2, (debugfile,
+		       "Undelete: %d %d\n", field_len - strlen(string),
+		       strlen(kb)));
+                       
+            if(string[field_pos] == '\0') {
+                /*--- adding to the end of the string ----*/
+                for(k = kb; *k; k++)
+		  string[field_pos++] = *k;
+
+                string[field_pos] = '\0';
+            } else {
+                goto bleep;
+                /* To lazy to do insert in middle of string now */
+            }
+
+	    if(*kb && flags)		/* record change if requested  */
+	      *flags |= OE_USER_MODIFIED;
+
+	    dline.vused = strlen(string);
+            fs_give((void **)&kb);
+	    line_paint(field_pos, &passwd);
+            break;
+            
+
+	    /*-------------------- Interrupt --------------------*/
+	  case ctrl('C'): /* ^C */ 
+	    if(F_ON(F_USE_FK,ps_global)
+	       || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
+	      goto bleep;
+
+	    goto cancel;
+
+	  case PF2:
+	    if(F_OFF(F_USE_FK,ps_global)
+	       || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
+	      goto bleep;
+
+	  cancel:
+	    return_v = 1;
+	    if(saved_original)
+	      strcpy(string, saved_original);
+
+	    break;
+	    
+
+          case ctrl('A'):
+	  case KEY_HOME:
+            /*-------------------- Start of line -------------*/
+	    line_paint(field_pos = 0, &passwd);
+            break;
+
+
+          case ctrl('E'):
+	  case KEY_END:
+            /*-------------------- End of line ---------------*/
+	    line_paint(field_pos = dline.vused, &passwd);
+            break;
+
+
+	    /*-------------------- Help --------------------*/
+	  case ctrl('G') : 
+	  case PF1:
+	    if(flags && ((*flags) & OE_DISALLOW_HELP))
+	      goto bleep;
+	    else if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){
+		km_popped++;
+		FOOTER_ROWS(ps_global) = 3;
+		clearfooter(ps_global);
+		if(lastc)
+		  (void)pico_set_colorp(lastc, PSC_NONE);
+		else
+		  EndInverse();
+
+		draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global),
+			     0, FirstMenu);
+
+		if(promptc)
+		  (void)pico_set_colorp(promptc, PSC_NONE);
+		else
+		  StartInverse();
+
+		mark_keymenu_dirty();
+		y_base = -3;
+		dline.row = real_y_base = y_base + ps_global->ttyo->screen_rows;
+		PutLine0(real_y_base, x_base, prompt);
+		fs_resize((void **)&dline.dl, (size_t)dline.dlen + 1);
+		memset((void *)dline.dl, 0, (size_t)(dline.dlen + 1));
+		line_paint(field_pos, &passwd);
+		break;
+	    }
+
+	    if(FOOTER_ROWS(ps_global) > 1){
+		mark_keymenu_dirty();
+		return_v = 3;
+	    }
+	    else
+	      goto bleep;
+
+	    break;
+
+#ifdef	MOUSE
+	  case KEY_MOUSE :
+	    {
+	      MOUSEPRESS mp;
+
+	      mouse_get_last (NULL, &mp);
+
+	      /* The clicked line have anything special on it? */
+	      switch(mp.button){
+		case M_BUTTON_LEFT :			/* position cursor */
+		  mp.col -= x_base + prompt_len;	/* normalize column */
+		  if(dline.vbase + mp.col <= dline.vused)
+		    line_paint(field_pos = dline.vbase + mp.col, &passwd);
+
+		  break;
+
+		case M_BUTTON_RIGHT :
+#ifdef	_WINDOWS
+		  mp.col -= x_base + prompt_len;	/* normalize column */
+		  if(dline.vbase + mp.col <= dline.vused)
+		    line_paint(field_pos = dline.vbase + mp.col, &passwd);
+
+		  mswin_allowpaste(MSWIN_PASTE_LINE);
+		  mswin_paste_popup();
+		  mswin_allowpaste(MSWIN_PASTE_DISABLE);
+		  break;
+#endif
+
+		case M_BUTTON_MIDDLE :			/* NO-OP for now */
+		default:				/* just ignore */
+		  break;
+	      }
+	    }
+
+	    break;
+#endif
+
+          case NO_OP_IDLE:
+	    /* Keep mail stream alive */
+	    i = new_mail(0, 2, NM_DEFER_SORT);
+	    if(ps_global->expunge_count &&
+	       flags && ((*flags) & OE_SEQ_SENSITIVE))
+	      goto cancel;
+
+	    if(i < 0){
+	      line_paint(field_pos, &passwd);
+	      break;			/* no changes, get on with life */
+	    }
+	    /* Else fall into redraw */
+
+	    /*-------------------- Redraw --------------------*/
+	  case ctrl('L'):
+            /*---------------- re size ----------------*/
+          case KEY_RESIZE:
+            
+	    dline.row = real_y_base = y_base > 0 ? y_base :
+					 y_base + ps_global->ttyo->screen_rows;
+	    if(lastc)
+	      (void)pico_set_colorp(lastc, PSC_NONE);
+	    else
+	      EndInverse();
+
+            ClearScreen();
+            redraw_titlebar();
+            if(ps_global->redrawer != (void (*)())NULL)
+              (*ps_global->redrawer)();
+
+            redraw_keymenu();
+	    if(promptc)
+	      (void)pico_set_colorp(promptc, PSC_NONE);
+	    else
+	      StartInverse();
+            
+            PutLine0(real_y_base, x_base, prompt);
+            cols     =  ps_global->ttyo->screen_cols;
+            too_thin = 0;
+            if(cols < x_base + prompt_len + 4) {
+		Writechar(BELL, 0);
+                PutLine0(real_y_base, 0, "Screen's too thin. Ouch!");
+                too_thin = 1;
+            } else {
+		dline.col   = x_base + prompt_len;
+		dline.dlen  = cols - (x_base + prompt_len + 1);
+		fs_resize((void **)&dline.dl, (size_t)dline.dlen + 1);
+		memset((void *)dline.dl, 0, (size_t)(dline.dlen + 1));
+		line_paint(field_pos, &passwd);
+            }
+            fflush(stdout);
+
+            dprint(9, (debugfile,
+                    "optionally_enter  RESIZE new_cols:%d  too_thin: %d\n",
+                       cols, too_thin));
+            break;
+
+	  case PF3 :		/* input to potentially remap */
+	  case PF5 :
+	  case PF6 :
+	  case PF7 :
+	  case PF8 :
+	  case PF9 :
+	  case PF10 :
+	  case PF11 :
+	  case PF12 :
+	      if(F_ON(F_USE_FK,ps_global)
+		 && fkey_table[ch - PF1] != NO_OP_COMMAND)
+		ch = fkey_table[ch - PF1]; /* remap function key input */
+  
+          default:
+	    if(escape_list){		/* in the escape key list? */
+		for(j=0; escape_list[j].ch != -1; j++){
+		    if(escape_list[j].ch == ch){
+			return_v = escape_list[j].rval;
+			break;
+		    }
+		}
+
+		if(return_v != -10)
+		  break;
+	    }
+
+	    if(iscntrl(ch & 0x7f)){
+       bleep:
+		putc(BELL, stdout);
+		continue;
+	    }
+
+       ok_for_passwd:
+	    /*--- Insert a character -----*/
+	    if(dline.vused >= field_len)
+	      goto bleep;
+
+	    /*---- extending the length of the string ---*/
+	    for(s2 = &string[++dline.vused]; s2 - string > field_pos; s2--)
+	      *s2 = *(s2-1);
+
+	    string[field_pos++] = ch;
+	    line_paint(field_pos, &passwd);
+	    if(flags)		/* record change if requested  */
+	      *flags |= OE_USER_MODIFIED;
+		    
+	}   /*---- End of switch on char ----*/
+    }
+
+#ifdef	_WINDOWS
+    if(!cursor_shown)
+      mswin_showcaret(0);
+#endif
+
+    fs_give((void **)&dline.dl);
+    if(saved_original) 
+      fs_give((void **)&saved_original);
+
+    if(kill_buffer)
+      fs_give((void **)&kill_buffer);
+
+    if (!(flags && (*flags) & OE_KEEP_TRAILING_SPACE))
+      removing_trailing_white_space(string);
+
+    if(lastc){
+	(void)pico_set_colorp(lastc, PSC_NONE);
+	free_color_pair(&lastc);
+	if(promptc)
+	  free_color_pair(&promptc);
+    }
+    else
+      EndInverse();
+
+    MoveCursor(real_y_base, x_base); /* Move the cursor to show we're done */
+    fflush(stdout);
+    resume_busy_alarm(0);
+    if(km_popped){
+	FOOTER_ROWS(ps_global) = 1;
+	clearfooter(ps_global);
+	ps_global->mangled_body = 1;
+    }
+
+    return(return_v);
+}
+
+
+/*
+ * line_paint - where the real work of managing what is displayed gets done.
+ *              The passwd variable is overloaded: if non-zero, don't
+ *              output anything, else only blat blank chars across line
+ *              once and use this var to tell us we've already written the 
+ *              line.
+ */
+void
+line_paint(offset, passwd)
+    int   offset;			/* current dot offset into line */
+    int  *passwd;			/* flag to hide display of chars */
+{
+    register char *pfp, *pbp;
+    register char *vfp, *vbp;
+    int            extra = 0;
+#define DLEN	(dline.vbase + dline.dlen)
+
+    /*
+     * for now just leave line blank, but maybe do '*' for each char later
+     */
+    if(*passwd){
+	if(*passwd > 1)
+	  return;
+	else
+	  *passwd = 2;		/* only blat once */
+
+	extra = 0;
+	MoveCursor(dline.row, dline.col);
+	while(extra++ < dline.dlen)
+	  Writechar(' ', 0);
+
+	MoveCursor(dline.row, dline.col);
+	return;
+    }
+
+    /* adjust right margin */
+    while(offset >= DLEN + ((dline.vused > DLEN) ? -1 : 1))
+      dline.vbase += dline.dlen/2;
+
+    /* adjust left margin */
+    while(offset < dline.vbase + ((dline.vbase) ? 2 : 0))
+      dline.vbase = max(dline.vbase - (dline.dlen/2), 0);
+
+    if(dline.vbase){				/* off screen cue left */
+	vfp = &dline.vl[dline.vbase+1];
+	pfp = &dline.dl[1];
+	if(dline.dl[0] != '<'){
+	    MoveCursor(dline.row, dline.col);
+	    Writechar(dline.dl[0] = '<', 0);
+	}
+    }
+    else{
+	vfp = dline.vl;
+	pfp = dline.dl;
+	if(dline.dl[0] == '<'){
+	    MoveCursor(dline.row, dline.col);
+	    Writechar(dline.dl[0] = ' ', 0);
+	}
+    }
+
+    if(dline.vused > DLEN){			/* off screen right... */
+	vbp = vfp + (long)(dline.dlen-(dline.vbase ? 2 : 1));
+	pbp = pfp + (long)(dline.dlen-(dline.vbase ? 2 : 1));
+	if(pbp[1] != '>'){
+	    MoveCursor(dline.row, dline.col+dline.dlen);
+	    Writechar(pbp[1] = '>', 0);
+	}
+    }
+    else{
+	extra = dline.dlen - (dline.vused - dline.vbase);
+	vbp = &dline.vl[max(0, dline.vused-1)];
+	pbp = &dline.dl[dline.dlen];
+	if(pbp[0] == '>'){
+	    MoveCursor(dline.row, dline.col+dline.dlen);
+	    Writechar(pbp[0] = ' ', 0);
+	}
+    }
+
+    while(*pfp == *vfp && vfp < vbp)			/* skip like chars */
+      pfp++, vfp++;
+
+    if(pfp == pbp && *pfp == *vfp){			/* nothing to paint! */
+	MoveCursor(dline.row, dline.col + (offset - dline.vbase));
+	return;
+    }
+
+    /* move backward thru like characters */
+    if(extra){
+	while(extra >= 0 && *pbp == ' ') 		/* back over spaces */
+	  extra--, pbp--;
+
+	while(extra >= 0)				/* paint new ones    */
+	  pbp[-(extra--)] = ' ';
+    }
+
+    if((vbp - vfp) == (pbp - pfp)){			/* space there? */
+	while((*pbp == *vbp) && pbp != pfp)		/* skip like chars */
+	  pbp--, vbp--;
+    }
+
+    if(pfp != pbp || *pfp != *vfp){			/* anything to paint?*/
+	MoveCursor(dline.row, dline.col + (int)(pfp - dline.dl));
+
+	do
+	  Writechar((unsigned char)((vfp <= vbp && *vfp)
+		      ? ((*pfp = *vfp++) == TAB) ? ' ' : *pfp
+		      : (*pfp = ' ')), 0);
+	while(++pfp <= pbp);
+    }
+
+    MoveCursor(dline.row, dline.col + (offset - dline.vbase));
+}
+
+
+
+/*----------------------------------------------------------------------
+    Check to see if the given command is reasonably valid
+  
+  Args:  ch -- the character to check
+
+ Result:  A valid command is returned, or a well know bad command is returned.
+ 
+ ---*/
+validatekeys(ch)
+     int  ch;
+{
+#ifndef _WINDOWS
+    if(F_ON(F_USE_FK,ps_global)) {
+	if(ch >= 'a' && ch <= 'z')
+	  return(KEY_JUNK);
+    } else {
+	if(ch >= PF1 && ch <= PF12)
+	  return(KEY_JUNK);
+    }
+#else
+    /*
+     * In windows menu items are bound to a single key command which
+     * gets inserted into the input stream as if the user had typed
+     * that key.  But all the menues are bonund to alphakey commands,
+     * not PFkeys.  to distinguish between a keyboard command and a
+     * menu command we insert a flag (KEY_MENU_FLAG) into the
+     * command value when setting up the bindings in
+     * configure_menu_items().  Here we strip that flag.
+     */
+    if(F_ON(F_USE_FK,ps_global)) {
+	if(ch >= 'a' && ch <= 'z' && !(ch & KEY_MENU_FLAG))
+	  return(KEY_JUNK);
+	ch &= ~ KEY_MENU_FLAG;
+    } else {
+	ch &= ~ KEY_MENU_FLAG;
+	if(ch >= PF1 && ch <= PF12)
+	  return(KEY_JUNK);
+    }
+#endif
+
+    return(ch);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Prepend config'd commands to keyboard input
+  
+  Args:  ch -- pointer to storage for returned command
+
+ Returns: TRUE if we're passing back a useful command, FALSE otherwise
+ 
+ ---*/
+int
+process_config_input(ch)
+    int *ch;
+{
+    static char firsttime = (char) 1;
+
+    /* commands in config file */
+    if(ps_global->initial_cmds && *ps_global->initial_cmds) {
+	/*
+	 * There are a few commands that may require keyboard input before
+	 * we enter the main command loop.  That input should be interactive,
+	 * not from our list of initial keystrokes.
+	 */
+	if(ps_global->dont_use_init_cmds)
+	  return(0);
+
+	*ch = *ps_global->initial_cmds++;
+	if(!*ps_global->initial_cmds && ps_global->free_initial_cmds){
+	    fs_give((void **)&(ps_global->free_initial_cmds));
+	    ps_global->initial_cmds = 0;
+	}
+
+	return(1);
+    }
+
+    if(firsttime) {
+	firsttime = 0;
+	if(ps_global->in_init_seq) {
+	    ps_global->in_init_seq = 0;
+	    ps_global->save_in_init_seq = 0;
+	    clear_cursor_pos();
+	    F_SET(F_USE_FK,ps_global,ps_global->orig_use_fkeys);
+	    /* draw screen */
+	    *ch = ctrl('L');
+	    return(1);
+	}
+    }
+
+    return(0);
+}
+
+
+#define	TAPELEN	256
+static int   tape[TAPELEN];
+static long  recorded = 0L;
+static short length  = 0;
+
+
+/*
+ * record user keystrokes
+ *
+ * Args:  ch -- the character to record
+ *
+ * Returns: character recorded
+ */
+int
+key_recorder(ch)
+    int ch;
+{
+    tape[recorded++ % TAPELEN] = ch;
+    if(length < TAPELEN)
+      length++;
+
+    return(ch);
+}
+
+
+/*
+ * playback user keystrokes
+ *
+ * Args:  ch -- ignored
+ *
+ * Returns: character played back or -1 to indicate end of tape
+ */
+int
+key_playback(ch)
+    int ch;
+{
+    ch = length ? tape[(recorded + TAPELEN - length--) % TAPELEN] : -1;
+    return(ch);
+}
+
+
+#ifdef	_WINDOWS
+int
+pcpine_oe_cursor(col, row)
+    int  col;
+    long row;
+{
+    return((row == g_mc_row
+	    && col >= g_mc_col
+	    && col < ps_global->ttyo->screen_cols)
+	    ? MSWIN_CURSOR_IBEAM
+	    : MSWIN_CURSOR_ARROW);
+}
+#endif
+
+/*======================================================================
+       Routines for painting the screen
+          - figure out what the terminal type is
+          - deal with screen size changes
+          - save special output sequences
+          - the usual screen clearing, cursor addressing and scrolling
+
+
+     This library gives programs the ability to easily access the
+     termcap information and write screen oriented and raw input
+     programs.  The routines can be called as needed, except that
+     to use the cursor / screen routines there must be a call to
+     InitScreen() first.  The 'Raw' input routine can be used
+     independently, however. (Elm comment)
+
+     Not sure what the original source of this code was. It got to be
+     here as part of ELM. It has been changed significantly from the
+     ELM version to be more robust in the face of inconsistent terminal
+     autowrap behaviour. Also, the unused functions were removed, it was
+     made to pay attention to the window size, and some code was made nicer
+     (in my opinion anyways). It also outputs the terminal initialization
+     strings and provides for minimal scrolling and detects terminals
+     with out enough capabilities. (Pine comment, 1990)
+
+
+This code used to pay attention to the "am" auto margin and "xn"
+new line glitch fields, but they were so often incorrect because many
+terminals can be configured to do either that we've taken it out. It
+now assumes it dosn't know where the cursor is after outputing in the
+80th column.
+*/
+
+#define	PUTLINE_BUFLEN	256
+
+static int   _lines, _columns;
+static int   _line  = FARAWAY;
+static int   _col   = FARAWAY;
+static int   _in_inverse;
+
+
+/*
+ * Internal prototypes
+ */
+static void moveabsolute PROTO((int, int));
+static void CursorUp PROTO((int));
+static void CursorDown PROTO((int));
+static void CursorLeft PROTO((int));
+static void CursorRight PROTO((int));
+
+
+extern char *_clearscreen, *_moveto, *_up, *_down, *_right, *_left,
+            *_setinverse, *_clearinverse,
+            *_cleartoeoln, *_cleartoeos,
+            *_startinsert, *_endinsert, *_insertchar, *_deletechar,
+            *_deleteline, *_insertline,
+            *_scrollregion, *_scrollup, *_scrolldown,
+            *_termcap_init, *_termcap_end;
+extern char term_name[];
+extern int  _tlines, _tcolumns, _bce;
+
+static enum  {NoScroll,UseScrollRegion,InsertDelete} _scrollmode;
+
+char  *tgoto();				/* and the goto stuff    */
+
+
+
+/*----------------------------------------------------------------------
+      Initialize the screen for output, set terminal type, etc
+
+   Args: tt -- Pointer to variable to store the tty output structure.
+
+ Result:  terminal size is discovered and set in pine state
+          termcap entry is fetched and stored
+          make sure terminal has adequate capabilites
+          evaluate scrolling situation
+          returns status of indicating the state of the screen/termcap entry
+
+      Returns:
+        -1 indicating no terminal name associated with this shell,
+        -2..-n  No termcap for this terminal type known
+	-3 Can't open termcap file 
+        -4 Terminal not powerful enough - missing clear to eoln or screen
+	                                       or cursor motion
+  ----*/
+int
+config_screen(tt)
+     struct ttyo **tt;
+{
+    struct ttyo *ttyo;
+    int          err;
+
+    ttyo = (struct ttyo *)fs_get(sizeof (struct ttyo));
+
+    _line  =  0;		/* where are we right now?? */
+    _col   =  0;		/* assume zero, zero...     */
+
+    /*
+     * This is an ugly hack to let vtterminalinfo know it's being called
+     * from pine.
+     */
+    Pmaster = (PICO *)1;
+    if(err = vtterminalinfo(F_ON(F_TCAP_WINS, ps_global)))
+      return(err);
+
+    Pmaster = NULL;
+
+    if(_tlines <= 0)
+      _lines = DEFAULT_LINES_ON_TERMINAL;
+    else
+      _lines = _tlines;
+
+    if(_tcolumns <= 0)
+      _columns = DEFAULT_COLUMNS_ON_TERMINAL;
+    else
+      _columns = _tcolumns;
+
+    get_windsize(ttyo);
+
+    ttyo->header_rows = 2;
+    ttyo->footer_rows = 3;
+
+    /*---- Make sure this terminal has the capability.
+        All we need is cursor address, clear line, and 
+        reverse video.
+      ---*/
+    if(_moveto == NULL || _cleartoeoln == NULL ||
+       _setinverse == NULL || _clearinverse == NULL) {
+          return(-4);
+    }
+
+    dprint(1, (debugfile, "Terminal type: %s\n", term_name));
+
+    /*------ Figure out scrolling mode -----*/
+    if(_scrollregion != NULL && _scrollregion[0] != '\0' &&
+    	  _scrollup != NULL && _scrollup[0] != '\0'){
+        _scrollmode = UseScrollRegion;
+    } else if(_insertline != NULL && _insertline[0] != '\0' &&
+       _deleteline != NULL && _deleteline[0] != '\0') {
+        _scrollmode = InsertDelete;
+    } else {
+        _scrollmode = NoScroll;
+    }
+    dprint(7, (debugfile, "Scroll mode: %s\n",
+               _scrollmode==NoScroll ? "No Scroll" :
+               _scrollmode==InsertDelete ? "InsertDelete" : "Scroll Regions"));
+
+    if (!_left) {
+    	_left = "\b";
+    }
+
+    *tt = ttyo;
+
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+   Initialize the screen with the termcap string 
+  ----*/
+void
+init_screen()
+{
+    if(_termcap_init)			/* init using termcap's rule */
+      tputs(_termcap_init, 1, outchar);
+
+    /* and make sure there are no scrolling surprises! */
+    BeginScroll(0, ps_global->ttyo->screen_rows - 1);
+
+    pico_toggle_color(0);
+    switch(ps_global->color_style){
+      case COL_NONE:
+      case COL_TERMDEF:
+	pico_set_color_options(0);
+	break;
+      case COL_ANSI8:
+	pico_set_color_options(COLOR_ANSI8_OPT);
+	break;
+      case COL_ANSI16:
+	pico_set_color_options(COLOR_ANSI16_OPT);
+	break;
+    }
+
+    if(ps_global->color_style != COL_NONE)
+      pico_toggle_color(1);
+
+    /* set colors */
+    if(pico_usingcolor()){
+	if(ps_global->VAR_NORM_FORE_COLOR)
+	  pico_nfcolor(ps_global->VAR_NORM_FORE_COLOR);
+
+	if(ps_global->VAR_NORM_BACK_COLOR)
+	  pico_nbcolor(ps_global->VAR_NORM_BACK_COLOR);
+
+	if(ps_global->VAR_REV_FORE_COLOR)
+	  pico_rfcolor(ps_global->VAR_REV_FORE_COLOR);
+
+	if(ps_global->VAR_REV_BACK_COLOR)
+	  pico_rbcolor(ps_global->VAR_REV_BACK_COLOR);
+
+	pico_set_normal_color();
+    }
+
+    /* and make sure icon text starts out consistent */
+    icon_text(NULL);
+    fflush(stdout);
+}
+        
+
+
+
+/*----------------------------------------------------------------------
+       Get the current window size
+  
+   Args: ttyo -- pointer to structure to store window size in
+
+  NOTE: we don't override the given values unless we know better
+ ----*/
+int
+get_windsize(ttyo)
+struct ttyo *ttyo;     
+{
+#ifdef RESIZING 
+    struct winsize win;
+
+    /*
+     * Get the window size from the tty driver.  If we can't fish it from
+     * stdout (pine's output is directed someplace else), try stdin (which
+     * *must* be associated with the terminal; see init_tty_driver)...
+     */
+    if(ioctl(1, TIOCGWINSZ, &win) >= 0			/* 1 is stdout */
+	|| ioctl(0, TIOCGWINSZ, &win) >= 0){		/* 0 is stdin */
+	if(win.ws_row)
+	  _lines = min(win.ws_row, MAX_SCREEN_ROWS);
+
+	if(win.ws_col)
+	  _columns  = min(win.ws_col, MAX_SCREEN_COLS);
+
+        dprint(2, (debugfile, "new win size -----<%d %d>------\n",
+                   _lines, _columns));
+    }
+    else
+      /* Depending on the OS, the ioctl() may have failed because
+	 of a 0 rows, 0 columns setting.  That happens on DYNIX/ptx 1.3
+	 (with a kernel patch that happens to involve the negotiation
+	 of window size in the telnet streams module.)  In this case
+	 the error is EINVARG.  Leave the default settings. */
+      dprint(1, (debugfile, "ioctl(TIOCWINSZ) failed :%s\n",
+		 error_description(errno)));
+#endif
+
+    ttyo->screen_cols = min(_columns, MAX_SCREEN_COLS);
+    ttyo->screen_rows = min(_lines, MAX_SCREEN_ROWS);
+    return(0);
+}
+
+
+/*----------------------------------------------------------------------
+      End use of the screen.
+      Print status message, if any.
+      Flush status messages.
+  ----*/
+void
+end_screen(message)
+    char *message;
+{
+    int footer_rows_was_one = 0;
+
+    dprint(9, (debugfile, "end_screen called\n"));
+
+    if(FOOTER_ROWS(ps_global) == 1){
+	footer_rows_was_one++;
+	FOOTER_ROWS(ps_global) = 3;
+	mark_status_unknown();
+    }
+
+    flush_status_messages(1);
+    blank_keymenu(_lines - 2, 0);
+    MoveCursor(_lines - 2, 0);
+
+    /* unset colors */
+    if(pico_hascolor())
+      pico_endcolor();
+
+    if(_termcap_end != NULL)
+      tputs(_termcap_end, 1, outchar);
+
+    if(message){
+	printf("%s\r\n", message);
+    }
+
+    if(F_ON(F_ENABLE_XTERM_NEWMAIL, ps_global) && getenv("DISPLAY"))
+      icon_text("xterm");
+
+    fflush(stdout);
+
+    if(footer_rows_was_one){
+	FOOTER_ROWS(ps_global) = 1;
+	mark_status_unknown();
+    }
+}
+    
+
+
+/*----------------------------------------------------------------------
+     Clear the terminal screen
+
+ Result: The screen is cleared
+         internal cursor position set to 0,0
+  ----*/
+void
+ClearScreen()
+{
+    _line = 0;	/* clear leaves us at top... */
+    _col  = 0;
+
+    if(ps_global->in_init_seq)
+      return;
+
+    mark_status_unknown();
+    mark_keymenu_dirty();
+    mark_titlebar_dirty();
+
+    /*
+     * If the terminal doesn't have back color erase, then we have to
+     * erase manually to preserve the background color.
+     */
+    if(pico_usingcolor() && (!_bce || !_clearscreen)){
+	ClearLines(0, _lines-1);
+        MoveCursor(0, 0);
+    }
+    else if(_clearscreen){
+	tputs(_clearscreen, 1, outchar);
+        moveabsolute(0, 0);	/* some clearscreens don't move correctly */
+    }
+}
+
+
+/*----------------------------------------------------------------------
+            Internal move cursor to absolute position
+
+  Args: col -- column to move cursor to
+        row -- row to move cursor to
+
+ Result: cursor is moved (variables, not updates)
+  ----*/
+
+static void
+moveabsolute(col, row)
+{
+
+	char *stuff, *tgoto();
+
+	stuff = tgoto(_moveto, col, row);
+	tputs(stuff, 1, outchar);
+}
+
+
+/*----------------------------------------------------------------------
+        Move the cursor to the row and column number
+  Args:  row number
+         column number
+
+ Result: Cursor moves
+         internal position updated
+  ----*/
+void
+MoveCursor(row, col)
+     int row, col;
+{
+    /** move cursor to the specified row column on the screen.
+        0,0 is the top left! **/
+
+    int scrollafter = 0;
+
+    /* we don't want to change "rows" or we'll mangle scrolling... */
+
+    if(ps_global->in_init_seq)
+      return;
+
+    if (col < 0)
+      col = 0;
+    if (col >= ps_global->ttyo->screen_cols)
+      col = ps_global->ttyo->screen_cols - 1;
+    if (row < 0)
+      row = 0;
+    if (row > ps_global->ttyo->screen_rows) {
+      if (col == 0)
+        scrollafter = row - ps_global->ttyo->screen_rows;
+      row = ps_global->ttyo->screen_rows;
+    }
+
+    if (!_moveto)
+    	return;
+
+    if (row == _line) {
+      if (col == _col)
+        return;				/* already there! */
+
+      else if (abs(col - _col) < 5) {	/* within 5 spaces... */
+        if (col > _col && _right)
+          CursorRight(col - _col);
+        else if (col < _col &&  _left)
+          CursorLeft(_col - col);
+        else
+          moveabsolute(col, row);
+      }
+      else 		/* move along to the new x,y loc */
+        moveabsolute(col, row);
+    }
+    else if (col == _col && abs(row - _line) < 5) {
+      if (row < _line && _up)
+        CursorUp(_line - row);
+      else if (_line > row && _down)
+        CursorDown(row - _line);
+      else
+        moveabsolute(col, row);
+    }
+    else if (_line == row-1 && col == 0) {
+      putchar('\n');	/* that's */
+      putchar('\r');	/*  easy! */
+    }
+    else 
+      moveabsolute(col, row);
+
+    _line = row;	/* to ensure we're really there... */
+    _col  = col;
+
+    if (scrollafter) {
+      while (scrollafter--) {
+        putchar('\n');
+        putchar('\r');
+
+      }
+    }
+
+    return;
+}
+
+
+
+/*----------------------------------------------------------------------
+         Newline, move the cursor to the start of next line
+
+ Result: Cursor moves
+  ----*/
+void
+NewLine()
+{
+   /** move the cursor to the beginning of the next line **/
+
+    Writechar('\n', 0);
+    Writechar('\r', 0);
+}
+
+
+
+/*----------------------------------------------------------------------
+        Move cursor up n lines with terminal escape sequence
+ 
+   Args:  n -- number of lines to go up
+
+ Result: cursor moves, 
+         internal position updated
+
+ Only for ttyout use; not outside callers
+  ----*/
+static void
+CursorUp(n)
+int n;
+{
+	/** move the cursor up 'n' lines **/
+	/** Calling function must check that _up is not null before calling **/
+
+    _line = (_line-n > 0? _line - n: 0);	/* up 'n' lines... */
+
+    while (n-- > 0)
+      tputs(_up, 1, outchar);
+}
+
+
+
+/*----------------------------------------------------------------------
+        Move cursor down n lines with terminal escape sequence
+ 
+    Arg: n -- number of lines to go down
+
+ Result: cursor moves, 
+         internal position updated
+
+ Only for ttyout use; not outside callers
+  ----*/
+static void
+CursorDown(n)
+     int          n;
+{
+    /** move the cursor down 'n' lines **/
+    /** Caller must check that _down is not null before calling **/
+
+    _line = (_line+n < ps_global->ttyo->screen_rows ? _line + n
+             : ps_global->ttyo->screen_rows);
+                                               /* down 'n' lines... */
+
+    while (n-- > 0)
+    	tputs(_down, 1, outchar);
+}
+
+
+
+/*----------------------------------------------------------------------
+        Move cursor left n lines with terminal escape sequence
+ 
+   Args:  n -- number of lines to go left
+
+ Result: cursor moves, 
+         internal position updated
+
+ Only for ttyout use; not outside callers
+  ----*/
+static void 
+CursorLeft(n)
+int n;
+{
+    /** move the cursor 'n' characters to the left **/
+    /** Caller must check that _left is not null before calling **/
+
+    _col = (_col - n> 0? _col - n: 0);	/* left 'n' chars... */
+
+    while (n-- > 0)
+      tputs(_left, 1, outchar);
+}
+
+
+/*----------------------------------------------------------------------
+        Move cursor right n lines with terminal escape sequence
+ 
+   Args:  number of lines to go right
+
+ Result: cursor moves, 
+         internal position updated
+
+ Only for ttyout use; not outside callers
+  ----*/
+static void 
+CursorRight(n)
+int n;
+{
+    /** move the cursor 'n' characters to the right (nondestructive) **/
+    /** Caller must check that _right is not null before calling **/
+
+    _col = (_col+n < ps_global->ttyo->screen_cols? _col + n :
+             ps_global->ttyo->screen_cols);	/* right 'n' chars... */
+
+    while (n-- > 0)
+      tputs(_right, 1, outchar);
+
+}
+
+
+
+/*----------------------------------------------------------------------
+       Insert character on screen pushing others right
+
+   Args: c --  character to insert
+
+ Result: charcter is inserted if possible
+         return -1 if it can't be done
+  ----------------------------------------------------------------------*/
+InsertChar(c)
+     int c;
+{
+    if(_insertchar != NULL && *_insertchar != '\0') {
+	tputs(_insertchar, 1, outchar);
+	Writechar(c, 0);
+    } else if(_startinsert != NULL && *_startinsert != '\0') {
+	tputs(_startinsert, 1, outchar);
+	Writechar(c, 0);
+	tputs(_endinsert, 1, outchar);
+    } else {
+	return(-1);
+    }
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+         Delete n characters from line, sliding rest of line left
+
+   Args: n -- number of characters to delete
+
+
+ Result: characters deleted on screen
+         returns -1 if it wasn't done
+  ----------------------------------------------------------------------*/
+DeleteChar(n)
+     int n;
+{
+    if(_deletechar == NULL || *_deletechar == '\0')
+      return(-1);
+
+    while(n) {
+	tputs(_deletechar, 1, outchar);
+	n--;
+    }
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Go into scrolling mode, that is set scrolling region if applicable
+
+   Args: top    -- top line of region to scroll
+         bottom -- bottom line of region to scroll
+	 (These are zero-origin numbers)
+
+ Result: either set scrolling region or
+         save values for later scrolling
+         returns -1 if we can't scroll
+
+ Unfortunately this seems to leave the cursor in an unpredictable place
+ at least the manuals don't say where, so we force it here.
+-----*/
+static int __t, __b;
+
+BeginScroll(top, bottom)
+     int top, bottom;
+{
+    char *stuff;
+
+    if(_scrollmode == NoScroll)
+      return(-1);
+
+    __t = top;
+    __b = bottom;
+    if(_scrollmode == UseScrollRegion){
+        stuff = tgoto(_scrollregion, bottom, top);
+        tputs(stuff, 1, outchar);
+        /*-- a location  very far away to force a cursor address --*/
+        _line = FARAWAY;
+        _col  = FARAWAY;
+    }
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+   End scrolling -- clear scrolling regions if necessary
+
+ Result: Clear scrolling region on terminal
+  -----*/
+void
+EndScroll()
+{
+    if(_scrollmode == UseScrollRegion && _scrollregion != NULL){
+	/* Use tgoto even though we're not cursor addressing because
+           the format of the capability is the same.
+         */
+        char *stuff = tgoto(_scrollregion, ps_global->ttyo->screen_rows -1, 0);
+	tputs(stuff, 1, outchar);
+        /*-- a location  very far away to force a cursor address --*/
+        _line = FARAWAY;
+        _col  = FARAWAY;
+    }
+}
+
+
+/* ----------------------------------------------------------------------
+    Scroll the screen using insert/delete or scrolling regions
+
+   Args:  lines -- number of lines to scroll, positive forward
+
+ Result: Screen scrolls
+         returns 0 if scroll succesful, -1 if not
+
+ positive lines goes foward (new lines come in at bottom
+ Leaves cursor at the place to insert put new text
+
+ 0,0 is the upper left
+ -----*/
+ScrollRegion(lines)
+    int lines;
+{
+    int l;
+
+    if(lines == 0)
+      return(0);
+
+    if(_scrollmode == UseScrollRegion) {
+	if(lines > 0) {
+	    MoveCursor(__b, 0);
+	    for(l = lines ; l > 0 ; l--)
+	      tputs((_scrolldown == NULL || _scrolldown[0] =='\0') ? "\n" :
+		    _scrolldown, 1, outchar);
+	} else {
+	    MoveCursor(__t, 0);
+	    for(l = -lines; l > 0; l--)
+	      tputs(_scrollup, 1, outchar);
+	}
+    } else if(_scrollmode == InsertDelete) {
+	if(lines > 0) {
+	    MoveCursor(__t, 0);
+	    for(l = lines; l > 0; l--) 
+	      tputs(_deleteline, 1, outchar);
+	    MoveCursor(__b, 0);
+	    for(l = lines; l > 0; l--) 
+	      tputs(_insertline, 1, outchar);
+	} else {
+	    for(l = -lines; l > 0; l--) {
+	        MoveCursor(__b, 0);
+	        tputs(_deleteline, 1, outchar);
+		MoveCursor(__t, 0);
+		tputs(_insertline, 1, outchar);
+	    }
+	}
+    } else {
+	return(-1);
+    }
+    fflush(stdout);
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Write a character to the screen, keeping track of cursor position
+
+   Args: ch -- character to output
+
+ Result: character output
+         cursor position variables updated
+  ----*/
+void
+Writechar(ch, new_esc_len)
+     register unsigned int ch;
+     int      new_esc_len;
+{
+    static   int esc_len = 0;
+
+    if(ps_global->in_init_seq				/* silent */
+       || (F_ON(F_BLANK_KEYMENU, ps_global)		/* or bottom, */
+	   && !esc_len					/* right cell */
+	   && _line + 1 == ps_global->ttyo->screen_rows
+	   && _col + 1 == ps_global->ttyo->screen_cols))
+      return;
+
+    if(!iscntrl(ch & 0x7f)){
+	putchar(ch);
+	if(esc_len > 0)
+	  esc_len--;
+	else
+	  _col++;
+    }
+    else{
+	switch(ch){
+	  case LINE_FEED:
+	    /*-- Don't have to watch out for auto wrap or newline glitch
+	      because we never let it happen. See below
+	      ---*/
+	    putchar('\n');
+	    _line = min(_line+1,ps_global->ttyo->screen_rows);
+	    esc_len = 0;
+	    break;
+
+	  case RETURN :		/* move to column 0 */
+	    putchar('\r');
+	    _col = 0;
+	    esc_len = 0;
+	    break;
+
+	  case BACKSPACE :	/* move back a space if not in column 0 */
+	    if(_col != 0) {
+		putchar('\b');
+		_col--;
+	    }			/* else BACKSPACE does nothing */
+
+	    break;
+
+	  case BELL :		/* ring the bell but don't advance _col */
+	    putchar(ch);
+	    break;
+
+	  case TAB :		/* if a tab, output it */
+	    do			/* BUG? ignores tty driver's spacing */
+	      putchar(' ');
+	    while(_col < ps_global->ttyo->screen_cols - 1
+		  && ((++_col)&0x07) != 0);
+	    break;
+
+	  case ESCAPE :
+	    /* If we're outputting an escape here, it may be part of an iso2022
+	       escape sequence in which case take up no space on the screen.
+	       Unfortunately such sequences are variable in length.
+	       */
+	    esc_len = new_esc_len - 1;
+	    putchar(ch);
+	    break;
+
+	  default :		/* Change remaining control characters to ? */
+	    if(F_ON(F_PASS_CONTROL_CHARS, ps_global))
+	      putchar(ch);
+	    else
+	      putchar('?');
+
+	    if(esc_len > 0)
+	      esc_len--;
+	    else
+	      _col++;
+
+	    break;
+	}
+    }
+
+
+    /* Here we are at the end of the line. We've decided to make no
+       assumptions about how the terminal behaves at this point.
+       What can happen now are the following
+           1. Cursor is at start of next line, and next character will
+              apear there. (autowrap, !newline glitch)
+           2. Cursor is at start of next line, and if a newline is output
+              it'll be ignored. (autowrap, newline glitch)
+           3. Cursor is still at end of line and next char will apear
+              there over the top of what is there now (no autowrap).
+       We ignore all this and force the cursor to the next line, just 
+       like case 1. A little expensive but worth it to avoid problems
+       with terminals configured so they don't match termcap
+       */
+    if(_col == ps_global->ttyo->screen_cols) {
+        _col = 0;
+        if(_line + 1 < ps_global->ttyo->screen_rows)
+	  _line++;
+
+	moveabsolute(_col, _line);
+    }
+}
+
+
+
+/*----------------------------------------------------------------------
+       Write string to screen at current cursor position
+
+   Args: string -- string to be output
+
+ Result: String written to the screen
+  ----*/
+void
+Write_to_screen(string)				/* UNIX */
+      register char *string; 
+{
+    while(*string)
+      Writechar((unsigned char) *string++, 0);
+}
+
+
+/*----------------------------------------------------------------------
+       Write no more than n chars of string to screen at current cursor position
+
+   Args: string -- string to be output
+	      n -- number of chars to output
+
+ Result: String written to the screen
+  ----*/
+void
+Write_to_screen_n(string, n)				/* UNIX */
+      register char *string; 
+      int            n;
+{
+    while(n-- && *string)
+      Writechar((unsigned char) *string++, 0);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Clear screen to end of line on current line
+
+ Result: Line is cleared
+  ----*/
+void
+CleartoEOLN()
+{
+    int   c, starting_col, starting_line;
+    char *last_bg_color;
+
+    /*
+     * If the terminal doesn't have back color erase, then we have to
+     * erase manually to preserve the background color.
+     */
+    if(pico_usingcolor() && (!_bce || !_cleartoeoln)){
+	starting_col  = _col;
+	starting_line = _line;
+	last_bg_color = pico_get_last_bg_color();
+	pico_set_nbg_color();
+	for(c = _col; c < _columns; c++)
+	  Writechar(' ', 0);
+	
+        MoveCursor(starting_line, starting_col);
+	if(last_bg_color){
+	    (void)pico_set_bg_color(last_bg_color);
+	    fs_give((void **)&last_bg_color);
+	}
+    }
+    else if(_cleartoeoln)
+      tputs(_cleartoeoln, 1, outchar);
+}
+
+
+
+/*----------------------------------------------------------------------
+     Clear screen to end of screen from current point
+
+ Result: screen is cleared
+  ----*/
+CleartoEOS()
+{
+    int starting_col, starting_line;
+
+    /*
+     * If the terminal doesn't have back color erase, then we have to
+     * erase manually to preserve the background color.
+     */
+    if(pico_usingcolor() && (!_bce || !_cleartoeos)){
+	starting_col  = _col;
+	starting_line = _line;
+        CleartoEOLN();
+	ClearLines(_line+1, _lines-1);
+        MoveCursor(starting_line, starting_col);
+    }
+    else if(_cleartoeos)
+      tputs(_cleartoeos, 1, outchar);
+}
+
+
+
+/*----------------------------------------------------------------------
+     function to output character used by termcap
+
+   Args: c -- character to output
+
+ Result: character output to screen via stdio
+  ----*/
+void
+outchar(c)
+int c;
+{
+	/** output the given character.  From tputs... **/
+	/** Note: this CANNOT be a macro!              **/
+
+	putc((unsigned char)c, stdout);
+}
+
+
+
+/*----------------------------------------------------------------------
+     function to output string such that it becomes icon text
+
+   Args: s -- string to write
+
+ Result: string indicated become our "icon" text
+  ----*/
+void
+icon_text(s)
+    char *s;
+{
+    static char *old_s;
+    static enum {ukn, yes, no} xterm;
+
+    if(xterm == ukn)
+      xterm = (getenv("DISPLAY") != NULL) ? yes : no;
+
+    if(F_ON(F_ENABLE_XTERM_NEWMAIL,ps_global) && xterm == yes && (s || old_s)){
+	fputs("\033]1;", stdout);
+	fputs((old_s = s) ? s : ps_global->pine_name, stdout);
+	fputs("\007", stdout);
+	fflush(stdout);
+    }
+}
+
+
+#ifdef	_WINDOWS
+#line 3 "osdep/termout.gen"
+#endif
+
+/*
+ * Generic tty output routines...
+ */
+
+/*----------------------------------------------------------------------
+      Printf style output line to the screen at given position, 0 args
+
+  Args:  x -- column position on the screen
+         y -- row position on the screen
+         line -- line of text to output
+
+ Result: text is output
+         cursor position is update
+  ----*/
+void
+PutLine0(x, y, line)
+    int            x,y;
+    register char *line;
+{
+    MoveCursor(x,y);
+    Write_to_screen(line);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Output line of length len to the display observing embedded attributes
+
+ Args:  x      -- column position on the screen
+        y      -- column position on the screen
+        line   -- text to be output
+        length -- length of text to be output
+
+ Result: text is output
+         cursor position is updated
+  ----------------------------------------------------------------------*/
+void
+PutLine0n8b(x, y, line, length, handles)
+    int            x, y, length;
+    register char *line;
+    HANDLE_S	  *handles;
+{
+    unsigned char c;
+#ifdef	_WINDOWS
+    int hkey = 0;
+#endif
+
+    MoveCursor(x,y);
+    while(length-- && (c = (unsigned char)*line++)){
+
+	if(c == (unsigned char)TAG_EMBED && length){
+	    length--;
+	    switch(*line++){
+	      case TAG_INVON :
+		StartInverse();
+		break;
+	      case TAG_INVOFF :
+		EndInverse();
+		break;
+	      case TAG_BOLDON :
+		StartBold();
+		break;
+	      case TAG_BOLDOFF :
+		EndBold();
+		break;
+	      case TAG_ULINEON :
+		StartUnderline();
+		break;
+	      case TAG_ULINEOFF :
+		EndUnderline();
+		break;
+	      case TAG_HANDLE :
+		length -= *line + 1;	/* key length plus length tag */
+		if(handles){
+		    int  key, n;
+
+		    for(key = 0, n = *line++; n; n--) /* forget Horner? */
+		      key = (key * 10) + (*line++ - '0');
+
+#if	_WINDOWS
+		    hkey = key;
+#endif
+
+		    if(key == handles->key){
+			if(pico_usingcolor() &&
+			   ps_global->VAR_SLCTBL_FORE_COLOR &&
+			   ps_global->VAR_SLCTBL_BACK_COLOR){
+			    pico_set_normal_color();
+			}
+			else
+			  EndBold();
+
+			StartInverse();
+		    }
+		}
+		else{
+		    /* BUG: complain? */
+		    line += *line + 1;
+		}
+
+		break;
+	      case TAG_FGCOLOR :
+		if(length < RGBLEN){
+		    Writechar(TAG_EMBED, 0);
+		    Writechar(*(line-1), 0);
+		    break;
+		}
+
+		(void)pico_set_fg_color(line);
+		length -= RGBLEN;
+		line += RGBLEN;
+		break;
+	      case TAG_BGCOLOR :
+		if(length < RGBLEN){
+		    Writechar(TAG_EMBED, 0);
+		    Writechar(*(line-1), 0);
+		    break;
+		}
+
+		(void)pico_set_bg_color(line);
+		length -= RGBLEN;
+		line += RGBLEN;
+		break;
+	      default :		/* literal "embed" char? */
+		Writechar(TAG_EMBED, 0);
+		Writechar(*(line-1), 0);
+		break;
+	    }					/* tag with handle, skip it */
+	}	
+	else if(c == '\033')			/* check for iso-2022 escape */
+	  Writechar(c, match_escapes(line));
+	else
+	  Writechar(c, 0);
+    }
+
+
+#if	_WINDOWS_X
+    if(hkey) {
+	char *tmp_file = NULL, ext[32], mtype[128];
+	HANDLE_S *h;
+	extern HANDLE_S *get_handle (HANDLE_S *, int);
+
+	if((h = get_handle(handles, hkey)) && h->type == Attach){
+	    ext[0] = '\0';
+	    strcpy(mtype, body_type_names(h->h.attach->body->type));
+	    if (h->h.attach->body->subtype) {
+		strcat (mtype, "/");
+		strcat (mtype, h->h.attach->body->subtype);
+	    }
+
+	    if(!set_mime_extension_by_type(ext, mtype)){
+		char *namep, *dotp, *p;
+
+		if(namep = rfc2231_get_param(h->h.attach->body->parameter,
+					     "name", NULL, NULL)){
+		    for(dotp = NULL, p = namep; *p; p++)
+		      if(*p == '.')
+			dotp = p + 1;
+
+		    if(dotp && strlen(dotp) < sizeof(ext) - 1)
+		      strcpy(ext, dotp);
+
+		    fs_give((void **) &namep);
+		}
+	    }
+
+	    if(ext[0] && (tmp_file = temp_nam_ext(NULL, "im", ext))){
+		FILE *f = fopen(tmp_file, "w");
+
+		mswin_registericon(x, h->key, tmp_file);
+
+		fclose(f);
+		unlink(tmp_file);
+		fs_give((void **)&tmp_file);
+	    }
+	}
+    }
+#endif
+}
+
+
+/*----------------------------------------------------------------------
+      Printf style output line to the screen at given position, 1 arg
+
+ Input:  position on the screen
+         line of text to output
+
+ Result: text is output
+         cursor position is update
+  ----------------------------------------------------------------------*/
+void
+/*VARARGS2*/
+PutLine1(x, y, line, arg1)
+    int   x, y;
+    char *line;
+    void *arg1;
+{
+    char buffer[PUTLINE_BUFLEN];
+
+    sprintf(buffer, line, arg1);
+    PutLine0(x, y, buffer);
+}
+
+
+/*----------------------------------------------------------------------
+      Printf style output line to the screen at given position, 2 args
+
+ Input:  position on the screen
+         line of text to output
+
+ Result: text is output
+         cursor position is update
+  ----------------------------------------------------------------------*/
+void
+/*VARARGS3*/
+PutLine2(x, y, line, arg1, arg2)
+    int   x, y;
+    char *line;
+    void *arg1, *arg2;
+{
+    char buffer[PUTLINE_BUFLEN];
+
+    sprintf(buffer, line, arg1, arg2);
+    PutLine0(x, y, buffer);
+}
+
+
+/*----------------------------------------------------------------------
+      Printf style output line to the screen at given position, 3 args
+
+ Input:  position on the screen
+         line of text to output
+
+ Result: text is output
+         cursor position is update
+  ----------------------------------------------------------------------*/
+void
+/*VARARGS4*/
+PutLine3(x, y, line, arg1, arg2, arg3)
+    int   x, y;
+    char *line;
+    void *arg1, *arg2, *arg3;
+{
+    char buffer[PUTLINE_BUFLEN];
+
+    sprintf(buffer, line, arg1, arg2, arg3);
+    PutLine0(x, y, buffer);
+}
+
+
+/*----------------------------------------------------------------------
+      Printf style output line to the screen at given position, 4 args
+
+ Args:  x -- column position on the screen
+        y -- column position on the screen
+        line -- printf style line of text to output
+
+ Result: text is output
+         cursor position is update
+  ----------------------------------------------------------------------*/
+void
+/*VARARGS5*/
+PutLine4(x, y, line, arg1, arg2, arg3, arg4)
+     int   x, y;
+     char *line;
+     void *arg1, *arg2, *arg3, *arg4;
+{
+    char buffer[PUTLINE_BUFLEN];
+
+    sprintf(buffer, line, arg1, arg2, arg3, arg4);
+    PutLine0(x, y, buffer);
+}
+
+
+
+/*----------------------------------------------------------------------
+      Printf style output line to the screen at given position, 5 args
+
+ Args:  x -- column position on the screen
+        y -- column position on the screen
+        line -- printf style line of text to output
+
+ Result: text is output
+         cursor position is update
+  ----------------------------------------------------------------------*/
+void
+/*VARARGS6*/
+PutLine5(x, y, line, arg1, arg2, arg3, arg4, arg5)
+     int   x, y;
+     char *line;
+     void *arg1, *arg2, *arg3, *arg4, *arg5;
+{
+    char buffer[PUTLINE_BUFLEN];
+
+    sprintf(buffer, line, arg1, arg2, arg3, arg4, arg5);
+    PutLine0(x, y, buffer);
+}
+
+
+
+/*----------------------------------------------------------------------
+       Output a line to the screen, centered
+
+  Input:  Line number to print on, string to output
+  
+ Result:  String is output to screen
+          Returns column number line is output on
+  ----------------------------------------------------------------------*/
+int
+Centerline(line, string)
+    int   line;
+    char *string;
+{
+    register int length, col;
+
+    length = strlen(string);
+
+    if (length > ps_global->ttyo->screen_cols)
+      col = 0;
+    else
+      col = (ps_global->ttyo->screen_cols - length) / 2;
+
+    PutLine0(line, col, string);
+    return(col);
+}
+
+
+
+/*----------------------------------------------------------------------
+     Clear specified line on the screen
+
+ Result: The line is blanked and the cursor is left at column 0.
+
+  ----*/
+void
+ClearLine(n)
+    int n;
+{
+    if(ps_global->in_init_seq)
+      return;
+
+    MoveCursor(n, 0);
+    CleartoEOLN();
+}
+
+
+
+/*----------------------------------------------------------------------
+     Clear specified lines on the screen
+
+ Result: The lines starting at 'x' and ending at 'y' are blanked
+	 and the cursor is left at row 'x', column 0
+
+  ----*/
+void
+ClearLines(x, y)
+    int x, y;
+{
+    int i;
+
+    for(i = x; i <= y; i++)
+      ClearLine(i);
+
+    MoveCursor(x, 0);
+}
+
+
+
+/*----------------------------------------------------------------------
+    Indicate to the screen painting here that the position of the cursor
+ has been disturbed and isn't where these functions might think.
+ ----*/
+void
+clear_cursor_pos()
+{
+    _line = FARAWAY;
+    _col  = FARAWAY;
+}
+
+