Initial Alpine Version

1 files changed, 3271 insertions, 0 deletions

diff --git a/pith/mailview.c b/pith/mailview.c
new file mode 100644
index 00000000..40728aab
--- /dev/null
+++ b/pith/mailview.c
@@ -0,0 +1,3271 @@
+#if !defined(lint) && !defined(DOS)
+static char rcsid[] = "$Id: mailview.c 1266 2009-07-14 18:39:12Z hubert@u.washington.edu $";
+#endif
+
+/*
+ * ========================================================================
+ * Copyright 2006-2009 University of Washington
+ * Copyright 2013 Eduardo Chappa
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * ========================================================================
+ */
+
+/*======================================================================
+
+     mailview.c
+     Implements message data gathering and formatting
+
+  ====*/
+
+
+#include "headers.h"
+#include "../pith/mailview.h"
+#include "../pith/conf.h"
+#include "../pith/msgno.h"
+#include "../pith/editorial.h"
+#include "../pith/mimedesc.h"
+#include "../pith/margin.h"
+#include "../pith/color.h"
+#include "../pith/strlst.h"
+#include "../pith/charset.h"
+#include "../pith/status.h"
+#include "../pith/maillist.h"
+#include "../pith/mailcmd.h"
+#include "../pith/mailindx.h"
+#include "../pith/imap.h"
+#include "../pith/detach.h"
+#include "../pith/text.h"
+#include "../pith/url.h"
+#include "../pith/rfc2231.h"
+#include "../pith/list.h"
+#include "../pith/stream.h"
+#include "../pith/send.h"
+#include "../pith/filter.h"
+#include "../pith/string.h"
+#include "../pith/ablookup.h"
+#include "../pith/escapes.h"
+#include "../pith/keyword.h"
+#include "../pith/smime.h"
+
+
+#define FBUF_LEN	(50)
+
+#define	ISRFCEOL(S)    (*(S) == '\015' && *((S)+1) == '\012')
+
+
+/*
+ *  This is a list of header fields that are represented canonically
+ *  by the c-client's ENVELOPE structure.  The list is used by the
+ *  two functions below to decide if a given field is included in this
+ *  set.
+ */
+static struct envelope_s {
+    char *name;
+    long val;
+} envelope_hdrs[] = {
+    {"from",		FE_FROM},
+    {"sender",		FE_SENDER},
+    {"date",		FE_DATE},
+    {"to",		FE_TO},
+    {"cc",		FE_CC},
+    {"bcc",		FE_BCC},
+    {"newsgroups",	FE_NEWSGROUPS},
+    {"subject",		FE_SUBJECT},
+    {"message-id",	FE_MESSAGEID},
+    {"reply-to",	FE_REPLYTO},
+    {"followup-to",	FE_FOLLOWUPTO},
+    {"in-reply-to",	FE_INREPLYTO},
+/*  {"return-path",	FE_RETURNPATH},      not usually filled in */
+    {"references",	FE_REFERENCES},
+    {NULL,		0}
+};
+
+
+/*
+ * Hook for optional display of rfc2369 content
+ */
+int  (*pith_opt_rfc2369_editorial)(long, HANDLE_S **, int, int, gf_io_t);
+
+
+
+
+/*
+ * Internal prototypes
+ */
+int	    format_blip_seen(long);
+int	    is_an_env_hdr(char *);
+int         is_an_addr_hdr(char *);
+void	    format_env_hdr(MAILSTREAM *, long, char *, ENVELOPE *,
+			   fmt_env_t, gf_io_t, char *, char *, int);
+int	    delineate_this_header(char *, char *, char **, char **);
+char	   *url_embed(int);
+int         color_headers(long, char *, LT_INS_S **, void *);
+int	    url_hilite_hdr(long, char *, LT_INS_S **, void *);
+int	    pad_to_right_edge(long, char *, LT_INS_S **, void *);
+int	    url_bogus_imap(char **, char *, char *);
+int	    format_raw_header(MAILSTREAM *, long, char *, gf_io_t);
+void	    format_envelope(MAILSTREAM *, long, char *, ENVELOPE *,
+			    gf_io_t, long, char *, int);
+int         any_hdr_color(char *);
+void	    format_addr_string(MAILSTREAM *, long, char *, char *,
+			       ADDRESS *, int, char *, gf_io_t);
+void        pine_rfc822_write_address_noquote(ADDRESS *, gf_io_t, int *);
+void	    format_newsgroup_string(char *, char *, int, gf_io_t);
+int	    format_raw_hdr_string(char *, char *, gf_io_t, char *, int);
+int	    format_env_puts(char *, gf_io_t);
+int	    find_field(char **, char *, size_t);
+int	    embed_color(COLOR_PAIR *, gf_io_t);
+COLOR_PAIR *get_cur_embedded_color(void);
+void        clear_cur_embedded_color(void);
+
+
+
+
+/*----------------------------------------------------------------------
+   Format a message message for viewing
+
+ Args: msgno -- The number of the message to view
+       env   -- pointer to the message's envelope
+       body  -- pointer to the message's body
+       handlesp -- address of pointer to the message's handles
+       flgs  -- possible flags listed in pith/mailview.h with
+		prefix FM_
+       pc    -- write to this function
+
+Result: Returns true if no problems encountered, else false.
+
+First the envelope is formatted; next a list of all attachments is
+formatted if there is more than one. Then all the body parts are
+formatted, fetching them as needed. This includes headers of included
+message. Richtext is also formatted. An entry is made in the text for
+parts that are not displayed or can't be displayed.
+
+ ----*/    
+int
+format_message(long int msgno, ENVELOPE *env, struct mail_bodystruct *body,
+	       HANDLE_S **handlesp, int flgs, gf_io_t pc)
+{
+    char     *decode_err = NULL;
+    HEADER_S  h;
+    int       width;
+
+    clear_cur_embedded_color();
+
+    if(!(flgs & FM_DISPLAY))
+      flgs |= FM_NOINDENT;
+
+    width = (flgs & FM_DISPLAY) ? ps_global->ttyo->screen_cols : 80;
+
+    /*---- format and copy envelope ----*/
+    if(!(flgs & FM_NOEDITORIAL)){
+	if(ps_global->full_header == 1)
+	  /* TRANSLATORS: User is viewing a message and all the quoted text is
+	     being shown. */
+	  q_status_message(SM_INFO, 0, 3, _("All quoted text being included"));
+	else if(ps_global->full_header == 2)
+	  q_status_message(SM_INFO, 0, 3,
+			   /* TRANSLATORS: User is viewing a message and all of
+			      the header text is being shown. */
+			   _("Full header mode ON.  All header text being included"));
+    }
+
+    HD_INIT(&h, ps_global->VAR_VIEW_HEADERS, ps_global->view_all_except, FE_DEFAULT);
+    switch(format_header(ps_global->mail_stream, msgno, NULL,
+			 env, &h, NULL, handlesp, flgs, NULL, pc)){
+			      
+      case -1 :			/* write error */
+	goto write_error;
+
+      case 1 :			/* fetch error */
+	if(!(gf_puts("[ Error fetching header ]",  pc)
+	     && !gf_puts(NEWLINE, pc)))
+	  goto write_error;
+
+	break;
+    }
+
+    if(!(body == NULL 
+	 || (ps_global->full_header == 2
+	     && F_ON(F_ENABLE_FULL_HDR_AND_TEXT, ps_global))))
+      format_attachment_list(msgno, body, handlesp, flgs, width, pc);
+
+    /* write delimiter and body */
+    if(gf_puts(NEWLINE, pc)
+       && (decode_err = format_body(msgno, body, handlesp, &h, flgs, width, pc)) == NULL)
+      return(1);
+
+
+  write_error:
+
+    if(!(flgs & FM_DISPLAY))
+      q_status_message1(SM_ORDER, 3, 4, _("Error writing message: %s"),
+			decode_err ? decode_err : error_description(errno));
+
+    return(0);
+}
+
+
+char *
+format_body(long int msgno, BODY *body, HANDLE_S **handlesp, HEADER_S *hp, int flgs, int width, gf_io_t pc)
+{
+    int		  filt_only_c0 = 0, wrapflags, error_found = 0;
+    int		  is_in_sig = OUT_SIG_BLOCK;
+    char	 *charset, *decode_err = NULL, *tmp1, *description;
+    ATTACH_S	 *a;
+    URL_HILITE_S  uh;
+    gf_io_t	  gc;
+
+    if(body == NULL 
+       || (ps_global->full_header == 2
+	   && F_ON(F_ENABLE_FULL_HDR_AND_TEXT, ps_global))) {
+
+        /*--- Server is not an IMAP2bis, It can't parse MIME
+              so we just show the text here. Hopefully the 
+              message isn't a MIME message 
+          ---*/
+	void *text2;
+
+        if((text2 = (void *)pine_mail_fetch_text(ps_global->mail_stream,
+						msgno, NULL, NULL, NIL)) != NULL){
+
+ 	    if(!gf_puts(NEWLINE, pc))		/* write delimiter */
+	      return("Write Error");
+
+	    gf_set_readc(&gc, text2, (unsigned long)strlen(text2), CharStar, 0);
+	    gf_filter_init();
+
+	    /*
+	     * We need to translate the message
+	     * into UTF-8, but that's trouble in the full header case
+	     * because we don't know what to translate from. We'll just
+	     * take a guess by looking for the first text part and
+	     * using its charset.
+	     */
+	    if(body && body->type == TYPETEXT)
+	      charset = parameter_val(body->parameter, "charset");
+	    else if(body && body->type == TYPEMULTIPART && body->nested.part
+		    && body->nested.part->body.type == TYPETEXT)
+	      charset = parameter_val(body->nested.part->body.parameter, "charset");
+	    else
+	      charset = ps_global->display_charmap;
+
+	    if(strucmp(charset, "us-ascii") && strucmp(charset, "utf-8")){
+		/* transliterate message text to UTF-8 */
+		gf_link_filter(gf_utf8, gf_utf8_opt(charset));
+	    }
+
+	    /* link in filters, similar to what is done in decode_text() */
+	    if(!ps_global->pass_ctrl_chars){
+		gf_link_filter(gf_escape_filter, NULL);
+		filt_only_c0 = 1;
+		gf_link_filter(gf_control_filter,
+			       gf_control_filter_opt(&filt_only_c0));
+	    }
+
+	    gf_link_filter(gf_tag_filter, NULL);
+
+	    if((F_ON(F_VIEW_SEL_URL, ps_global)
+		|| F_ON(F_VIEW_SEL_URL_HOST, ps_global)
+		|| F_ON(F_SCAN_ADDR, ps_global))
+	       && handlesp){
+		gf_link_filter(gf_line_test,
+			       gf_line_test_opt(url_hilite,
+					        gf_url_hilite_opt(&uh,handlesp,0)));
+	    }
+
+	    if((flgs & FM_DISPLAY)
+	       && !(flgs & FM_NOCOLOR)
+	       && pico_usingcolor()
+	       && ps_global->VAR_SIGNATURE_FORE_COLOR
+	       && ps_global->VAR_SIGNATURE_BACK_COLOR){
+		gf_link_filter(gf_line_test, gf_line_test_opt(color_signature, &is_in_sig));
+	    }
+
+	    if((flgs & FM_DISPLAY)
+	       && !(flgs & FM_NOCOLOR)
+	       && pico_usingcolor()
+	       && ps_global->VAR_QUOTE1_FORE_COLOR
+	       && ps_global->VAR_QUOTE1_BACK_COLOR){
+		gf_link_filter(gf_line_test, gf_line_test_opt(color_a_quote, NULL));
+	    }
+
+	    if(!(flgs & FM_NOWRAP)){
+		wrapflags = (flgs & FM_DISPLAY) ? (GFW_HANDLES|GFW_SOFTHYPHEN) : GFW_NONE;
+		if(flgs & FM_DISPLAY
+		   && !(flgs & FM_NOCOLOR)
+		   && pico_usingcolor())
+		  wrapflags |= GFW_USECOLOR;
+		gf_link_filter(gf_wrap, gf_wrap_filter_opt(width, width,
+							   (flgs & FM_NOINDENT)
+							      ? NULL : format_view_margin(),
+							   0,
+							   wrapflags));
+	    }
+
+	    gf_link_filter(gf_nvtnl_local, NULL);
+	    if((decode_err = gf_pipe(gc, pc)) != NULL){
+		/* TRANSLATORS: There was an error putting together a message for
+		   viewing. The arg is the description of the error. */
+                snprintf(tmp_20k_buf, SIZEOF_20KBUF, _("Formatting error: %s"), decode_err);
+		tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';
+		if(gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)
+		   && !format_editorial(tmp_20k_buf, width, flgs, handlesp, pc)
+		   && gf_puts(NEWLINE, pc))
+		  decode_err = NULL;
+		else
+		  return(decode_err);
+	    }
+	}
+
+	if(!text2){
+	    if(!gf_puts(NEWLINE, pc)
+	       || !gf_puts(_("    [ERROR fetching text of message]"), pc)
+	       || !gf_puts(NEWLINE, pc)
+	       || !gf_puts(NEWLINE, pc))
+	      return("Write Error");
+	}
+    }
+    else{
+	int show_parts = 0;
+
+	/*======== Now loop through formatting all the parts =======*/
+	for(a = ps_global->atmts; a->description != NULL; a++) {
+
+	    if(a->body->type == TYPEMULTIPART){
+#ifdef SMIME
+		if(strucmp(a->body->subtype, OUR_PKCS7_ENCLOSURE_SUBTYPE)==0){
+		    if(a->description){
+			if(!(!format_editorial(a->description, width, flgs, handlesp, pc)
+			     && gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)))
+			  return("Write Error");
+		    }
+		}
+#endif /* SMIME */
+		continue;
+	    }
+
+	    if(!a->shown) {
+		if(a->suppress_editorial)
+		  continue;
+
+		if(!(flgs & FM_NOEDITORIAL)
+		   && (!gf_puts(NEWLINE, pc)
+		       || (decode_err = part_desc(a->number, a->body,
+						  (flgs & FM_DISPLAY)
+						  ? (a->can_display != MCD_NONE)
+						  ? 1 : 2
+						  : 3, width, flgs, pc))))
+		  return("Write Error");
+
+		continue;
+	    } 
+
+	    switch(a->body->type){
+
+	      case TYPETEXT:
+		/*
+		 * If a message is multipart *and* the first part of it
+		 * is text *and that text is empty, there is a good chance that
+		 * there was actually something there that c-client was
+		 * unable to parse.  Here we report the empty message body
+		 * and insert the raw RFC822.TEXT (if full-headers are
+		 * on).
+		 */
+		if(body->type == TYPEMULTIPART
+		   && a == ps_global->atmts
+		   && a->body->size.bytes == 0
+		   && F_ON(F_ENABLE_FULL_HDR, ps_global)){
+		    char *err = NULL;
+
+		    snprintf(tmp_20k_buf, SIZEOF_20KBUF,
+			     "Empty or malformed message%s.",
+			     ps_global->full_header == 2 
+			     ? ". Displaying raw text"
+			     : ". Use \"H\" to see raw text");
+		    tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';
+
+		    if(!(gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)
+			 && !format_editorial(tmp_20k_buf, width, flgs, handlesp, pc)
+			 && gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)))
+		      return("Write Error");
+
+		    if(ps_global->full_header == 2
+		       && (err = detach_raw(ps_global->mail_stream, msgno,
+					    a->number, pc, flgs))){
+			snprintf(tmp_20k_buf, SIZEOF_20KBUF,
+				 "%s%s  [ Formatting error: %s ]%s%s",
+				 NEWLINE, NEWLINE, err, NEWLINE, NEWLINE);
+			tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';
+			if(!gf_puts(tmp_20k_buf, pc))
+			  return("Write Error");
+		    }
+
+		    break;
+		}
+
+		/*
+		 * Don't write our delimiter if this text part is
+		 * the first part of a message/rfc822 segment...
+		 */
+		if(show_parts && a != ps_global->atmts 
+		   && !((a[-1].body && a[-1].body->type == TYPEMESSAGE)
+#ifdef SMIME
+		       || (a[-1].body->type == TYPEMULTIPART
+		           && a[-1].body->subtype
+			   && (strucmp(a[-1].body->subtype, OUR_PKCS7_ENCLOSURE_SUBTYPE)==0)
+			   && &a[-1] != ps_global->atmts
+			   && a[-2].body && a[-2].body->type == TYPEMESSAGE)
+#endif /* SMIME */
+		       )
+		   && !(flgs & FM_NOEDITORIAL)){
+		    tmp1 = a->body->description ? a->body->description
+		      : "Attached Text";
+		    description = iutf8ncpy((char *)(tmp_20k_buf+10000),
+					    (char *)rfc1522_decode_to_utf8((unsigned char *)(tmp_20k_buf+15000), 5000, tmp1), 5000);
+		
+		    snprintf(tmp_20k_buf, SIZEOF_20KBUF, "Part %s: \"%.1024s\"", a->number,
+			     description);
+		    tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';
+		    if(!(gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)
+			 && !format_editorial(tmp_20k_buf, width, flgs, handlesp, pc)
+			 && gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)))
+		      return("Write Error");
+		}
+
+		error_found += decode_text(a, msgno, pc, handlesp,
+					   (flgs & FM_DISPLAY) ? InLine : QStatus,
+					   flgs);
+		break;
+
+	      case TYPEMESSAGE:
+		tmp1 = a->body->description ? a->body->description
+		  : (strucmp(a->body->subtype, "delivery-status") == 0)
+		  ? "Delivery Status"
+		  : "Included Message";
+		description = iutf8ncpy((char *)(tmp_20k_buf+10000),
+					(char *)rfc1522_decode_to_utf8((unsigned char *)(tmp_20k_buf+15000), 5000, tmp1), 5000);
+	    
+		snprintf(tmp_20k_buf, SIZEOF_20KBUF, "Part %s: \"%.1024s\"", a->number,
+			 description);
+		tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';
+
+		if(!(gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)
+		     && !format_editorial(tmp_20k_buf, width, flgs, handlesp, pc)
+		     && gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)))
+		  return("Write Error");
+
+		if(a->body->subtype && strucmp(a->body->subtype, "rfc822") == 0){
+		    /* imapenvonly, we may not have all the headers we need */
+		    if(a->body->nested.msg->env->imapenvonly)
+		      mail_fetch_header(ps_global->mail_stream, msgno,
+					a->number, NULL, NULL, FT_PEEK);
+		    switch(format_header(ps_global->mail_stream, msgno, a->number,
+					 a->body->nested.msg->env, hp,
+					 NULL, handlesp, flgs, NULL, pc)){
+		      case -1 :			/* write error */
+			return("Write Error");
+
+		      case 1 :			/* fetch error */
+			if(!(gf_puts("[ Error fetching header ]",  pc)
+			     && !gf_puts(NEWLINE, pc)))
+			  return("Write Error");
+
+			break;
+		    }
+		}
+		else if(a->body->subtype && strucmp(a->body->subtype, "external-body") == 0){
+		    int *margin, avail, m1, m2;
+
+		    avail = width;
+		    margin = (flgs & FM_NOINDENT) ? NULL : format_view_margin();
+
+		    m1 = MAX(MIN(margin ? margin[0] : 0, avail), 0);
+		    avail -= m1;
+
+		    m2 = MAX(MIN(margin ? margin[1] : 0, avail), 0);
+		    avail -= m2;
+
+		    if(format_editorial("This part is not included and can be fetched as follows:", avail, flgs, handlesp, pc)
+		       || !gf_puts(NEWLINE, pc)
+		       || format_editorial(display_parameters(a->body->parameter), avail, flgs, handlesp, pc))
+		      return("Write Error");
+		}
+		else
+		  error_found += decode_text(a, msgno, pc, handlesp,
+					     (flgs&FM_DISPLAY) ? InLine : QStatus,
+					     flgs);
+
+		if(!gf_puts(NEWLINE, pc))
+		  return("Write Error");
+
+		break;
+
+	      default:
+		if((decode_err = part_desc(a->number, a->body,
+					   (flgs & FM_DISPLAY) ? 1 : 3,
+					   width, flgs, pc)) != NULL)
+		  return("Write Error");
+	    }
+
+	    show_parts++;
+	}
+
+	if(!(!error_found
+	     && (pith_opt_rfc2369_editorial ? (*pith_opt_rfc2369_editorial)(msgno, handlesp, flgs, width, pc) : 1)
+	     && format_blip_seen(msgno)))
+	  return("Cannot format body.");
+    }
+
+    return(NULL);
+}
+
+
+int
+format_attachment_list(long int msgno, BODY *body, HANDLE_S **handlesp, int flgs, int width, gf_io_t pc)
+{
+    ATTACH_S *a;
+
+    if(flgs & FM_NEW_MESS) {
+	zero_atmts(ps_global->atmts);
+	describe_mime(body, "", 1, 1, 0, flgs);
+    }
+
+    /*----- First do the list of parts/attachments if needed ----*/
+    if((flgs & FM_DISPLAY)
+       && (ps_global->atmts[1].description
+	   || (ps_global->atmts[0].body
+	       && ps_global->atmts[0].body->type != TYPETEXT))){
+	char tmp[6*MAX_SCREEN_COLS + 1], *tmpp;
+	int  i, n, maxnumwid = 0, maxsizewid = 0, *margin;
+	int  avail, m1, m2, hwid, s1, s2, s3, s4, s5, dwid, shownwid;
+	int  sizewid, descwid, dashwid, partwid, padwid;
+	COLOR_PAIR *hdrcolor = NULL;
+
+	if((flgs & FM_DISPLAY)
+	   && !(flgs & FM_NOCOLOR)
+	   && pico_usingcolor()
+	   && ps_global->VAR_HEADER_GENERAL_FORE_COLOR
+	   && ps_global->VAR_HEADER_GENERAL_BACK_COLOR
+	   && ps_global->VAR_NORM_FORE_COLOR
+	   && ps_global->VAR_NORM_BACK_COLOR
+	   && (colorcmp(ps_global->VAR_HEADER_GENERAL_FORE_COLOR,
+		        ps_global->VAR_NORM_FORE_COLOR)
+	       || colorcmp(ps_global->VAR_HEADER_GENERAL_BACK_COLOR,
+		        ps_global->VAR_NORM_BACK_COLOR))){
+
+	    if((hdrcolor = new_color_pair(ps_global->VAR_HEADER_GENERAL_FORE_COLOR,
+					  ps_global->VAR_HEADER_GENERAL_BACK_COLOR)) != NULL){
+		if(!pico_is_good_colorpair(hdrcolor))
+		  free_color_pair(&hdrcolor);
+	    }
+	}
+
+	margin = (flgs & FM_NOINDENT) ? NULL : format_view_margin();
+
+	/*
+	 * Attachment list header
+	 */
+
+	avail = width;
+
+	m1 = MAX(MIN(margin ? margin[0] : 0, avail), 0);
+	avail -= m1;
+
+	m2 = MAX(MIN(margin ? margin[1] : 0, avail), 0);
+	avail -= m2;
+
+	hwid = MAX(avail, 0);
+
+	i = utf8_width(_("Parts/Attachments:"));
+	partwid = MIN(i, hwid);
+	padwid = hdrcolor ? (hwid-partwid) : 0;
+
+	if(m1 > 0){
+	    snprintf(tmp, sizeof(tmp), "%*.*s", m1, m1, "");
+	    if(!gf_puts(tmp, pc))
+	      return(0);
+	}
+
+	utf8_snprintf(tmp, sizeof(tmp),
+	    "%-*.*w%*.*s",
+	    /* TRANSLATORS: A label */
+	    partwid, partwid, _("Parts/Attachments:"),
+	    padwid, padwid, "");
+
+	if(!((!hdrcolor || embed_color(hdrcolor, pc)) && gf_puts(tmp, pc) && gf_puts(NEWLINE, pc)))
+	  return(0);
+
+
+	/*----- Figure max display widths -----*/
+        for(a = ps_global->atmts; a->description != NULL; a++){
+	    if((n = utf8_width(a->number)) > maxnumwid)
+	      maxnumwid = n;
+
+	    if((n = utf8_width(a->size)) > maxsizewid)
+	      maxsizewid = n;
+	}
+
+	/*
+	 *   ----- adjust max lengths for nice display -----
+	 *
+	 *  marg _ D _ number _ Shown _ _ _ size _ _ description marg
+	 *
+	 */
+
+	avail = width - m1 - m2;
+
+	s1 = MAX(MIN(1, avail), 0);
+	avail -= s1;
+
+	dwid = MAX(MIN(1, avail), 0);
+	avail -= dwid;
+
+	s2 = MAX(MIN(1, avail), 0);
+	avail -= s2;
+
+	maxnumwid = MIN(maxnumwid, width/3);
+	maxnumwid = MAX(MIN(maxnumwid, avail), 0);
+	avail -= maxnumwid;
+
+	s3 = MAX(MIN(1, avail), 0);
+	avail -= s3;
+
+	shownwid = MAX(MIN(5, avail), 0);
+	avail -= shownwid;
+
+	s4 = MAX(MIN(3, avail), 0);
+	avail -= s4;
+
+	sizewid = MAX(MIN(maxsizewid, avail), 0);
+	avail -= sizewid;
+
+	s5 = MAX(MIN(2, avail), 0);
+	avail -= s5;
+
+	descwid = MAX(0, avail);
+
+	/*----- Format the list of attachments -----*/
+	for(a = ps_global->atmts; a->description != NULL; a++){
+	    COLOR_PAIR *lastc = NULL;
+	    char numbuf[50];
+	    int thisdescwid, padwid;
+
+#ifdef SMIME
+	    if(a->body->type == TYPEMULTIPART
+	       && (strucmp(a->body->subtype, OUR_PKCS7_ENCLOSURE_SUBTYPE)==0))
+	      continue;
+#endif /* SMIME */
+
+	    i = utf8_width((descwid > 2 && a->description) ? a->description : "");
+	    thisdescwid = MIN(i, descwid);
+	    padwid = hdrcolor ? (descwid-thisdescwid) : 0;
+		
+	    if(m1 > 0){
+		snprintf(tmp, sizeof(tmp), "%*.*s", m1, m1, "");
+		if(!gf_puts(tmp, pc))
+		  return(0);
+	    }
+
+	    utf8_snprintf(tmp, sizeof(tmp),
+		"%*.*s%*.*w%*.*s%-*.*w%*.*s%*.*w%*.*s%*.*w%*.*s%-*.*w",
+		s1, s1, "",
+		dwid, dwid,
+		msgno_part_deleted(ps_global->mail_stream, msgno, a->number) ? "D" : "",
+		s2, s2, "",
+		maxnumwid, maxnumwid,
+		a->number
+		    ? short_str(a->number, numbuf, sizeof(numbuf), maxnumwid, FrontDots)
+		    : "",
+		s3, s3, "",
+		shownwid, shownwid,
+		a->shown ? "Shown" :
+		  (a->can_display != MCD_NONE && !(a->can_display & MCD_EXT_PROMPT))
+		    ? "OK " : "",
+		s4, s4, "",
+		sizewid, sizewid,
+		a->size ? a->size : "",
+		s5, s5, "",
+		thisdescwid, thisdescwid,
+		(descwid > 2 && a->description) ? a->description : "");
+
+	    if(!(!hdrcolor || embed_color(hdrcolor, pc)))
+	      return(0);
+
+	    if(F_ON(F_VIEW_SEL_ATTACH, ps_global) && handlesp){
+		char      buf[16], color[64];
+		int	  l;
+		HANDLE_S *h;
+
+		for(tmpp = tmp; *tmpp && *tmpp == ' '; tmpp++)
+		  if(!(*pc)(' '))
+		    return(0);
+
+		h	    = new_handle(handlesp);
+		h->type	    = Attach;
+		h->h.attach = a;
+
+		snprintf(buf, sizeof(buf), "%d", h->key);
+		buf[sizeof(buf)-1] = '\0';
+
+		if(!(flgs & FM_NOCOLOR)
+		   && handle_start_color(color, sizeof(color), &l, 1)){
+		    lastc = get_cur_embedded_color();
+		    if(!gf_nputs(color, (long) l, pc))
+		      return(0);
+		}
+		else if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global)
+			&& (!((*pc)(TAG_EMBED) && (*pc)(TAG_BOLDON))))
+		  return(0);
+
+		if(!((*pc)(TAG_EMBED) && (*pc)(TAG_HANDLE)
+		     && (*pc)(strlen(buf)) && gf_puts(buf, pc)))
+		  return(0);
+	    }
+	    else
+	      tmpp = tmp;
+
+	    if(!format_env_puts(tmpp, pc))
+	      return(0);
+
+	    if(F_ON(F_VIEW_SEL_ATTACH, ps_global) && handlesp){
+		if(lastc){
+		    if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global)){
+			if(!((*pc)(TAG_EMBED) && (*pc)(TAG_BOLDOFF)))
+			  return(0);
+		    }
+
+		    if(!embed_color(lastc, pc))
+		      return(0);
+
+		    free_color_pair(&lastc);
+		}
+		else if(!((*pc)(TAG_EMBED) && (*pc)(TAG_BOLDOFF)))
+		  return(0);
+
+		if(!((*pc)(TAG_EMBED) && (*pc)(TAG_INVOFF)))
+		  return(0);
+	    }
+
+	    if(padwid > 0){
+		snprintf(tmp, sizeof(tmp), "%*.*s", padwid, padwid, "");
+		if(!gf_puts(tmp, pc))
+		  return(0);
+	    }
+
+	    if(!gf_puts(NEWLINE, pc))
+	      return(0);
+        }
+
+	/*
+	 * Dashed line after list
+	 */
+
+	if(hdrcolor){
+	    avail = width - m1 - m2;
+	    hwid = MAX(avail, 0);
+
+	    dashwid = MAX(MIN(40, hwid-2), 0);
+	    padwid = hwid - dashwid;
+	    if(m1 > 0){
+		snprintf(tmp, sizeof(tmp), "%*.*s", m1, m1, "");
+		if(!gf_puts(tmp, pc))
+		  return(0);
+	    }
+
+	    snprintf(tmp, sizeof(tmp),
+		"%s%*.*s",
+		repeat_char(dashwid, '-'),
+		padwid, padwid, "");
+	}
+	else{
+	    avail = width - m1 -2;
+
+	    dashwid = MAX(MIN(40, avail), 0);
+	    avail -= dashwid;
+
+	    snprintf(tmp, sizeof(tmp),
+		"%*.*s%s",
+		m1, m1, "",
+		repeat_char(dashwid, '-'));
+	}
+
+	if(!((!hdrcolor || embed_color(hdrcolor, pc)) && gf_puts(tmp, pc) && gf_puts(NEWLINE, pc)))
+	  return(0);
+
+	if(hdrcolor)
+	  free_color_pair(&hdrcolor);
+    }
+
+    return(1);
+}
+
+
+
+/*
+ * format_blip_seen - if seen bit (which is usually cleared as a side-effect
+ *		      of body part fetches as we're formatting) for the
+ *		      given message isn't set (likely because there
+ *		      weren't any parts suitable for display), then make
+ *		      sure to set it here.
+ */
+int
+format_blip_seen(long int msgno)
+{
+    MESSAGECACHE *mc;
+
+    if(msgno > 0L && ps_global->mail_stream
+       && msgno <= ps_global->mail_stream->nmsgs
+       && (mc = mail_elt(ps_global->mail_stream, msgno))
+       && !mc->seen
+       && !ps_global->mail_stream->rdonly)
+      mail_flag(ps_global->mail_stream, long2string(msgno), "\\SEEN", ST_SET);
+
+    return(1);
+}
+
+
+/*
+ * is_an_env_hdr - is this name a header in the envelope structure?
+ *
+ *             name - the header name to check
+ */
+int
+is_an_env_hdr(char *name)
+{
+    register int i;
+
+    for(i = 0; envelope_hdrs[i].name; i++)
+      if(!strucmp(name, envelope_hdrs[i].name))
+	return(1);
+
+    return(0);
+}
+
+
+
+
+/*
+ * is_an_addr_hdr - is this an address header?
+ *
+ *             name - the header name to check
+ */
+int
+is_an_addr_hdr(char *fieldname)
+{
+    char   fbuf[FBUF_LEN+1];
+    char  *colon, *fname;
+    static char *addr_headers[] = {
+	"from",
+	"reply-to",
+	"to",
+	"cc",
+	"bcc",
+	"return-path",
+	"sender",
+	"x-sender",
+	"x-x-sender",
+	"resent-from",
+	"resent-to",
+	"resent-cc",
+	NULL
+    };
+
+    /* so it is pointing to NULL */
+    char **p = addr_headers + sizeof(addr_headers)/sizeof(*addr_headers) - 1;
+
+    if((colon = strindex(fieldname, ':')) != NULL){
+	strncpy(fbuf, fieldname, MIN(colon-fieldname,sizeof(fbuf)));
+	fbuf[MIN(colon-fieldname,sizeof(fbuf)-1)] = '\0';
+	fname = fbuf;
+    }
+    else
+      fname = fieldname;
+
+    if(fname && *fname){
+	for(p = addr_headers; *p; p++)
+	  if(!strucmp(fname, *p))
+	    break;
+    }
+
+    return((*p) ? 1 : 0);
+}
+
+
+/*
+ * Format a single field from the envelope
+ */
+void
+format_env_hdr(MAILSTREAM *stream, long int msgno, char *section, ENVELOPE *env,
+	       fmt_env_t fmt_env, gf_io_t pc, char *field, char *oacs, int flags)
+{
+    register int i;
+
+    if(!fmt_env)
+      fmt_env = format_envelope;
+
+    for(i = 0; envelope_hdrs[i].name; i++)
+      if(!strucmp(field, envelope_hdrs[i].name)){
+	  (*fmt_env)(stream, msgno, section, env, pc, envelope_hdrs[i].val, oacs, flags);
+	  return;
+      }
+}
+
+
+/*
+ * Look through header string beginning with "begin", for the next
+ * occurrence of header "field".  Set "start" to that.  Set "end" to point one
+ * position past all of the continuation lines that go with "field".
+ * That is, if "end" is converted to a null
+ * character then the string "start" will be the next occurence of header
+ * "field" including all of its continuation lines. Assume we
+ * have CRLF's as end of lines.
+ *
+ * If "field" is NULL, then we just leave "start" pointing to "begin" and
+ * make "end" the end of that header.
+ *
+ * Returns 1 if found, 0 if not.
+ */
+int
+delineate_this_header(char *field, char *begin, char **start, char **end)
+{
+    char tmpfield[MAILTMPLEN+2]; /* copy of field with colon appended */
+    char *p;
+    char *begin_srch;
+
+    if(field == NULL){
+	if(!begin || !*begin || isspace((unsigned char)*begin))
+	  return 0;
+	else
+	  *start = begin;
+    }
+    else{
+	strncpy(tmpfield, field, sizeof(tmpfield)-2);
+	tmpfield[sizeof(tmpfield)-2] = '\0';
+	strncat(tmpfield, ":", sizeof(tmpfield)-strlen(tmpfield)-1);
+	tmpfield[sizeof(tmpfield)-1] = '\0';
+
+	/*
+	 * We require that start is at the beginning of a line, so
+	 * either it equals begin (which we assume is the beginning of a
+	 * line) or it is preceded by a CRLF.
+	 */
+	begin_srch = begin;
+	*start = srchstr(begin_srch, tmpfield);
+	while(*start && *start != begin
+	             && !(*start - 2 >= begin && ISRFCEOL(*start - 2))){
+	    begin_srch = *start + 1;
+	    *start = srchstr(begin_srch, tmpfield);
+	}
+
+	if(!*start)
+	  return 0;
+    }
+
+    for(p = *start; *p; p++){
+	if(ISRFCEOL(p)
+	   && (!isspace((unsigned char)*(p+2)) || *(p+2) == '\015')){
+	    /*
+	     * The final 015 in the test above is to test for the end
+	     * of the headers.
+	     */
+	    *end = p+2;
+	    break;
+	}
+    }
+
+    if(!*p)
+      *end = p;
+    
+    return 1;
+}
+
+
+
+int
+handle_start_color(char *colorstring, size_t buflen, int *len, int use_hdr_color)
+{
+    *len = 0;
+
+    if(pico_usingcolor()){
+	char *fg = NULL, *bg = NULL, *s;
+	char *basefg = NULL, *basebg = NULL;
+
+	basefg = use_hdr_color	? ps_global->VAR_HEADER_GENERAL_FORE_COLOR
+				: ps_global->VAR_NORM_FORE_COLOR;
+	basebg = use_hdr_color	? ps_global->VAR_HEADER_GENERAL_BACK_COLOR
+				: ps_global->VAR_NORM_BACK_COLOR;
+
+	if(ps_global->VAR_SLCTBL_FORE_COLOR
+	   && colorcmp(ps_global->VAR_SLCTBL_FORE_COLOR, basefg))
+	  fg = ps_global->VAR_SLCTBL_FORE_COLOR;
+
+	if(ps_global->VAR_SLCTBL_BACK_COLOR
+	   && colorcmp(ps_global->VAR_SLCTBL_BACK_COLOR, basebg))
+	  bg = ps_global->VAR_SLCTBL_BACK_COLOR;
+
+	if(bg || fg){
+	    COLOR_PAIR *tmp;
+
+	    /*
+	     * The blacks are just known good colors for
+	     * testing whether the other color is good.
+	     */
+	    if((tmp = new_color_pair(fg ? fg : colorx(COL_BLACK),
+				     bg ? bg : colorx(COL_BLACK))) != NULL){
+		if(pico_is_good_colorpair(tmp))
+		  for(s = color_embed(fg, bg);
+		      (*len) < buflen && (colorstring[*len] = *s);
+		      s++, (*len)++)
+		    ;
+
+		free_color_pair(&tmp);
+	    }
+	}
+
+	if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global)){
+	    strncpy(colorstring + (*len), url_embed(TAG_BOLDON), MIN(3,buflen-(*len)));
+	    *len += 2;
+	}
+    }
+
+    colorstring[buflen-1] = '\0';
+
+    return(*len != 0);
+}
+
+
+int
+handle_end_color(char *colorstring, size_t buflen, int *len)
+{
+    *len = 0;
+    if(pico_usingcolor()){
+	char *fg = NULL, *bg = NULL, *s;
+
+	/*
+	 * We need to change the fg and bg colors back even if they
+	 * are the same as the Normal Colors so that color_a_quote
+	 * will have a chance to pick up those colors as the ones to
+	 * switch to. We don't do this before the handle above so that
+	 * the quote color will flow into the selectable item when
+	 * the selectable item color is partly the same as the
+	 * normal color. That is, suppose the normal color was black on
+	 * cyan and the selectable color was blue on cyan, only a fg color
+	 * change. We preserve the only-a-fg-color-change in a quote by
+	 * letting the quote background color flow into the selectable text.
+	 */
+	if(ps_global->VAR_SLCTBL_FORE_COLOR)
+	  fg = ps_global->VAR_NORM_FORE_COLOR;
+
+	if(ps_global->VAR_SLCTBL_BACK_COLOR)
+	  bg = ps_global->VAR_NORM_BACK_COLOR;
+
+	if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global)){
+	    strncpy(colorstring, url_embed(TAG_BOLDOFF), MIN(3,buflen));
+	    *len = 2;
+	}
+
+	if(fg || bg)
+	  for(s = color_embed(fg, bg); (*len) < buflen && (colorstring[*len] = *s); s++, (*len)++)
+	    ;
+    }
+
+    colorstring[buflen-1] = '\0';
+
+    return(*len != 0);
+}
+
+
+char *
+url_embed(int embed)
+{
+    static char buf[3] = {TAG_EMBED};
+    buf[1] = embed;
+    buf[2] = '\0';
+    return(buf);
+}
+
+
+/*
+ * Paint the signature.
+ */
+int
+color_signature(long int linenum, char *line, LT_INS_S **ins, void *is_in_sig)
+{
+    struct variable *vars = ps_global->vars;
+    int             *in_sig_block;
+    COLOR_PAIR      *col = NULL;
+
+    if(is_in_sig == NULL)
+      return 0;
+
+    in_sig_block = (int *) is_in_sig;
+    
+    if(!strcmp(line, SIGDASHES))
+      *in_sig_block = START_SIG_BLOCK; 
+    else if(*line == '\0')
+      /* 
+       * Suggested by Eduardo: allow for a blank line right after 
+       * the sigdashes. 
+       */
+      *in_sig_block = (*in_sig_block == START_SIG_BLOCK)
+			  ? IN_SIG_BLOCK : OUT_SIG_BLOCK;
+    else
+      *in_sig_block = (*in_sig_block != OUT_SIG_BLOCK)
+			  ? IN_SIG_BLOCK : OUT_SIG_BLOCK;
+
+    if(*in_sig_block != OUT_SIG_BLOCK
+       && VAR_SIGNATURE_FORE_COLOR && VAR_SIGNATURE_BACK_COLOR
+       && (col = new_color_pair(VAR_SIGNATURE_FORE_COLOR,
+				VAR_SIGNATURE_BACK_COLOR))){
+	if(!pico_is_good_colorpair(col))
+	  free_color_pair(&col);
+    }
+    
+    if(col){
+	char *p, fg[RGBLEN + 1], bg[RGBLEN + 1], rgbbuf[RGBLEN + 1];
+
+	ins = gf_line_test_new_ins(ins, line,
+				   color_embed(col->fg, col->bg),
+				   (2 * RGBLEN) + 4);
+
+        strncpy(fg, color_to_asciirgb(VAR_NORM_FORE_COLOR), sizeof(fg));
+	fg[sizeof(fg)-1] = '\0';
+	strncpy(bg, color_to_asciirgb(VAR_NORM_BACK_COLOR), sizeof(bg));
+	bg[sizeof(bg)-1] = '\0';
+
+	/*
+	 * Loop watching colors, and override with 
+	 * signature color whenever the normal foreground and background
+	 * colors are in force.
+	 */
+
+	for(p = line; *p; )
+	  if(*p++ == TAG_EMBED){
+
+	      switch(*p++){
+		case TAG_HANDLE :
+		  p += *p + 1;	/* skip handle key */
+		  break;
+
+		case TAG_FGCOLOR :
+		  snprintf(rgbbuf, sizeof(rgbbuf), "%.*s", RGBLEN, p);
+		  rgbbuf[sizeof(rgbbuf)-1] = '\0';
+		  p += RGBLEN;	/* advance past color value */
+		  
+		  if(!colorcmp(rgbbuf, VAR_NORM_FORE_COLOR)
+		     && !colorcmp(bg, VAR_NORM_BACK_COLOR))
+		    ins = gf_line_test_new_ins(ins, p,
+					       color_embed(col->fg,NULL),
+					       RGBLEN + 2);
+		  break;
+
+		case TAG_BGCOLOR :
+		  snprintf(rgbbuf, sizeof(rgbbuf), "%.*s", RGBLEN, p);
+		  rgbbuf[sizeof(rgbbuf)-1] = '\0';
+		  p += RGBLEN;	/* advance past color value */
+		  
+		  if(!colorcmp(rgbbuf, VAR_NORM_BACK_COLOR)
+		     && !colorcmp(fg, VAR_NORM_FORE_COLOR))
+		    ins = gf_line_test_new_ins(ins, p,
+					       color_embed(NULL,col->bg),
+					       RGBLEN + 2);
+
+		  break;
+
+		default :
+		  break;
+	      }
+	  }
+ 
+	ins = gf_line_test_new_ins(ins, line + strlen(line),
+				   color_embed(VAR_NORM_FORE_COLOR,
+					       VAR_NORM_BACK_COLOR),
+				   (2 * RGBLEN) + 4);
+        free_color_pair(&col);
+    }
+
+    return 0;
+}
+
+
+/*
+ * Line filter to add color to displayed headers.
+ */
+int
+color_headers(long int linenum, char *line, LT_INS_S **ins, void *local)
+{
+    static char field[FBUF_LEN + 1];
+    char        fg[RGBLEN + 1], bg[RGBLEN + 1], rgbbuf[RGBLEN + 1];
+    char       *p, *q, *value, *beg;
+    COLOR_PAIR *color;
+    int         in_quote = 0, in_comment = 0, did_color = 0;
+    struct variable *vars = ps_global->vars;
+
+    field[FBUF_LEN] = '\0';
+
+    if(isspace((unsigned char)*line))		/* continuation line */
+      value = line;
+    else{
+	if(!(value = strindex(line, ':')))
+	  return(0);
+	
+	memset(field, 0, sizeof(field));
+	strncpy(field, line, MIN(value-line, sizeof(field)-1));
+    }
+
+    for(value++; isspace((unsigned char)*value); value++)
+      ;
+
+    strncpy(fg, color_to_asciirgb(VAR_HEADER_GENERAL_FORE_COLOR), sizeof(fg));
+    fg[sizeof(fg)-1] = '\0';
+    strncpy(bg, color_to_asciirgb(VAR_HEADER_GENERAL_BACK_COLOR), sizeof(bg));
+    bg[sizeof(bg)-1] = '\0';
+
+    /*
+     * Split into two cases depending on whether this is a header which
+     * contains addresses or not. We may color addresses separately.
+     */
+    if(is_an_addr_hdr(field)){
+
+	/*
+	 * If none of the patterns are for this header, don't bother parsing
+	 * and checking each address.
+	 */
+	if(!any_hdr_color(field))
+	  return(0);
+
+	/*
+	 * First check for patternless patterns which color whole line.
+	 */
+	if((color = hdr_color(field, NULL, ps_global->hdr_colors)) != NULL){
+	    if(pico_is_good_colorpair(color)){
+		ins = gf_line_test_new_ins(ins, value,
+					   color_embed(color->fg, color->bg),
+					   (2 * RGBLEN) + 4);
+		strncpy(fg, color_to_asciirgb(color->fg), sizeof(fg));
+		fg[sizeof(fg)-1] = '\0';
+		strncpy(bg, color_to_asciirgb(color->bg), sizeof(bg));
+		bg[sizeof(bg)-1] = '\0';
+		did_color++;
+	    }
+	    else
+	      free_color_pair(&color);
+	}
+
+	/*
+	 * Then go through checking address by address.
+	 * Keep track of quotes and watch for color changes, and override
+	 * with most recent header color whenever the normal foreground
+	 * and background colors are in force.
+	 */
+	beg = p = value;
+	while(*p){
+	    switch(*p){
+	      case '\\':
+		/* skip next character */
+		if(*(p+1) && (in_comment || in_quote))
+		  p += 2;
+		else
+		  p++;
+
+		break;
+
+	      case '"':
+		if(!in_comment)
+		  in_quote = 1 - in_quote;
+
+		p++;
+		break;
+
+	      case '(':
+		in_comment++;
+		p++;
+		break;
+
+	      case ')':
+		if(in_comment > 0)
+		  in_comment--;
+
+		p++;
+		break;
+
+	      case ',':
+		if(!(in_quote || in_comment)){
+		    /* we reached the end of this address */   
+		    *p = '\0';
+		    if(color)
+		      free_color_pair(&color);
+
+		    if((color = hdr_color(field, beg,
+					  ps_global->hdr_colors)) != NULL){
+			if(pico_is_good_colorpair(color)){
+			    did_color++;
+			    ins = gf_line_test_new_ins(ins, beg,
+						       color_embed(color->fg,
+								   color->bg),
+						       (2 * RGBLEN) + 4);
+			    *p = ',';
+			    for(q = p; q > beg && 
+				  isspace((unsigned char)*(q-1)); q--)
+			      ;
+
+			    ins = gf_line_test_new_ins(ins, q,
+						       color_embed(fg, bg),
+						       (2 * RGBLEN) + 4);
+			}
+			else
+			  free_color_pair(&color);
+		    }
+		    else
+		      *p = ',';
+		    
+		    for(p++; isspace((unsigned char)*p); p++)
+		      ;
+		    
+		    beg = p;
+		}
+		else
+		  p++;
+
+		break;
+	    
+	      case TAG_EMBED:
+		switch(*(++p)){
+		  case TAG_HANDLE:
+		    p++;
+		    p += *p + 1;	/* skip handle key */
+		    break;
+
+		  case TAG_FGCOLOR:
+		    p++;
+		    snprintf(rgbbuf, sizeof(rgbbuf), "%.*s", RGBLEN, p);
+		    rgbbuf[sizeof(rgbbuf)-1] = '\0';
+		    p += RGBLEN;	/* advance past color value */
+		  
+		    if(!colorcmp(rgbbuf, VAR_HEADER_GENERAL_FORE_COLOR))
+		      ins = gf_line_test_new_ins(ins, p,
+					         color_embed(color->fg,NULL),
+					         RGBLEN + 2);
+		    break;
+
+		  case TAG_BGCOLOR:
+		    p++;
+		    snprintf(rgbbuf, sizeof(rgbbuf), "%.*s", RGBLEN, p);
+		    rgbbuf[sizeof(rgbbuf)-1] = '\0';
+		    p += RGBLEN;	/* advance past color value */
+		  
+		    if(!colorcmp(rgbbuf, VAR_HEADER_GENERAL_BACK_COLOR))
+		      ins = gf_line_test_new_ins(ins, p,
+					         color_embed(NULL,color->bg),
+					         RGBLEN + 2);
+
+		    break;
+
+		  default:
+		    break;
+	        }
+
+		break;
+
+	      default:
+		p++;
+		break;
+	    }
+	}
+
+	for(q = beg; *q && isspace((unsigned char)*q); q++)
+	  ;
+
+	if(*q && !(in_quote || in_comment)){
+	    /* we reached the end of this address */   
+	    if(color)
+	      free_color_pair(&color);
+
+	    if((color = hdr_color(field, beg, ps_global->hdr_colors)) != NULL){
+		if(pico_is_good_colorpair(color)){
+		    did_color++;
+		    ins = gf_line_test_new_ins(ins, beg,
+					       color_embed(color->fg,
+							   color->bg),
+					       (2 * RGBLEN) + 4);
+		    for(q = p; q > beg && isspace((unsigned char)*(q-1)); q--)
+		      ;
+
+		    ins = gf_line_test_new_ins(ins, q,
+					       color_embed(fg, bg),
+					       (2 * RGBLEN) + 4);
+		}
+		else
+		  free_color_pair(&color);
+	    }
+	}
+
+	if(color)
+	  free_color_pair(&color);
+
+	if(did_color)
+	  ins = gf_line_test_new_ins(ins, line + strlen(line),
+				     color_embed(VAR_HEADER_GENERAL_FORE_COLOR,
+					         VAR_HEADER_GENERAL_BACK_COLOR),
+				     (2 * RGBLEN) + 4);
+    }
+    else{
+
+	color = hdr_color(field, value, ps_global->hdr_colors);
+
+	if(color){
+	    if(pico_is_good_colorpair(color)){
+		ins = gf_line_test_new_ins(ins, value,
+					   color_embed(color->fg, color->bg),
+					   (2 * RGBLEN) + 4);
+
+		/*
+		 * Loop watching colors, and override with header
+		 * color whenever the normal foreground and background
+		 * colors are in force.
+		 */
+		p = value;
+		while(*p)
+		  if(*p++ == TAG_EMBED){
+
+		      switch(*p++){
+			case TAG_HANDLE:
+			  p += *p + 1;	/* skip handle key */
+			  break;
+
+			case TAG_FGCOLOR:
+			  snprintf(rgbbuf, sizeof(rgbbuf), "%.*s", RGBLEN, p);
+			  rgbbuf[sizeof(rgbbuf)-1] = '\0';
+			  p += RGBLEN;	/* advance past color value */
+			  
+			  if(!colorcmp(rgbbuf, VAR_HEADER_GENERAL_FORE_COLOR)
+			     && !colorcmp(bg, VAR_HEADER_GENERAL_BACK_COLOR))
+			    ins = gf_line_test_new_ins(ins, p,
+						       color_embed(color->fg,NULL),
+						       RGBLEN + 2);
+			  break;
+
+			case TAG_BGCOLOR:
+			  snprintf(rgbbuf, sizeof(rgbbuf), "%.*s", RGBLEN, p);
+			  rgbbuf[sizeof(rgbbuf)-1] = '\0';
+			  p += RGBLEN;	/* advance past color value */
+			  
+			  if(!colorcmp(rgbbuf, VAR_HEADER_GENERAL_BACK_COLOR)
+			     && !colorcmp(fg, VAR_HEADER_GENERAL_FORE_COLOR))
+			    ins = gf_line_test_new_ins(ins, p,
+						       color_embed(NULL,color->bg),
+						       RGBLEN + 2);
+
+			  break;
+
+			default:
+			  break;
+		      }
+		  }
+
+		ins = gf_line_test_new_ins(ins, line + strlen(line),
+					   color_embed(VAR_HEADER_GENERAL_FORE_COLOR,
+						       VAR_HEADER_GENERAL_BACK_COLOR),
+					   (2 * RGBLEN) + 4);
+	    }
+
+	    free_color_pair(&color);
+	}
+    }
+
+    return(0);
+}
+
+
+int
+url_hilite(long int linenum, char *line, LT_INS_S **ins, void *local)
+{
+    register char *lp, *up = NULL, *urlp = NULL,
+		  *weburlp = NULL, *mailurlp = NULL;
+    int		   n, n1, n2, n3, l;
+    char	   buf[256], color[256];
+    HANDLE_S	  *h;
+    URL_HILITE_S  *uh;
+
+    for(lp = line; ; lp = up + n){
+	/* scan for all of them so we can choose the first */
+	if(F_ON(F_VIEW_SEL_URL,ps_global))
+	  urlp = rfc1738_scan(lp, &n1);
+	if(F_ON(F_VIEW_SEL_URL_HOST,ps_global))
+	  weburlp = web_host_scan(lp, &n2);
+	if(F_ON(F_SCAN_ADDR,ps_global))
+	  mailurlp = mail_addr_scan(lp, &n3);
+	
+	if(urlp || weburlp || mailurlp){
+	    up = urlp ? urlp : 
+		  weburlp ? weburlp : mailurlp;
+	    if(up == urlp && weburlp && weburlp < up)
+	      up = weburlp;
+	    if(mailurlp && mailurlp < up)
+	      up = mailurlp;
+
+	    if(up == urlp){
+		n = n1;
+		weburlp = mailurlp = NULL;
+	    }
+	    else if(up == weburlp){
+		n = n2;
+		mailurlp = NULL;
+	    }
+	    else{
+		n = n3;
+		weburlp = NULL;
+	    }
+	}
+	else
+	  break;
+
+	uh = (URL_HILITE_S *) local;
+
+	h	      = new_handle(uh->handlesp);
+	h->type	      = URL;
+	h->h.url.path = (char *) fs_get((n + 10) * sizeof(char));
+	snprintf(h->h.url.path, n+10, "%s%.*s",
+		weburlp ? "http://" : (mailurlp ? "mailto:" : ""), n, up);
+	h->h.url.path[n+10-1] = '\0';
+
+	if(handle_start_color(color, sizeof(color), &l, uh->hdr_color))
+	  ins = gf_line_test_new_ins(ins, up, color, l);
+	else if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global))
+	  ins = gf_line_test_new_ins(ins, up, url_embed(TAG_BOLDON), 2);
+
+	buf[0] = TAG_EMBED;
+	buf[1] = TAG_HANDLE;
+	snprintf(&buf[3], sizeof(buf)-3, "%d", h->key);
+	buf[sizeof(buf)-1] = '\0';
+	buf[2] = strlen(&buf[3]);
+	ins = gf_line_test_new_ins(ins, up, buf, (int) buf[2] + 3);
+
+	/* in case it was the current selection */
+	ins = gf_line_test_new_ins(ins, up + n, url_embed(TAG_INVOFF), 2);
+
+	if(scroll_handle_end_color(color, sizeof(color), &l, uh->hdr_color))
+	  ins = gf_line_test_new_ins(ins, up + n, color, l);
+	else
+	  ins = gf_line_test_new_ins(ins, up + n, url_embed(TAG_BOLDOFF), 2);
+
+	urlp = weburlp = mailurlp = NULL;
+    }
+
+    return(0);
+}
+
+
+int
+url_hilite_hdr(long int linenum, char *line, LT_INS_S **ins, void *local)
+{
+    static int     check_for_urls = 0;
+    register char *lp;
+
+    if(isspace((unsigned char)*line))	/* continuation, check or not 
+					   depending on last line */
+      lp = line;
+    else{
+	check_for_urls = 0;
+	if((lp = strchr(line, ':')) != NULL){	/* there ought to always be a colon */
+	    FieldType ft;
+
+	    *lp = '\0';
+
+	    if(((ft = pine_header_standard(line)) == FreeText
+		|| ft == Subject
+		|| ft == TypeUnknown)
+	       && strucmp(line, "message-id")
+	       && strucmp(line, "newsgroups")
+	       && strucmp(line, "references")
+	       && strucmp(line, "in-reply-to")
+	       && strucmp(line, "received")
+	       && strucmp(line, "date")){
+		check_for_urls = 1;
+	    }
+
+	    *lp = ':';
+	}
+    }
+
+    if(check_for_urls)
+      (void) url_hilite(linenum, lp + 1, ins, local);
+
+    return(0);
+}
+
+
+int
+pad_to_right_edge(long int linenum, char *line, LT_INS_S **ins, void *local)
+{
+    char *p;
+    int wid = 0;
+    int total_wid;
+    struct variable *vars = ps_global->vars;
+
+    if(!line[0])
+      return 0;
+
+    total_wid = *((int *) local);
+
+    /* calculate width of line */
+    p = line;
+    while(*p){
+
+	switch(*p){
+	  case TAG_EMBED:
+	    p++;
+	    switch(*p){
+	      case TAG_HANDLE:
+		p++;
+		p += *p + 1;  /* skip handle key */
+		break;
+
+	      case TAG_FGCOLOR :
+	      case TAG_BGCOLOR :
+		p += (RGBLEN + 1);	/* 1 for TAG, RGBLEN for color */
+		break;
+
+	      case TAG_INVON:
+	      case TAG_INVOFF:
+	      case TAG_BOLDON:
+	      case TAG_BOLDOFF:
+	      case TAG_ULINEON:
+	      case TAG_ULINEOFF:
+		p++;
+		break;
+	    
+	      default:	/* literal embed char */
+		break;
+	    }
+
+	    break;
+
+	  case TAB:
+	    p++;
+	    while(((++wid) &  0x07) != 0) /* add tab's spaces */
+	      ;
+
+	    break;
+
+	  default:
+	    wid += width_at_this_position((unsigned char *) p, strlen(p));
+	    p++;
+	    break;
+	}
+    }
+
+    if(total_wid > wid){
+	ins = gf_line_test_new_ins(ins, line + strlen(line),
+				   color_embed(VAR_HEADER_GENERAL_FORE_COLOR,
+					       VAR_HEADER_GENERAL_BACK_COLOR),
+				   (2 * RGBLEN) + 4);
+	ins = gf_line_test_new_ins(ins, line+strlen(line),
+				   repeat_char(total_wid-wid, ' '), total_wid-wid);
+	ins = gf_line_test_new_ins(ins, line + strlen(line),
+				   color_embed(VAR_NORM_FORE_COLOR,
+					       VAR_NORM_BACK_COLOR),
+				   (2 * RGBLEN) + 4);
+    }
+
+    return(0);
+}
+
+
+
+#define	UES_LEN	12
+#define	UES_MAX	32
+int
+url_external_specific_handler(char *url, int len)
+{
+    static char list[UES_LEN * UES_MAX];
+
+    if(url){
+	char *p;
+	int   i;
+
+	for(i = 0; i < UES_MAX && *(p = &list[i * UES_LEN]); i++)
+	  if(strlen(p) == len && !struncmp(p, url, len))
+	    return(1);
+    }
+    else{					/* initialize! */
+	char **l, *test, *cmd, *p, *p2;
+	int    i = 0, n;
+
+	memset(list, 0, sizeof(list));
+	for(l = ps_global->VAR_BROWSER ; l && *l; l++){
+	    get_pair(*l, &test, &cmd, 1, 1);
+
+	    if((p = srchstr(test, "_scheme(")) && (p2 = strstr(p+8, ")_"))){
+		*p2 = '\0';
+
+		for(p += 8; *p && i < UES_MAX; p += n)
+		  if((p2 = strchr(p, ',')) != NULL){
+		      if((n = p2 - p) < UES_LEN){
+			strncpy(&list[i * UES_LEN], p, MIN(n, sizeof(list)-(i * UES_LEN)));
+			i++;
+		      }
+		      else
+			dprint((1,
+				   "* * * HANLDER TOO LONG: %.*s\n", n,
+				   p ? p : "?"));
+
+		      n++;
+		  }
+		  else{
+		      if(strlen(p) <= UES_LEN){
+			strncpy(&list[i * UES_LEN], p, sizeof(list)-(i * UES_LEN));
+			i++;
+		      }
+
+		      break;
+		  }
+	    }
+
+	    if(test)
+	      fs_give((void **) &test);
+
+	    if(cmd)
+	      fs_give((void **) &cmd);
+	}
+    }
+
+    return(0);
+}
+
+
+int
+url_imap_folder(char *true_url, char **folder, imapuid_t *uid_val,
+		imapuid_t *uid, char **search, int silent)
+{
+    char *url, *scheme, *p, *cmd, *server = NULL,
+	 *user = NULL, *auth = NULL, *mailbox = NULL,
+	 *section = NULL;
+    size_t l;
+    int   rv = URL_IMAP_ERROR;
+
+    /*
+     * Since we're planting nulls, operate on a temporary copy...
+     */
+    scheme = silent ? NULL : "IMAP";
+    url = cpystr(true_url + 7);
+
+    /* Try to pick apart the "iserver" portion */
+    if((cmd = strchr(url, '/')) != NULL){		/* iserver "/" [mailbox] ? */
+	*cmd++ = '\0';
+    }
+    else{
+	dprint((2, "-- URL IMAP FOLDER: missing: %s\n",
+	       url ? url : "?"));
+	cmd = &url[strlen(url)-1];	/* assume only iserver */
+    }
+
+    if((p = strchr(url, '@')) != NULL){		/* user | auth | pass? */
+	*p++ = '\0';
+	server = rfc1738_str(p);
+	
+	/* only ";auth=*" supported (and also ";auth=anonymous") */
+	if((p = srchstr(url, ";auth=")) != NULL){
+	    *p = '\0';
+	    auth = rfc1738_str(p + 6);
+	}
+
+	if(*url)
+	  user = rfc1738_str(url);
+    }
+    else
+      server = rfc1738_str(url);
+
+    if(!*server)
+      return(url_bogus_imap(&url, scheme, "No server specified"));
+
+    /*
+     * "iserver" in hand, pick apart the "icommand"...
+     */
+    p = NULL;
+    if(!*cmd || (p = srchstr(cmd, ";type="))){
+	char *criteria;
+
+	/*
+	 * No "icommand" (all top-level folders) or "imailboxlist"...
+	 */
+	if(p){
+	    *p	 = '\0';		/* tie off criteria */
+	    criteria = rfc1738_str(cmd);	/* get "enc_list_mailbox" */
+	    if(!strucmp(p = rfc1738_str(p+6), "lsub"))
+	      rv |= URL_IMAP_IMBXLSTLSUB;
+	    else if(strucmp(p, "list"))
+	      return(url_bogus_imap(&url, scheme,
+				    "Invalid list type specified"));
+	}
+	else{
+	    rv |= URL_IMAP_ISERVERONLY;
+	    criteria = "";
+	}
+		
+	/* build folder list from specified server/criteria/list-method */
+	l = strlen(server) + strlen(criteria) + 10 + (user ? (strlen(user)+2) : 9);
+	*folder = (char *) fs_get((l+1) * sizeof(char));
+	snprintf(*folder, l+1, "{%s/%s%s%s}%s%s%s", server,
+		user ? "user=\"" : "Anonymous",
+		user ? user : "",
+		user ? "\"" : "",
+		*criteria ? "[" : "", criteria, *criteria ? "[" : "");
+	(*folder)[l] = '\0';
+	rv |= URL_IMAP_IMAILBOXLIST;
+    }
+    else{
+	if((p = srchstr(cmd, "/;uid=")) != NULL){ /* "imessagepart" */
+	    *p = '\0';		/* tie off mailbox [uidvalidity] */
+	    if((section = srchstr(p += 6, "/;section=")) != NULL){
+		*section = '\0';	/* tie off UID */
+		section  = rfc1738_str(section + 10);
+/* BUG: verify valid section spec ala rfc 2060 */
+		dprint((2,
+			   "-- URL IMAP FOLDER: section not used: %s\n",
+			   section ? section : "?"));
+	    }
+
+	    if(!(*uid = rfc1738_num(&p)) || *p) /* decode UID */
+	      return(url_bogus_imap(&url, scheme, "Invalid data in UID"));
+
+	    /* optional "uidvalidity"? */
+	    if((p = srchstr(cmd, ";uidvalidity=")) != NULL){
+		*p  = '\0';
+		p  += 13;
+		if(!(*uid_val = rfc1738_num(&p)) || *p)
+		  return(url_bogus_imap(&url, scheme,
+					"Invalid UIDVALIDITY"));
+	    }
+
+	    mailbox = rfc1738_str(cmd);
+	    rv = URL_IMAP_IMESSAGEPART;
+	}
+	else{			/* "imessagelist" */
+	    /* optional "uidvalidity"? */
+	    if((p = srchstr(cmd, ";uidvalidity=")) != NULL){
+		*p  = '\0';
+		p  += 13;
+		if(!(*uid_val = rfc1738_num(&p)) || *p)
+		  return(url_bogus_imap(&url, scheme,
+					"Invalid UIDVALIDITY"));
+	    }
+
+	    /* optional "enc_search"? */
+	    if((p = strchr(cmd, '?')) != NULL){
+		*p = '\0';
+		if(search)
+		  *search = cpystr(rfc1738_str(p + 1));
+/* BUG: verify valid search spec ala rfc 2060 */
+	    }
+
+	    mailbox = rfc1738_str(cmd);
+	    rv = URL_IMAP_IMESSAGELIST;
+	}
+
+	if(auth && *auth != '*' && strucmp(auth, "anonymous"))
+	  q_status_message(SM_ORDER, 3, 3,
+	     "Unsupported authentication method.  Using standard login.");
+
+	/*
+	 * At this point our structure should contain the
+	 * digested url.  Now put it together for c-client...
+	 */
+	l = strlen(server) + 8 + (mailbox ? strlen(mailbox) : 0)
+				   + (user ? (strlen(user)+2) : 9);
+	*folder = (char *) fs_get((l+1) * sizeof(char));
+	snprintf(*folder, l+1, "{%s%s%s%s%s}%s", server,
+		 (user || !(auth && strucmp(auth, "anonymous"))) ? "/" : "",
+		 user ? "user=\"" : ((auth && strucmp(auth, "anonymous")) ? "" : "Anonymous"),
+		 user ? user : "",
+		 user ? "\"" : "",
+		 mailbox);
+	(*folder)[l] = '\0';
+    }
+
+    fs_give((void **) &url);
+    return(rv);
+}
+
+
+int
+url_bogus_imap(char **freeme, char *url, char *problem)
+{
+    fs_give((void **) freeme);
+    (void) url_bogus(url, problem);
+    return(URL_IMAP_ERROR);
+}
+
+
+/*
+ * url_bogus - report url syntax errors and such
+ */
+int
+url_bogus(char *url, char *reason)
+{
+    dprint((2, "-- bogus url \"%s\": %s\n",
+	       url ? url : "<NULL URL>", reason ? reason : "?"));
+    if(url)
+      q_status_message3(SM_ORDER|SM_DING, 2, 3,
+		        "Malformed \"%.*s\" URL: %.200s",
+			(void *) (strchr(url, ':') - url), url, reason);
+
+    return(0);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Format header text suitable for display
+
+  Args: stream -- mail stream for various header text fetches
+	msgno -- sequence number in stream of message we're interested in
+	section -- which section of message 
+	env -- pointer to msg's envelope
+	hdrs -- struct containing what's to get formatted
+	prefix -- prefix to append to each output line
+        handlesp -- address of pointer to the message's handles
+	flags -- FM_ flags, see pith/mailview.h
+	final_pc -- function to write header text with
+
+  Result: 0 if all's well, -1 if write error, 1 if fetch error
+
+  NOTE: Blank-line delimiter is NOT written here.  Newlines are written
+	in the local convention.
+
+ ----*/
+#define	FHT_OK		0
+#define	FHT_WRTERR	-1
+#define	FHT_FTCHERR	1
+int
+format_header(MAILSTREAM *stream, long int msgno, char *section, ENVELOPE *env,
+	      HEADER_S *hdrs, char *prefix, HANDLE_S **handlesp, int flags,
+	      fmt_env_t fmt_env, gf_io_t final_pc)
+{
+    int	     rv = FHT_OK;
+    int	     nfields, i;
+    char    *h = NULL, **fields = NULL, **v, *q, *start,
+	    *finish, *current;
+    STORE_S *tmp_store;
+    URL_HILITE_S uh;
+    gf_io_t  tmp_pc, tmp_gc;
+    struct variable *vars = ps_global->vars;
+
+    if((tmp_store = so_get(CharStar, NULL, EDIT_ACCESS)) != NULL)
+      gf_set_so_writec(&tmp_pc, tmp_store);
+    else
+      return(FHT_WRTERR);
+
+    if(!fmt_env)
+      fmt_env = format_envelope;
+
+    if(ps_global->full_header == 2){
+	rv = format_raw_header(stream, msgno, section, tmp_pc);
+    }
+    else{
+	/*
+	 * First, calculate how big a fields array we need.
+	 */
+
+	/* Custom header viewing list specified */
+	if(hdrs->type == HD_LIST){
+	    /* view all these headers */
+	    if(!hdrs->except){
+		for(nfields = 0, v = hdrs->h.l; (q = *v) != NULL; v++)
+		  if(!is_an_env_hdr(q))
+		    nfields++;
+	    }
+	    /* view all except these headers */
+	    else{
+		for(nfields = 0, v = hdrs->h.l; *v != NULL; v++)
+		  nfields++;
+
+		if(nfields > 1)
+		  nfields--; /* subtract one for ALL_EXCEPT field */
+	    }
+	}
+	else
+	  nfields = 6;				/* default view */
+
+	/* allocate pointer space */
+	if(nfields){
+	    fields = (char **)fs_get((size_t)(nfields+1) * sizeof(char *));
+	    memset(fields, 0, (size_t)(nfields+1) * sizeof(char *));
+	}
+
+	if(hdrs->type == HD_LIST){
+	    /* view all these headers */
+	    if(!hdrs->except){
+		/* put the non-envelope headers in fields */
+		if(nfields)
+		  for(i = 0, v = hdrs->h.l; (q = *v) != NULL; v++)
+		    if(!is_an_env_hdr(q))
+		      fields[i++] = q;
+	    }
+	    /* view all except these headers */
+	    else{
+		/* put the list of headers not to view in fields */
+		if(nfields)
+		  for(i = 0, v = hdrs->h.l; (q = *v) != NULL; v++)
+		    if(strucmp(ALL_EXCEPT, q))
+		      fields[i++] = q;
+	    }
+
+	    v = hdrs->h.l;
+	}
+	else{
+	    if(nfields){
+		fields[i = 0] = "Resent-Date";
+		fields[++i]   = "Resent-From";
+		fields[++i]   = "Resent-To";
+		fields[++i]   = "Resent-cc";
+		fields[++i]   = "Resent-Subject";
+	    }
+
+	    v = fields;
+	}
+
+	/* custom view with exception list */
+	if(hdrs->type == HD_LIST && hdrs->except){
+	    /*
+	     * Go through each header in h and print it.
+	     * First we check to see if it is an envelope header so we
+	     * can print our envelope version of it instead of the raw version.
+	     */
+
+	    /* fetch all the other headers */
+	    if(nfields)
+	      h = pine_fetchheader_lines_not(stream, msgno, section, fields);
+
+	    for(current = h;
+		h && delineate_this_header(NULL, current, &start, &finish);
+		current = finish){
+		char tmp[MAILTMPLEN+1];
+		char *colon_loc;
+
+		colon_loc = strindex(start, ':');
+		if(colon_loc && colon_loc < finish){
+		    strncpy(tmp, start, MIN(colon_loc-start, sizeof(tmp)-1));
+		    tmp[MIN(colon_loc-start, sizeof(tmp)-1)] = '\0';
+		}
+		else
+		  colon_loc = NULL;
+
+		if(colon_loc && is_an_env_hdr(tmp)){
+		    char *dummystart, *dummyfinish;
+
+		    /*
+		     * Pretty format for env hdrs.
+		     * If the same header appears more than once, only
+		     * print the last to avoid duplicates.
+		     * They should have been combined in the env when parsed.
+		     */
+		    if(!delineate_this_header(tmp, current+1, &dummystart,
+					      &dummyfinish))
+		      format_env_hdr(stream, msgno, section, env,
+				     fmt_env, tmp_pc, tmp, hdrs->charset, flags);
+		}
+		else{
+		    if((rv = format_raw_hdr_string(start, finish, tmp_pc,
+						   hdrs->charset, flags)) != 0)
+		      goto write_error;
+		    else
+		      start = finish;
+		}
+	    }
+	}
+	/* custom view or default */
+	else{
+	    /* fetch the non-envelope headers */
+	    if(nfields)
+	      h = pine_fetchheader_lines(stream, msgno, section, fields);
+
+	    /* default envelope for default view */
+	    if(hdrs->type == HD_BFIELD)
+	      (*fmt_env)(stream, msgno, section, env, tmp_pc, hdrs->h.b, hdrs->charset, flags);
+
+	    /* go through each header in list, v initialized above */
+	    for(; (q = *v) != NULL; v++){
+		if(is_an_env_hdr(q)){
+		    /* pretty format for env hdrs */
+		    format_env_hdr(stream, msgno, section, env,
+				   fmt_env, tmp_pc, q, hdrs->charset, flags);
+		}
+		else{
+		    /*
+		     * Go through h finding all occurences of this header
+		     * and all continuation lines, and output.
+		     */
+		    for(current = h;
+			h && delineate_this_header(q,current,&start,&finish);
+			current = finish){
+			if((rv = format_raw_hdr_string(start, finish, tmp_pc,
+						       hdrs->charset, flags)) != 0)
+			  goto write_error;
+			else
+			  start = finish;
+		    }
+		}
+	    }
+	}
+    }
+
+
+  write_error:
+
+    gf_clear_so_writec(tmp_store);
+
+    if(!rv){			/* valid data?  Do wrapping and filtering... */
+	int	 column;
+	char	*errstr, *display_filter = NULL, trigger[MAILTMPLEN];
+	STORE_S *df_store = NULL;
+
+	so_seek(tmp_store, 0L, 0);
+
+	column = (flags & FM_DISPLAY) ? ps_global->ttyo->screen_cols : 80;
+
+	/*
+	 * Test for and act on any display filter
+	 * This barely makes sense. The display filter is going
+	 * to be getting UTF-8'ized headers here. In pre-alpine
+	 * pine the display filter was being fed already decoded
+	 * headers in whatever character set they were in.
+	 * The good news is that that didn't make much
+	 * sense either, so this shouldn't break anything.
+	 * It seems unlikely that anybody is doing anything useful
+	 * with the header part of display filters.
+	 */
+	if(ps_global->tools.display_filter
+	   && ps_global->tools.display_filter_trigger
+	   && (display_filter = (*ps_global->tools.display_filter_trigger)(NULL, trigger, sizeof(trigger)))){
+	    if((df_store = so_get(CharStar, NULL, EDIT_ACCESS)) != NULL){
+
+		gf_set_so_writec(&tmp_pc, df_store);
+		gf_set_so_readc(&tmp_gc, df_store);
+		if((errstr = (*ps_global->tools.display_filter)(display_filter, tmp_store, tmp_pc, NULL)) != NULL){
+		    q_status_message1(SM_ORDER | SM_DING, 3, 3,
+				      _("Formatting error: %s"), errstr);
+		    rv = FHT_WRTERR;
+		}
+		else
+		  so_seek(df_store, 0L, 0);
+
+		gf_clear_so_writec(df_store);
+	    }
+	    else{
+		q_status_message(SM_ORDER | SM_DING, 3, 3,
+				  "No space for filtered text.");
+		rv = FHT_WRTERR;
+	    }
+	}
+	else{
+	    so_seek(tmp_store, 0L, 0);
+	    gf_set_so_readc(&tmp_gc, tmp_store);
+	}
+
+	if(!rv){
+	    int *margin, wrapflags = GFW_ONCOMMA;
+
+	    gf_filter_init();
+	    gf_link_filter(gf_local_nvtnl, NULL);
+
+	    if((F_ON(F_VIEW_SEL_URL, ps_global)
+		|| F_ON(F_VIEW_SEL_URL_HOST, ps_global)
+		|| F_ON(F_SCAN_ADDR, ps_global))
+	       && handlesp){
+		gf_link_filter(gf_line_test,
+			       gf_line_test_opt(url_hilite_hdr,
+					        gf_url_hilite_opt(&uh,handlesp,1)));
+		wrapflags |= GFW_HANDLES;
+	    }
+
+	    if((flags & FM_DISPLAY)
+	       && !(flags & FM_NOCOLOR)
+	       && pico_usingcolor()
+	       && ((VAR_NORM_FORE_COLOR
+		    && VAR_HEADER_GENERAL_FORE_COLOR
+		    && colorcmp(VAR_NORM_FORE_COLOR, VAR_HEADER_GENERAL_FORE_COLOR))
+	          ||
+	           (VAR_NORM_BACK_COLOR
+		    && VAR_HEADER_GENERAL_BACK_COLOR
+		    && colorcmp(VAR_NORM_BACK_COLOR, VAR_HEADER_GENERAL_BACK_COLOR))))
+	      wrapflags |= GFW_HDRCOLOR;
+
+	    if((flags & FM_DISPLAY)
+	       && !(flags & FM_NOCOLOR)
+	       && pico_usingcolor()
+	       && ps_global->hdr_colors){
+		gf_link_filter(gf_line_test,
+			       gf_line_test_opt(color_headers, NULL));
+		wrapflags |= (GFW_HANDLES | GFW_HDRCOLOR);
+	    }
+
+	    if(prefix && *prefix)
+	      column = MAX(column-strlen(prefix), 50);
+
+	    margin = format_view_margin();
+
+	    if(!(flags & FM_NOWRAP))
+	      gf_link_filter(gf_wrap,
+			     gf_wrap_filter_opt(column, column,
+					        (flags & FM_NOINDENT) ? NULL : margin,
+						4, wrapflags));
+
+	    if(prefix && *prefix)
+	      gf_link_filter(gf_prefix, gf_prefix_opt(prefix));
+
+	    if((flags & FM_DISPLAY)
+	       && !(flags & FM_NOCOLOR)
+	       && pico_usingcolor()
+	       && ((VAR_NORM_FORE_COLOR
+		    && VAR_HEADER_GENERAL_FORE_COLOR
+		    && colorcmp(VAR_NORM_FORE_COLOR, VAR_HEADER_GENERAL_FORE_COLOR))
+	          ||
+	           (VAR_NORM_BACK_COLOR
+		    && VAR_HEADER_GENERAL_BACK_COLOR
+		    && colorcmp(VAR_NORM_BACK_COLOR, VAR_HEADER_GENERAL_BACK_COLOR)))){
+		int right_margin;
+		int total_wid;
+
+		right_margin = margin ? margin[1] : 0;
+		total_wid = column - right_margin;
+
+		gf_link_filter(gf_line_test,
+			       gf_line_test_opt(pad_to_right_edge, (void *) &total_wid));
+		wrapflags |= GFW_HANDLES;
+	    }
+
+	    gf_link_filter(gf_nvtnl_local, NULL);
+
+	    if((errstr = gf_pipe(tmp_gc, final_pc)) != NULL){
+		rv = FHT_WRTERR;
+		q_status_message1(SM_ORDER | SM_DING, 3, 3,
+				  "Can't build header : %.200s", errstr);
+	    }
+	}
+
+	if(df_store){
+	    gf_clear_so_readc(df_store);
+	    so_give(&df_store);
+	}
+	else
+	  gf_clear_so_readc(tmp_store);
+    }
+
+    so_give(&tmp_store);
+
+    if(h)
+      fs_give((void **)&h);
+
+    if(fields)
+      fs_give((void **)&fields);
+
+    return(rv);
+}
+
+
+/*----------------------------------------------------------------------
+  Format RAW header text for display
+
+  Args: stream -- mail stream for various header text fetches
+	rawno -- sequence number in stream of message we're interested in
+	section -- which section of message 
+	pc -- function to write header text with
+
+  Result: 0 if all's well, -1 if write error, 1 if fetch error
+
+  NOTE: Blank-line delimiter is NOT written here.  Newlines are written
+	in the local convention.
+
+ ----*/
+int
+format_raw_header(MAILSTREAM *stream, long int msgno, char *section, gf_io_t pc)
+{
+    char *h = mail_fetch_header(stream, msgno, section, NULL, NULL, FT_PEEK);
+    unsigned char c;
+
+    if(h){
+	while(*h){
+	    if(ISRFCEOL(h)){
+		h += 2;
+		if(!gf_puts(NEWLINE, pc))
+		  return(FHT_WRTERR);
+
+		if(ISRFCEOL(h))		/* all done! */
+		  return(FHT_OK);
+	    }
+	    else if((unsigned char)(*h) < 0x80 && FILTER_THIS(*h) &&
+		    !(*(h+1) && *h == ESCAPE && match_escapes(h+1))){
+		c = (unsigned char) *h++;
+		if(!((*pc)(c >= 0x80 ? '~' : '^')
+		     && (*pc)((c == 0x7f) ? '?' : (c & 0x1f) + '@')))
+		  return(FHT_WRTERR);
+	    }
+	    else if(!(*pc)(*h++))
+	      return(FHT_WRTERR);
+	}
+    }
+    else
+      return(FHT_FTCHERR);
+
+    return(FHT_OK);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Format c-client envelope data suitable for display
+
+  Args: s -- mail stream for various header text fetches
+	n -- raw sequence number in stream of message we're interested in
+	sect -- which section of message 
+	e -- pointer to msg's envelope
+	pc -- function to write header text with
+	which -- which header lines to write
+	oacs -- 
+	flags -- FM_ flags, see pith/mailview.h
+
+  Result: 0 if all's well, -1 if write error, 1 if fetch error
+
+  NOTE: Blank-line delimiter is NOT written here.  Newlines are written
+	in the local convention.
+
+ ----*/
+void
+format_envelope(MAILSTREAM *s, long int n, char *sect, ENVELOPE *e, gf_io_t pc,
+		long int which, char *oacs, int flags)
+{
+    char *q, *p2, buftmp[MAILTMPLEN];
+
+    if(!e)
+      return;
+
+    if((which & FE_DATE) && e->date) {
+	q = "Date: ";
+	snprintf(buftmp, sizeof(buftmp), "%s",
+		 F_ON(F_DATES_TO_LOCAL,ps_global)
+		    ? convert_date_to_local((char *) e->date) : (char *) e->date);
+	buftmp[sizeof(buftmp)-1] = '\0';
+	p2 = (char *)rfc1522_decode_to_utf8((unsigned char *) tmp_20k_buf,
+					    SIZEOF_20KBUF, buftmp);
+	gf_puts(q, pc);
+	format_env_puts(p2, pc);
+	gf_puts(NEWLINE, pc);
+    }
+
+    if((which & FE_FROM) && e->from)
+      format_addr_string(s, n, sect, "From: ", e->from, flags, oacs, pc);
+
+    if((which & FE_REPLYTO) && e->reply_to
+       && (!e->from || !address_is_same(e->reply_to, e->from)))
+      format_addr_string(s, n, sect, "Reply-To: ", e->reply_to, flags, oacs, pc);
+
+    if((which & FE_TO) && e->to)
+      format_addr_string(s, n, sect, "To: ", e->to, flags, oacs, pc);
+
+    if((which & FE_CC) && e->cc)
+      format_addr_string(s, n, sect, "Cc: ", e->cc, flags, oacs, pc);
+
+    if((which & FE_BCC) && e->bcc)
+      format_addr_string(s, n, sect, "Bcc: ", e->bcc, flags, oacs, pc);
+
+    if((which & FE_RETURNPATH) && e->return_path)
+      format_addr_string(s, n, sect, "Return-Path: ", e->return_path,
+			 flags, oacs, pc);
+
+    if((which & FE_NEWSGROUPS) && e->newsgroups){
+	int bogus = NIL;
+      format_newsgroup_string("Newsgroups: ", e->newsgroups, flags, pc);
+      if (!e->ngpathexists && e->message_id &&
+       strncmp (e->message_id,"<alpine.",8) &&
+       strncmp (e->message_id,"<Pine.",6) &&
+       strncmp (e->message_id,"<MS-C.",6) &&
+       strncmp (e->message_id,"<MailManager.",13) &&
+       strncmp (e->message_id,"<EasyMail.",11) &&
+       strncmp (e->message_id,"<ML-",4)) bogus = T;
+
+	if(bogus)
+	  q_status_message(SM_ORDER, 0, 3,
+     "Unverified Newsgroup header -- Message MAY or MAY NOT have been posted");
+    }
+
+    if((which & FE_FOLLOWUPTO) && e->followup_to)
+      format_newsgroup_string("Followup-To: ", e->followup_to, flags, pc);
+
+    if((which & FE_SUBJECT) && e->subject && e->subject[0]){
+	char *freeme = NULL;
+
+	q = "Subject: ";
+	gf_puts(q, pc);
+
+	p2 = iutf8ncpy((char *)(tmp_20k_buf+10000), (char *)rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf, 10000, e->subject), SIZEOF_20KBUF-10000);
+
+	if(flags & FM_DISPLAY
+	   && (ps_global->display_keywords_in_subject
+	       || ps_global->display_keywordinits_in_subject)){
+
+	    /* don't bother if no keywords are defined */
+	    if(some_user_flags_defined(s))
+	      p2 = freeme = prepend_keyword_subject(s, n, p2,
+			  ps_global->display_keywords_in_subject ? KW : KWInit,
+			  NULL, ps_global->VAR_KW_BRACES);
+	}
+
+	format_env_puts(p2, pc);
+
+	if(freeme)
+	  fs_give((void **) &freeme);
+
+	gf_puts(NEWLINE, pc);
+    }
+
+    if((which & FE_SENDER) && e->sender
+       && (!e->from || !address_is_same(e->sender, e->from)))
+      format_addr_string(s, n, sect, "Sender: ", e->sender, flags, oacs, pc);
+
+    if((which & FE_MESSAGEID) && e->message_id){
+	q = "Message-ID: ";
+	gf_puts(q, pc);
+	p2 = iutf8ncpy((char *)(tmp_20k_buf+10000), (char *)rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf, 10000, e->message_id), SIZEOF_20KBUF-10000);
+	format_env_puts(p2, pc);
+	gf_puts(NEWLINE, pc);
+    }
+
+    if((which & FE_INREPLYTO) && e->in_reply_to){
+	q = "In-Reply-To: ";
+	gf_puts(q, pc);
+	p2 = iutf8ncpy((char *)(tmp_20k_buf+10000), (char *)rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf, 10000, e->in_reply_to), SIZEOF_20KBUF-10000);
+	format_env_puts(p2, pc);
+	gf_puts(NEWLINE, pc);
+    }
+
+    if((which & FE_REFERENCES) && e->references) {
+	q = "References: ";
+	gf_puts(q, pc);
+	p2 = iutf8ncpy((char *)(tmp_20k_buf+10000), (char *)rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf, 10000, e->references), SIZEOF_20KBUF-10000);
+	format_env_puts(p2, pc);
+	gf_puts(NEWLINE, pc);
+    }
+}
+
+
+
+
+/*
+ * The argument fieldname is something like "Subject:..." or "Subject".
+ * Look through the specs in speccolor for a match of the fieldname,
+ * and return the color that goes with any match, or NULL.
+ * Caller should free the color.
+ */
+COLOR_PAIR *
+hdr_color(char *fieldname, char *value, SPEC_COLOR_S *speccolor)
+{
+    SPEC_COLOR_S *hc = NULL;
+    COLOR_PAIR   *color_pair = NULL;
+    char         *colon, *fname;
+    char          fbuf[FBUF_LEN+1];
+    int           gotit;
+    PATTERN_S    *pat;
+
+    colon = strindex(fieldname, ':');
+    if(colon){
+	strncpy(fbuf, fieldname, MIN(colon-fieldname,FBUF_LEN));
+	fbuf[MIN(colon-fieldname,FBUF_LEN)] = '\0';
+	fname = fbuf;
+    }
+    else
+      fname = fieldname;
+
+    if(fname && *fname)
+      for(hc = speccolor; hc; hc = hc->next)
+	if(hc->spec && !strucmp(fname, hc->spec)){
+	    if(!hc->val)
+	      break;
+	    
+	    gotit = 0;
+	    for(pat = hc->val; !gotit && pat; pat = pat->next)
+	      if(srchstr(value, pat->substring))
+		gotit++;
+	    
+	    if(gotit)
+	      break;
+	}
+
+    if(hc && hc->fg && hc->fg[0] && hc->bg && hc->bg[0])
+      color_pair = new_color_pair(hc->fg, hc->bg);
+    
+    return(color_pair);
+}
+
+
+/*
+ * The argument fieldname is something like "Subject:..." or "Subject".
+ * Look through the specs in hdr_colors for a match of the fieldname,
+ * and return 1 if that fieldname is in one of the patterns, 0 otherwise.
+ */
+int
+any_hdr_color(char *fieldname)
+{
+    SPEC_COLOR_S *hc = NULL;
+    char         *colon, *fname;
+    char          fbuf[FBUF_LEN+1];
+
+    colon = strindex(fieldname, ':');
+    if(colon){
+	strncpy(fbuf, fieldname, MIN(colon-fieldname,FBUF_LEN));
+	fbuf[MIN(colon-fieldname,FBUF_LEN)] = '\0';
+	fname = fbuf;
+    }
+    else
+      fname = fieldname;
+
+    if(fname && *fname)
+      for(hc = ps_global->hdr_colors; hc; hc = hc->next)
+	if(hc->spec && !strucmp(fname, hc->spec))
+	  break;
+
+    return(hc ? 1 : 0);
+}
+
+
+/*----------------------------------------------------------------------
+     Format an address field, wrapping lines nicely at commas
+
+  Args: field_name  -- The name of the field we're formatting ("TO: ", ...)
+        addr        -- ADDRESS structure to format
+
+ Result: A formatted, malloced string is returned.
+  ----------------------------------------------------------------------*/
+void
+format_addr_string(MAILSTREAM *stream, long int msgno, char *section, char *field_name,
+		   struct mail_address *addr, int flags, char *oacs, gf_io_t pc)
+{
+    char    *ptmp, *mtmp;
+    int	     trailing = 0, group = 0;
+    ADDRESS *atmp;
+
+    if(!addr)
+      return;
+
+    /*
+     * quickly run down address list to make sure none are patently bogus.
+     * If so, just blat raw field out.
+     */
+    for(atmp = addr; stream && atmp; atmp = atmp->next)
+      if(atmp->host && atmp->host[0] == '.'){
+	  char *field, *fields[2];
+
+	  fields[1] = NULL;
+	  fields[0] = cpystr(field_name);
+	  if((ptmp = strchr(fields[0], ':')) != NULL)
+	    *ptmp = '\0';
+
+	  if((field = pine_fetchheader_lines(stream, msgno, section, fields)) != NULL){
+	      char *h, *t;
+
+	      for(t = h = field; *h ; t++)
+		if(*t == '\015' && *(t+1) == '\012'){
+		    *t = '\0';			/* tie off line */
+		    format_env_puts(h, pc);
+		    if(*(h = (++t) + 1))	/* set new h and skip CRLF */
+		      gf_puts(NEWLINE, pc);	/* more to write */
+		    else
+		      break;
+		}
+		else if(!*t){			/* shouldn't happen much */
+		    if(h != t)
+		      format_env_puts(h, pc);
+
+		    break;
+		}
+
+	      fs_give((void **)&field);
+	  }
+
+	  fs_give((void **)&fields[0]);
+	  gf_puts(NEWLINE, pc);
+	  dprint((2, "Error in \"%s\" field address\n",
+	         field_name ? field_name : "?"));
+	  return;
+      }
+
+    gf_puts(field_name, pc);
+
+    while(addr){
+	atmp	       = addr->next;		/* remember what's next */
+	addr->next     = NULL;
+	if(!addr->host && addr->mailbox){
+	    mtmp = addr->mailbox;
+	    addr->mailbox = cpystr((char *)rfc1522_decode_to_utf8(
+			   (unsigned char *)tmp_20k_buf,
+			   SIZEOF_20KBUF, addr->mailbox));
+	}
+
+	ptmp	       = addr->personal;	/* RFC 1522 personal name? */
+	addr->personal = iutf8ncpy((char *)tmp_20k_buf, (char *)rfc1522_decode_to_utf8((unsigned char *)(tmp_20k_buf+10000), SIZEOF_20KBUF-10000, addr->personal), 10000);
+	tmp_20k_buf[10000-1] = '\0';
+
+	if(!trailing)				/* 1st pass, just address */
+	  trailing++;
+	else{					/* else comma, unless */
+	    if(!((group == 1 && addr->host)	/* 1st addr in group, */
+	       || (!addr->host && !addr->mailbox))){ /* or end of group */
+		gf_puts(",", pc);
+#if	0
+		gf_puts(NEWLINE, pc);		/* ONE address/line please */
+		gf_puts("   ", pc);
+#endif
+	    }
+
+	    gf_puts(" ", pc);
+	}
+
+	pine_rfc822_write_address_noquote(addr, pc, &group);
+
+	addr->personal = ptmp;			/* restore old personal ptr */
+	if(!addr->host && addr->mailbox){
+	    fs_give((void **)&addr->mailbox);
+	    addr->mailbox = mtmp;
+	}
+
+	addr->next = atmp;
+	addr       = atmp;
+    }
+
+    gf_puts(NEWLINE, pc);
+}
+
+
+ 
+
+const char *rspecials_minus_quote_and_dot = "()<>@,;:\\[]";
+				/* RFC822 continuation, must start with CRLF */
+#define RFC822CONT "\015\012    "
+
+/* Write RFC822 address with some quoting turned off.
+ * Accepts: 
+ *	    address to interpret
+ *
+ * (This is a copy of c-client's rfc822_write_address except
+ *  we don't quote double quote and dot in personal names. It writes
+ *  to a gf_io_t instead of to a buffer so that we don't have to worry
+ *  about fixed sized buffer overflowing. It's also special cased to deal
+ *  with only a single address.)
+ *
+ * The idea is that there are some places where we'd just like to display
+ * the personal name as is before applying confusing quoting. However,
+ * we do want to be careful not to break things that should be quoted so
+ * we'll only use this where we are sure. Quoting may look ugly but it
+ * doesn't usually break anything.
+ */
+void
+pine_rfc822_write_address_noquote(struct mail_address *adr, gf_io_t pc, int *group)
+{
+  extern const char *rspecials;
+
+    if (adr->host) {		/* ordinary address? */
+      if (!(adr->personal || adr->adl)) pine_rfc822_address (adr, pc);
+      else {			/* no, must use phrase <route-addr> form */
+        if (adr->personal)
+	  pine_rfc822_cat (adr->personal, rspecials_minus_quote_and_dot, pc);
+
+        gf_puts(" <", pc);	/* write address delimiter */
+        pine_rfc822_address(adr, pc);
+        gf_puts (">", pc);	/* closing delimiter */
+      }
+
+      if(*group)
+	(*group)++;
+    }
+    else if (adr->mailbox) {	/* start of group? */
+				/* yes, write group name */
+      pine_rfc822_cat (adr->mailbox, rspecials, pc);
+
+      gf_puts (": ", pc);	/* write group identifier */
+      *group = 1;		/* in a group */
+    }
+    else if (*group) {		/* must be end of group (but be paranoid) */
+      gf_puts (";", pc);
+      *group = 0;		/* no longer in that group */
+    }
+}
+
+
+/* Write RFC822 route-address to string
+ * Accepts:
+ *	    address to interpret
+ */
+
+void
+pine_rfc822_address(struct mail_address *adr, gf_io_t pc)
+{
+  extern char *wspecials;
+
+  if (adr && adr->host) {	/* no-op if no address */
+    if (adr->adl) {		/* have an A-D-L? */
+      gf_puts (adr->adl, pc);
+      gf_puts (":", pc);
+    }
+				/* write mailbox name */
+    pine_rfc822_cat (adr->mailbox, wspecials, pc);
+    if (*adr->host != '@') {	/* unless null host (HIGHLY discouraged!) */
+      gf_puts ("@", pc);	/* host delimiter */
+      gf_puts (adr->host, pc);	/* write host name */
+    }
+  }
+}
+
+
+/* Concatenate RFC822 string
+ * Accepts: 
+ *	    pointer to string to concatenate
+ *	    list of special characters
+ */
+
+void
+pine_rfc822_cat(char *src, const char *specials, gf_io_t pc)
+{
+  char *s;
+
+  if (strpbrk (src,specials)) {	/* any specials present? */
+    gf_puts ("\"", pc);		/* opening quote */
+				/* truly bizarre characters in there? */
+    while ((s = strpbrk (src,"\\\"")) != NULL) {
+      char save[2];
+
+      /* turn it into a null-terminated piece */
+      save[0] = *s;
+      save[1] = '\0';
+      *s = '\0';
+      gf_puts (src, pc);	/* yes, output leader */
+      *s = save[0];
+      gf_puts ("\\", pc);	/* quoting */
+      gf_puts (save, pc);	/* output the bizarre character */
+      src = ++s;		/* continue after the bizarre character */
+    }
+    if (*src) gf_puts (src, pc);/* output non-bizarre string */
+    gf_puts ("\"", pc);		/* closing quote */
+  }
+  else gf_puts (src, pc);	/* otherwise it's the easy case */
+}
+
+
+/*----------------------------------------------------------------------
+  Format an address field, wrapping lines nicely at commas
+
+  Args: field_name  -- The name of the field we're formatting ("TO:", Cc:...)
+        newsgrps    -- ADDRESS structure to format
+
+  Result: A formatted, malloced string is returned.
+
+The resuling lines formatted are 80 columns wide.
+  ----------------------------------------------------------------------*/
+void
+format_newsgroup_string(char *field_name, char *newsgrps, int flags, gf_io_t pc)
+{
+    char     buf[MAILTMPLEN];
+    int	     trailing = 0, llen, alen;
+    char    *next_ng;
+    
+    if(!newsgrps || !*newsgrps)
+      return;
+    
+    gf_puts(field_name, pc);
+
+    llen = strlen(field_name);
+    while(*newsgrps){
+        for(next_ng = newsgrps; *next_ng && *next_ng != ','; next_ng++);
+        strncpy(buf, newsgrps, MIN(next_ng - newsgrps, sizeof(buf)-1));
+        buf[MIN(next_ng - newsgrps, sizeof(buf)-1)] = '\0';
+        newsgrps = next_ng;
+        if(*newsgrps)
+          newsgrps++;
+	alen = strlen(buf);
+	if(!trailing){			/* first time thru, just address */
+	    llen += alen;
+	    trailing++;
+	}
+	else{				/* else preceding comma */
+	    gf_puts(",", pc);
+	    llen++;
+
+	    if(alen + llen + 1 > 76){
+		gf_puts(NEWLINE, pc);
+		gf_puts("    ", pc);
+		llen = alen + 5;
+	    }
+	    else{
+		gf_puts(" ", pc);
+		llen += alen + 1;
+	    }
+	}
+
+	if(alen && llen > 76){		/* handle long addresses */
+	    register char *q, *p = &buf[alen-1];
+
+	    while(p > buf){
+		if(isspace((unsigned char)*p)
+		   && (llen - (alen - (int)(p - buf))) < 76){
+		    for(q = buf; q < p; q++)
+		      (*pc)(*q);	/* write character */
+
+		    gf_puts(NEWLINE, pc);
+		    gf_puts("    ", pc);
+		    gf_puts(p, pc);
+		    break;
+		}
+		else
+		  p--;
+	    }
+
+	    if(p == buf)		/* no reasonable break point */
+	      gf_puts(buf, pc);
+	}
+	else
+	  gf_puts(buf, pc);
+    }
+
+    gf_puts(NEWLINE, pc);
+}
+
+
+
+/*----------------------------------------------------------------------
+  Format a text field that's part of some raw (non-envelope) message header
+
+  Args: start --
+        finish --
+	pc -- 
+
+  Result: Semi-digested text (RFC 1522 decoded, anyway) written with "pc"
+
+  ----------------------------------------------------------------------*/
+int
+format_raw_hdr_string(char *start, char *finish, gf_io_t pc, char *oacs, int flags)
+{
+    register char *current;
+    unsigned char *p, *tmp = NULL, c;
+    size_t	   n, len;
+    char	   ch;
+    int		   rv = FHT_OK;
+
+    ch = *finish;
+    *finish = '\0';
+
+    if((n = 4*(finish-start)) > SIZEOF_20KBUF-1){
+	len = n+1;
+	p = tmp = (unsigned char *) fs_get(len * sizeof(unsigned char));
+    }
+    else{
+	len = SIZEOF_20KBUF;
+	p = (unsigned char *) tmp_20k_buf;
+    }
+
+    if(islower((unsigned char)(*start)))
+      *start = toupper((unsigned char)(*start));
+
+    current = (char *) rfc1522_decode_to_utf8(p, len, start);
+
+    /* output from start to finish */
+    while(*current && rv == FHT_OK)
+      if(ISRFCEOL(current)){
+	  if(!gf_puts(NEWLINE, pc))
+	    rv = FHT_WRTERR;
+
+	  current += 2;
+      }
+      else if((unsigned char)(*current) < 0x80 && FILTER_THIS(*current) &&
+	     !(*(current+1) && *current == ESCAPE && match_escapes(current+1))){
+	  c = (unsigned char) *current++;
+	  if(!((*pc)(c >= 0x80 ? '~' : '^')
+	       && (*pc)((c == 0x7f) ? '?' : (c & 0x1f) + '@')))
+	    rv = FHT_WRTERR;
+      }
+      else if(!(*pc)(*current++))
+	rv = FHT_WRTERR;
+
+    if(tmp)
+      fs_give((void **) &tmp);
+
+    *finish = ch;
+
+    return(rv);
+}
+
+
+
+
+/*----------------------------------------------------------------------
+  Format a text field that's part of some raw (non-envelope) message header
+
+  Args: s --
+	pc -- 
+
+  Result: Output
+
+  ----------------------------------------------------------------------*/
+int
+format_env_puts(char *s, gf_io_t pc)
+{
+    if(ps_global->pass_ctrl_chars)
+      return(gf_puts(s, pc));
+
+    for(; *s; s++)
+      if((unsigned char)(*s) < 0x80 && FILTER_THIS(*s) && !(*(s+1) && *s == ESCAPE && match_escapes(s+1))){
+	  if(!((*pc)((unsigned char) (*s) >= 0x80 ? '~' : '^')
+	       && (*pc)((*s == 0x7f) ? '?' : (*s & 0x1f) + '@')))
+	    return(0);
+      }
+      else if(!(*pc)(*s))
+	return(0);
+
+    return(1);
+}
+
+
+char *    
+display_parameters(PARAMETER *params)
+{
+    int		n, longest = 0;
+    char       *d, *printme;
+    PARAMETER  *p;
+    PARMLIST_S *parmlist;
+
+    for(p = params; p; p = p->next)	/* ok if we include *'s */
+      if(p->attribute && (n = strlen(p->attribute)) > longest)
+	longest = MIN(32, n);   /* shouldn't be any bigger than 32 */
+
+    d = tmp_20k_buf;
+    tmp_20k_buf[0] = '\0';
+    if((parmlist = rfc2231_newparmlist(params)) != NULL){
+	n = 0;			/* n overloaded */
+	while(rfc2231_list_params(parmlist) && d < tmp_20k_buf + 10000){
+	    if(n++){
+		snprintf(d, 10000-(d-tmp_20k_buf), "\n");
+		tmp_20k_buf[10000-1] = '\0';
+		d += strlen(d);
+	    }
+
+	    if(parmlist->value){
+		if(parmlist->attrib && strucmp(parmlist->attrib, "url") == 0){
+		    snprintf(printme = tmp_20k_buf + 11000, 1000, "%s", parmlist->value);
+		    sqzspaces(printme);
+		}
+		else
+		  printme = strsquish(tmp_20k_buf + 11000, 1000, parmlist->value, 100);
+	    }
+	    else
+	      printme = "";
+
+            snprintf(d, 10000-(d-tmp_20k_buf), "%-*s: %s", longest,
+		     parmlist->attrib ? parmlist->attrib : "", printme);
+
+	    tmp_20k_buf[10000-1] = '\0';
+            d += strlen(d);
+	}
+
+	rfc2231_free_parmlist(&parmlist);
+    }
+
+    return(tmp_20k_buf);
+}
+
+
+/*----------------------------------------------------------------------
+      Fetch the requested header fields from the msgno specified
+
+   Args: stream -- mail stream of open folder
+         msgno -- number of message to get header lines from
+         fields -- array of pointers to desired fields
+
+   Returns: allocated string containing matched header lines,
+	    NULL on error.
+ ----*/
+char *
+pine_fetch_header(MAILSTREAM *stream, long int msgno, char *section, char **fields, long int flags)
+{
+    STRINGLIST *sl;
+    char       *p, *m, *h = NULL, *match = NULL, *free_this, tmp[MAILTMPLEN];
+    char      **pflds = NULL, **pp = NULL, **qq;
+
+    /*
+     * If the user misconfigures it is possible to have one of the fields
+     * set to the empty string instead of a header name. We want to catch
+     * that here instead of asking the server the nonsensical question.
+     */
+    for(pp = fields ? &fields[0] : NULL; pp && *pp; pp++)
+      if(!**pp)
+	break;
+
+    if(pp && *pp){		/* found an empty header field, fix it */
+	pflds = copy_list_array(fields);
+	for(pp = pflds; pp && *pp; pp++){
+	    if(!**pp){			/* scoot rest of the lines up */
+		free_this = *pp;
+		for(qq = pp; *qq; qq++)
+		  *qq = *(qq+1);
+
+		if(free_this)
+		  fs_give((void **) &free_this);
+	    }
+	}
+
+	/* no headers to look for, return NULL */
+	if(pflds && !*pflds && !(flags & FT_NOT)){
+	    free_list_array(&pflds);
+	    return(NULL);
+	}
+    }
+    else
+      pflds = fields;
+
+    sl = (pflds && *pflds) ? new_strlst(pflds) : NULL;  /* package up fields */
+    h  = mail_fetch_header(stream, msgno, section, sl, NULL, flags | FT_PEEK);
+    if (sl) 
+      free_strlst(&sl);
+
+    if(!h){
+	if(pflds && pflds != fields)
+	  free_list_array(&pflds);
+	  
+	return(NULL);
+    }
+
+    while(find_field(&h, tmp, sizeof(tmp))){
+	for(pp = &pflds[0]; *pp && strucmp(tmp, *pp); pp++)
+	  ;
+
+	/* interesting field? */
+	if((p = (flags & FT_NOT) ? ((*pp) ? NULL : tmp) : *pp) != NULL){
+	    /*
+	     * Hold off allocating space for matching fields until
+	     * we at least find one to copy...
+	     */
+	    if(!match)
+	      match = m = fs_get(strlen(h) + strlen(p) + 1);
+
+	    while(*p)				/* copy field name */
+	      *m++ = *p++;
+
+	    while(*h && (*m++ = *h++))		/* header includes colon */
+	      if(*(m-1) == '\n' && (*h == '\r' || !isspace((unsigned char)*h)))
+		break;
+
+	    *m = '\0';				/* tie off match string */
+	}
+	else{					/* no match, pass this field */
+	    while(*h && !(*h++ == '\n'
+	          && (*h == '\r' || !isspace((unsigned char)*h))))
+	      ;
+	}
+    }
+
+    if(pflds && pflds != fields)
+      free_list_array(&pflds);
+
+    return(match ? match : cpystr(""));
+}
+
+
+int
+find_field(char **h, char *tmp, size_t ntmp)
+{
+    char *otmp = tmp;
+
+    if(!h || !*h || !**h || isspace((unsigned char)**h))
+      return(0);
+
+    while(tmp-otmp<ntmp-1 && **h && **h != ':' && !isspace((unsigned char)**h))
+      *tmp++ = *(*h)++;
+
+    *tmp = '\0';
+    return(1);
+}
+
+
+static char *_last_embedded_fg_color, *_last_embedded_bg_color;
+
+
+int
+embed_color(COLOR_PAIR *cp, gf_io_t pc)
+{
+    if(cp && cp->fg){
+	if(_last_embedded_fg_color)
+	  fs_give((void **)&_last_embedded_fg_color);
+
+	_last_embedded_fg_color = cpystr(cp->fg);
+
+	if(!(pc && (*pc)(TAG_EMBED) && (*pc)(TAG_FGCOLOR) &&
+	     gf_puts(color_to_asciirgb(cp->fg), pc)))
+	  return 0;
+    }
+    
+    if(cp && cp->bg){
+	if(_last_embedded_bg_color)
+	  fs_give((void **)&_last_embedded_bg_color);
+
+	_last_embedded_bg_color = cpystr(cp->bg);
+
+	if(!(pc && (*pc)(TAG_EMBED) && (*pc)(TAG_BGCOLOR) &&
+	     gf_puts(color_to_asciirgb(cp->bg), pc)))
+	  return 0;
+    }
+
+    return 1;
+}
+
+
+COLOR_PAIR *
+get_cur_embedded_color(void)
+{
+    COLOR_PAIR *ret;
+
+    if(_last_embedded_fg_color && _last_embedded_bg_color)
+      ret = new_color_pair(_last_embedded_fg_color, _last_embedded_bg_color);
+    else
+      ret = pico_get_cur_color();
+    
+    return(ret);
+}
+
+
+void
+clear_cur_embedded_color(void)
+{
+    if(_last_embedded_fg_color)
+      fs_give((void **)&_last_embedded_fg_color);
+
+    if(_last_embedded_bg_color)
+      fs_give((void **)&_last_embedded_bg_color);
+}
+
+
+int
+scroll_handle_start_color(char *colorstring, size_t buflen, int *len)
+{
+    *len = 0;
+
+    if(pico_usingcolor()){
+	char *fg = NULL, *bg = NULL, *s;
+
+	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(bg || fg){
+	    COLOR_PAIR *tmp;
+
+	    /*
+	     * The blacks are just known good colors for
+	     * testing whether the other color is good.
+	     */
+	    if((tmp = new_color_pair(fg ? fg : colorx(COL_BLACK),
+				     bg ? bg : colorx(COL_BLACK))) != NULL){
+		if(pico_is_good_colorpair(tmp))
+		  for(s = color_embed(fg, bg);
+		      (*len) < buflen && (colorstring[*len] = *s);
+		      s++, (*len)++)
+		    ;
+
+		free_color_pair(&tmp);
+	    }
+	}
+
+	if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global)){
+	    strncpy(colorstring + (*len), url_embed(TAG_BOLDON), MIN(3,buflen-(*len)));
+	    *len += 2;
+	}
+    }
+
+    colorstring[buflen-1] = '\0';
+
+    return(*len != 0);
+}
+
+
+int
+scroll_handle_end_color(char *colorstring, size_t buflen, int *len, int use_hdr_color)
+{
+    *len = 0;
+    if(pico_usingcolor()){
+	char *fg = NULL, *bg = NULL, *s;
+	char *basefg = NULL, *basebg = NULL;
+
+	basefg = use_hdr_color	? ps_global->VAR_HEADER_GENERAL_FORE_COLOR
+				: ps_global->VAR_NORM_FORE_COLOR;
+	basebg = use_hdr_color	? ps_global->VAR_HEADER_GENERAL_BACK_COLOR
+				: ps_global->VAR_NORM_BACK_COLOR;
+
+	/*
+	 * We need to change the fg and bg colors back even if they
+	 * are the same as the Normal Colors so that color_a_quote
+	 * will have a chance to pick up those colors as the ones to
+	 * switch to. We don't do this before the handle above so that
+	 * the quote color will flow into the selectable item when
+	 * the selectable item color is partly the same as the
+	 * normal color. That is, suppose the normal color was black on
+	 * cyan and the selectable color was blue on cyan, only a fg color
+	 * change. We preserve the only-a-fg-color-change in a quote by
+	 * letting the quote background color flow into the selectable text.
+	 */
+	if(ps_global->VAR_SLCTBL_FORE_COLOR)
+	  fg = basefg;
+
+	if(ps_global->VAR_SLCTBL_BACK_COLOR)
+	  bg = basebg;
+
+	if(F_OFF(F_SLCTBL_ITEM_NOBOLD, ps_global)){
+	    strncpy(colorstring, url_embed(TAG_BOLDOFF), MIN(3,buflen));
+	    *len = 2;
+	}
+
+	if(fg || bg)
+	  for(s = color_embed(fg, bg); (*len) < buflen && (colorstring[*len] = *s); s++, (*len)++)
+	    ;
+    }
+
+    colorstring[buflen-1] = '\0';
+
+    return(*len != 0);
+}
+
+
+/*
+ * Helper routine that is of limited use.
+ * We need to tally up the screen width of
+ * a UTF-8 string as we go through the string.
+ * We just want the width of the character starting
+ * at str (and no longer than remaining_octets).
+ * If we're plopped into the middle of a UTF-8
+ * character we just want to return width zero.
+ */
+int
+width_at_this_position(unsigned char *str, unsigned long n)
+{
+    unsigned char *inputp = str;
+    unsigned long  remaining_octets = n;
+    UCS            ucs;
+    int            width = 0;
+
+    ucs = (UCS) utf8_get(&inputp, &remaining_octets);
+    if(!(ucs & U8G_ERROR || ucs == UBOGON)){
+	width = wcellwidth(ucs);
+	/* Writechar will print a '?' */
+	if(width < 0)
+	  width = 1;
+    }
+
+    return(width);
+}