* New version 2.26

[alpine.git] / pith / reply.c

/*
 * ========================================================================
 * Copyright 2013-2022 Eduardo Chappa
 * Copyright 2006-2008 University of Washington
 *
 * 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
 *
 * ========================================================================
 */

#include "../pith/headers.h"
#include "../pith/reply.h"
#include "../pith/send.h"
#include "../pith/init.h"
#include "../pith/state.h"
#include "../pith/conf.h"
#include "../pith/remote.h"
#include "../pith/status.h"
#include "../pith/mailview.h"
#include "../pith/filter.h"
#include "../pith/newmail.h"
#include "../pith/bldaddr.h"
#include "../pith/mailindx.h"
#include "../pith/mimedesc.h"
#include "../pith/detach.h"
#include "../pith/help.h"
#include "../pith/pipe.h"
#include "../pith/addrstring.h"
#include "../pith/news.h"
#include "../pith/util.h"
#include "../pith/pattern.h"
#include "../pith/detoken.h"
#include "../pith/stream.h"
#include "../pith/busy.h"
#include "../pith/readfile.h"
#include "../pith/text.h"
#include "../pith/list.h"
#include "../pith/ablookup.h"
#include "../pith/mailcmd.h"
#include "../pith/margin.h"
#include "../pith/smime.h"


/*
 * Internal prototypes
 */
void     bounce_mask_header(char **, char *);


int     (*pith_opt_replyto_prompt)(void);
int     (*pith_opt_reply_to_all_prompt)(int *);


/*
 * standard type of storage object used for body parts...
 */
#define           PART_SO_TYPE  CharStar


char *(*pith_opt_user_agent_prefix)(void);

/* compare two subjects and return if they are the same.
   We compare stripped subjects, that is, those that do
   not have re/fwd. Before we compare the subjects, we
   decode them in case they were encoded.
   Return value: 0 - not the same subject, 1 - same subject.
*/

int
same_subject(char *s, char *t)
{
   int rv = 0;
   int i, j, len;
   char *s1, *s2;       /* holds decoded subjects from s and t */
   char *u, *v;

   if (s == NULL || t == NULL)
     return s == t ? 1 : 0;

   i = strlen(s); j = strlen(t);
   len = i < j ? j : i;
   u  = fs_get(6*len+1);
   v  = fs_get(6*len+1);
   s1 = (char *) rfc1522_decode_to_utf8((unsigned char *) u, 6*len + 1, s);
   s2 = (char *) rfc1522_decode_to_utf8((unsigned char *) v, 6*len + 1, t);
   mail_strip_subject(s1, &u);
   mail_strip_subject(s2, &v);

   rv = !strucmp(u, v);

   fs_give((void **) &u);
   fs_give((void **) &v);
   return rv;
}

/*
 * reply_harvest - 
 *
 *  Returns: 1 if addresses successfully copied
 *           0 on user cancel or error
 *
 *  Input flags: 
 *               RSF_FORCE_REPLY_TO
 *               RSF_QUERY_REPLY_ALL
 *               RSF_FORCE_REPLY_ALL
 *
 *  Output flags:
 *               RSF_FORCE_REPLY_ALL
 * 
 */
int
reply_harvest(struct pine *ps, long int msgno, char *section, ENVELOPE *env,
              struct mail_address **saved_from, struct mail_address **saved_to,
              struct mail_address **saved_cc, struct mail_address **saved_resent,
              int *flags)
{
    ADDRESS *ap, *ap2, *rep_address;
    int      ret = 0, sniff_resent = 0;
    char    *rep_field;

      /*
       * If Reply-To is same as From just treat it like it was From.
       * Otherwise, always use the reply-to if we're replying to more
       * than one msg or say ok to using it, even if it's us.
       * If there's no reply-to or it's the same as the from, assume
       * that the user doesn't want to reply to himself, unless there's
       * nobody else.
       */
    if(env->reply_to && !addr_lists_same(env->reply_to, env->from)
       && (F_ON(F_AUTO_REPLY_TO, ps)
           || ((*flags) & RSF_FORCE_REPLY_TO)
           || (pith_opt_replyto_prompt && (*pith_opt_replyto_prompt)() == 'y'))){
        rep_field   = "reply-to";
        rep_address = env->reply_to;
    }
    else{
        rep_field   = "From";
        rep_address = env->from;
    }

    ap = reply_cp_addr(ps, msgno, section, rep_field, *saved_from,
                       (ADDRESS *) NULL, rep_address, RCA_NOT_US);

    if(ret == 'x') {
        cmd_cancelled("Reply");
        return(0);
    }

    reply_append_addr(saved_from, ap);

    /*--------- check for other recipients ---------*/
    if(((*flags) & (RSF_FORCE_REPLY_ALL | RSF_QUERY_REPLY_ALL))){

        if((ap = reply_cp_addr(ps, msgno, section, "To", *saved_to,
                              *saved_from, env->to, RCA_NOT_US)) != NULL)
          reply_append_addr(saved_to, ap);

        if((ap = reply_cp_addr(ps, msgno, section, "Cc", *saved_cc,
                              *saved_from, env->cc, RCA_NOT_US)) != NULL)
          reply_append_addr(saved_cc, ap);

        /*
         * In these cases, we either need to look at the resent headers
         * to include in the reply-to-all, or to decide whether or not
         * we need to ask the reply-to-all question.
         */
        if(((*flags) & RSF_FORCE_REPLY_ALL)
           || (((*flags) & RSF_QUERY_REPLY_ALL)
               && ((!(*saved_from) && !(*saved_cc))
                   || (*saved_from && !(*saved_to) && !(*saved_cc))))){

            sniff_resent++;
            if((ap2 = reply_resent(ps, msgno, section)) != NULL){
                /*
                 * look for bogus addr entries and replace
                 */
                if((ap = reply_cp_addr(ps, 0, NULL, NULL, *saved_resent,
                                      *saved_from, ap2, RCA_NOT_US)) != NULL)

                  reply_append_addr(saved_resent, ap);

                mail_free_address(&ap2);
            }
        }

        /*
         * It makes sense to ask reply-to-all now.
         */
        if(((*flags) & RSF_QUERY_REPLY_ALL)
           && ((*saved_from && (*saved_to || *saved_cc || *saved_resent))
               || (*saved_cc || *saved_resent))){
            *flags &= ~RSF_QUERY_REPLY_ALL;
            if(pith_opt_reply_to_all_prompt
               && (*pith_opt_reply_to_all_prompt)(flags) < 0){
                cmd_cancelled("Reply");
                return(0);
            }
        }

        /*
         * If we just answered yes to the reply-to-all question and
         * we still haven't collected the resent headers, do so now.
         */
        if(((*flags) & RSF_FORCE_REPLY_ALL) && !sniff_resent
           && (ap2 = reply_resent(ps, msgno, section))){
            /*
             * look for bogus addr entries and replace
             */
            if((ap = reply_cp_addr(ps, 0, NULL, NULL, *saved_resent,
                                  *saved_from, ap2, RCA_NOT_US)) != NULL)
              reply_append_addr(saved_resent, ap);

            mail_free_address(&ap2);
        }
    }

    return(1);
}


/*----------------------------------------------------------------------
    Return a pointer to a copy of the given address list
  filtering out those already in the "mask" lists and ourself.

Args:  mask1  -- Don't copy if in this list
       mask2  --  or if in this list
       source -- List to be copied
       us_too -- Don't filter out ourself.
       flags  -- RCA_NOT_US   copy all addrs except for our own
                 RCA_ALL      copy all addrs, including our own
                 RCA_ONLY_US  copy only addrs that are our own

  ---*/
ADDRESS *
reply_cp_addr(struct pine *ps, long int msgno, char *section, char *field,
              struct mail_address *mask1, struct mail_address *mask2,
              struct mail_address *source, int flags)
{
    ADDRESS *tmp1, *tmp2, *ret = NULL, **ret_tail;

    /* can only choose one of these flags values */
    assert(!((flags & RCA_ALL && flags & RCA_ONLY_US)
             || (flags & RCA_ALL && flags & RCA_NOT_US)
             || (flags & RCA_ONLY_US && flags & RCA_NOT_US)));

    for(tmp1 = source; msgno && tmp1; tmp1 = tmp1->next)
      if(tmp1->host && tmp1->host[0] == '.'){
          char *h, *fields[2];

          fields[0] = field;
          fields[1] = NULL;
          if((h = pine_fetchheader_lines(ps ? ps->mail_stream : NULL,
                                        msgno, section, fields)) != NULL){
              char *p, fname[32];
              int q;

              q = strlen(h);

              strncpy(fname, field, sizeof(fname)-2);
              fname[sizeof(fname)-2] = '\0';
              strncat(fname, ":", sizeof(fname)-strlen(fname)-1);
              fname[sizeof(fname)-1] = '\0';

              for(p = h; (p = strstr(p, fname)) != NULL; )
                rplstr(p, q-(p-h), strlen(fname), "");  /* strip field strings */

              sqznewlines(h);                   /* blat out CR's & LF's */
              for(p = h; (p = strchr(p, TAB)) != NULL; )
                *p++ = ' ';                     /* turn TABs to whitespace */

              if(*h){
                  long l;
                  size_t ll;

                  ret = (ADDRESS *) fs_get(sizeof(ADDRESS));
                  memset(ret, 0, sizeof(ADDRESS));

                  /* get rid of leading white space */
                  for(p = h; *p == SPACE; p++)
                    ;
                  
                  if(p != h){
                      memmove(h, p, l = strlen(p));
                      h[l] = '\0';
                  }

                  /* base64 armor plate the gunk to protect against
                   * c-client quoting in output.
                   */
                  p = (char *) rfc822_binary(h, strlen(h),
                                             (unsigned long *) &l);
                  sqznewlines(p);
                  fs_give((void **) &h);
                  /*
                   * Seems like the 4 ought to be a 2, but I'll leave it
                   * to be safe, in case something else adds 2 chars later.
                   */
                  ll = strlen(p) + 4;
                  ret->mailbox = (char *) fs_get(ll * sizeof(char));
                  snprintf(ret->mailbox, ll, "&%s", p);
                  ret->mailbox[ll-1] = '\0';
                  fs_give((void **) &p);
                  ret->host = cpystr(RAWFIELD);
              }
          }

          return(ret);
      }

    ret_tail = &ret;
    for(source = first_addr(source); source; source = source->next){
        for(tmp1 = first_addr(mask1); tmp1; tmp1 = tmp1->next)
          if(address_is_same(source, tmp1))     /* it is in mask1, skip it */
            break;

        for(tmp2 = first_addr(mask2); !tmp1 && tmp2; tmp2 = tmp2->next)
          if(address_is_same(source, tmp2))     /* it is in mask2, skip it */
            break;

        /*
         * If there's no match in masks and this address satisfies the
         * flags requirement, copy it.
         */
        if(!tmp1 && !tmp2               /* no mask match */
           && ((flags & RCA_ALL)        /* including everybody */
               || (flags & RCA_ONLY_US && address_is_us(source, ps))
               || (flags & RCA_NOT_US && !address_is_us(source, ps)))){
            tmp1         = source->next;
            source->next = NULL;        /* only copy one addr! */
            *ret_tail    = rfc822_cpy_adr(source);
            ret_tail     = &(*ret_tail)->next;
            source->next = tmp1;        /* restore rest of list */
        }
    }

    return(ret);
}


ACTION_S *
set_role_from_msg(struct pine *ps, long int rflags, long int msgno, char *section)
{
    ACTION_S      *role = NULL;
    PAT_S         *pat = NULL;
    SEARCHSET     *ss = NULL;
    PAT_STATE      pstate;

    if(!nonempty_patterns(rflags, &pstate))
      return(role);

    if(msgno > 0L){
        ss = mail_newsearchset();
        ss->first = ss->last = (unsigned long)msgno;
    }

    /* Go through the possible roles one at a time until we get a match. */
    pat = first_pattern(&pstate);

    /* calculate this message's score if needed */
    if(ss && pat && scores_are_used(SCOREUSE_GET) & SCOREUSE_ROLES &&
       get_msg_score(ps->mail_stream, msgno) == SCORE_UNDEF)
      (void)calculate_some_scores(ps->mail_stream, ss, 0);

    while(!role && pat){
        if(match_pattern(pat->patgrp, ps->mail_stream, ss, section,
                         get_msg_score, SE_NOSERVER|SE_NOPREFETCH)){
            if(!pat->action || pat->action->bogus)
              break;

            role = pat->action;
        }
        else
          pat = next_pattern(&pstate);
    }

    if(ss)
      mail_free_searchset(&ss);

    return(role);
}


/*
 * reply_seed - fill in reply header
 * 
 */
void
reply_seed(struct pine *ps, ENVELOPE *outgoing, ENVELOPE *env,
           struct mail_address *saved_from, struct mail_address *saved_to,
           struct mail_address *saved_cc, struct mail_address *saved_resent,
           char **fcc, int replytoall, char **errmsg)
{
    ADDRESS **to_tail, **cc_tail;
    
    to_tail = &outgoing->to;
    cc_tail = &outgoing->cc;

    if(saved_from){
        /* Put Reply-To or From in To. */
        *to_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->to,
                                 (ADDRESS *) NULL, saved_from, RCA_ALL);
        if(replytoall){
            if(ps->reply.preserve_fields){
                while(*to_tail)
                   to_tail = &(*to_tail)->next;

                *to_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->to,
                                 (ADDRESS *) NULL, saved_to, RCA_ALL);

                while(*to_tail)
                   to_tail = &(*to_tail)->next;

                *to_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->cc,
                                     outgoing->to, saved_resent, RCA_ALL);

                *cc_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->cc,
                                     outgoing->to, saved_cc, RCA_ALL);
            }
            else{       /* and the rest in cc */
                *cc_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->cc,
                                     outgoing->to, saved_to, RCA_ALL);
                while(*cc_tail)         /* stay on last address */
                   cc_tail = &(*cc_tail)->next;

                *cc_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->cc,
                                     outgoing->to, saved_cc, RCA_ALL);
                while(*cc_tail)
                      cc_tail = &(*cc_tail)->next;

                *cc_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->cc,
                                     outgoing->to, saved_resent, RCA_ALL);
            }
        }
    }
    else if(saved_to){
        /* No From (maybe from us), put To in To. */
        *to_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->to,
                                 (ADDRESS *)NULL, saved_to, RCA_ALL);
        /* and the rest in cc */
        if(replytoall){
            *cc_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->cc,
                                     outgoing->to, saved_cc, RCA_ALL);
            while(*cc_tail)
              cc_tail = &(*cc_tail)->next;

            *cc_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->cc,
                                     outgoing->to, saved_resent, RCA_ALL);
        }
    }
    else{
        /* No From or To, put everything else in To if replytoall, */
        if(replytoall){
            *to_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->to,
                                     (ADDRESS *) NULL, saved_cc, RCA_ALL);
            while(*to_tail)
              to_tail = &(*to_tail)->next;

            *to_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->to,
                                     (ADDRESS *) NULL, saved_resent, RCA_ALL);
        }
        /* else, reply to original From which must be us */
        else{
            /*
             * Put self in To if in original From.
             */
            if(!outgoing->newsgroups)
              *to_tail = reply_cp_addr(ps, 0, NULL, NULL, outgoing->to,
                                       (ADDRESS *) NULL, env->from, RCA_ALL);
        }
    }

    /* add any missing personal data */
    reply_fish_personal(outgoing, env);

    /* get fcc */
    if(fcc && outgoing->to && outgoing->to->host[0] != '.'){
        *fcc = get_fcc_based_on_to(outgoing->to);
    }
    else if(fcc && outgoing->newsgroups){
        char *newsgroups_returned = NULL;
        int   rv;

        rv = news_grouper(outgoing->newsgroups, &newsgroups_returned, errmsg, fcc, NULL);
        if(rv != -1 &&
            strcmp(outgoing->newsgroups, newsgroups_returned)){
            fs_give((void **)&outgoing->newsgroups);
            outgoing->newsgroups = newsgroups_returned;
        }
        else
          fs_give((void **) &newsgroups_returned);
    }
}


/*----------------------------------------------------------------------
    Test the given address lists for equivalence

Args:  x -- First address list for comparison
       y -- Second address for comparison

  ---*/
int
addr_lists_same(struct mail_address *x, struct mail_address *y)
{
    for(x = first_addr(x), y = first_addr(y);
        x && y;
        x = first_addr(x->next), y = first_addr(y->next)){
        if(!address_is_same(x, y))
          return(0);
    }

    return(!x && !y);                   /* true if ran off both lists */
}


/*----------------------------------------------------------------------
    Test the given address against those in the given envelope's to, cc

Args:  addr -- address for comparison
       env  -- envelope to compare against

  ---*/
int
addr_in_env(struct mail_address *addr, ENVELOPE *env)
{
    ADDRESS *ap;

    for(ap = env ? env->to : NULL; ap; ap = ap->next)
      if(address_is_same(addr, ap))
        return(1);

    for(ap = env ? env->cc : NULL; ap; ap = ap->next)
      if(address_is_same(addr, ap))
        return(1);

    return(0);                          /* not found! */
}


/*----------------------------------------------------------------------
    Add missing personal info dest from src envelope

Args:  dest -- envelope to add personal info to
       src  -- envelope to get personal info from

NOTE: This is just kind of a courtesy function.  It's really not adding
      anything needed to get the mail thru, but it is nice for the user
      under some odd circumstances.
  ---*/
void
reply_fish_personal(ENVELOPE *dest, ENVELOPE *src)
{
    ADDRESS *da, *sa;

    for(da = dest ? dest->to : NULL; da; da = da->next){
        if(da->personal && !da->personal[0])
          fs_give((void **)&da->personal);

        for(sa = src ? src->to : NULL; sa && !da->personal ; sa = sa->next)
          if(address_is_same(da, sa) && sa->personal && sa->personal[0])
            da->personal = cpystr(sa->personal);

        for(sa = src ? src->cc : NULL; sa && !da->personal; sa = sa->next)
          if(address_is_same(da, sa) && sa->personal && sa->personal[0])
            da->personal = cpystr(sa->personal);
    }

    for(da = dest ? dest->cc : NULL; da; da = da->next){
        if(da->personal && !da->personal[0])
          fs_give((void **)&da->personal);

        for(sa = src ? src->to : NULL; sa && !da->personal; sa = sa->next)
          if(address_is_same(da, sa) && sa->personal && sa->personal[0])
            da->personal = cpystr(sa->personal);

        for(sa = src ? src->cc : NULL; sa && !da->personal; sa = sa->next)
          if(address_is_same(da, sa) && sa->personal && sa->personal[0])
            da->personal = cpystr(sa->personal);
    }
}


/*----------------------------------------------------------------------
   Given a header field and envelope, build "References: " header data

Args:  

Returns: 
  ---*/
char *
reply_build_refs(ENVELOPE *env)
{
    int   len, id_len, first_ref_len = 0, foldslop;
    char *p, *refs = NULL, *h = env->references;
    char *first_ref = NULL, *tail_refs = NULL;


    if(!(env->message_id && (id_len = strlen(env->message_id))))
      return(NULL);

    if(h){
        /*
         * The length we have to work with doesn't seem to appear in any
         * standards. Steve Jones says that in comp.news discussions he
         * has seen 1024 as the longest length of a header value.
         * In the inn news source we find MAXHEADERSIZE = 1024. It appears
         * that is the maximum length of the header value, including 
         * newlines for folded lines (that is, the newlines are counted).
         * We'll be conservative and figure every reference will take up a
         * line of its own when we fold. We'll also count 2 for CRLF instead
         * of just one for LF just to be safe.       hubert 2001-jan
         * J.B. Moreno <planb@newsreaders.com> says "The server limit is
         * more commonly encountered at 999/1000 bytes [...]". So we'll
         * back off to 999 instead of 1024.
         */
#define MAXHEADERSIZE (999)

        /* count the total number of potential folds, max of 2 bytes each */
        for(foldslop = 2, p = h; (p = strstr(p+1, "> <")); )
          foldslop += 2;
        
        if((len=strlen(h)) + 1+id_len + foldslop >= MAXHEADERSIZE
           && (p = strstr(h, "> <"))){
            /*
             * If the references line is so long that we are going to have
             * to delete some of the references, delete the 2nd, 3rd, ...
             * We don't want to delete the first message in the thread.
             */
            p[1] = '\0';
            first_ref = cpystr(h);
            first_ref_len = strlen(first_ref)+1;        /* len includes space */
            p[1] = ' ';
            tail_refs = p+2;
            /* get rid of 2nd, 3rd, ... until it fits */
            while((len=strlen(tail_refs)) + first_ref_len + 1+id_len +
                                                    foldslop >= MAXHEADERSIZE
                  && (p = strstr(tail_refs, "> <"))){
                tail_refs = p + 2;
                foldslop -= 2;
            }

            /*
             * If the individual references are seriously long, somebody
             * is messing with us and we don't care if it works right.
             */
            if((len=strlen(tail_refs)) + first_ref_len + 1+id_len +
                                                    foldslop >= MAXHEADERSIZE){
                first_ref_len = len = 0;
                tail_refs = NULL;
                if(first_ref)
                  fs_give((void **)&first_ref);
            }
        }
        else
          tail_refs = h;

        refs = (char *)fs_get((first_ref_len + 1+id_len + len + 1) *
                                                        sizeof(char));
        snprintf(refs, first_ref_len + 1+id_len + len + 1, "%s%s%s%s%s",
                first_ref ? first_ref : "",
                first_ref ? " " : "",
                tail_refs ? tail_refs : "",
                tail_refs ? " " : "",
                env->message_id);
        refs[first_ref_len + 1+id_len + len] = '\0';
    }

    if(!refs && id_len)
      refs = cpystr(env->message_id);

    if(first_ref)
      fs_give((void **)&first_ref);

    return(refs);
}



/*----------------------------------------------------------------------
   Snoop for any Resent-* headers, and return an ADDRESS list

Args:  stream -- 
       msgno -- 

Returns: either NULL if no Resent-* or parsed ADDRESS struct list
  ---*/
ADDRESS *
reply_resent(struct pine *pine_state, long int msgno, char *section)
{
#define RESENTFROM 0
#define RESENTTO   1
#define RESENTCC   2
    ADDRESS     *rlist = NULL, **a, **b;
    char        *hdrs, *values[RESENTCC+1];
    int          i;
    static char *fields[] = {"Resent-From", "Resent-To", "Resent-Cc", NULL};
    static char *fakedomain = "@";

    if((hdrs = pine_fetchheader_lines(pine_state->mail_stream,
                                     msgno, section, fields)) != NULL){
        memset(values, 0, (RESENTCC+1) * sizeof(char *));
        simple_header_parse(hdrs, fields, values);
        for(i = RESENTFROM; i <= RESENTCC; i++)
          rfc822_parse_adrlist(&rlist, values[i],
                               (F_ON(F_COMPOSE_REJECTS_UNQUAL, pine_state))
                                 ? fakedomain : pine_state->maildomain);

        /* pare dup's ... */
        for(a = &rlist; *a; a = &(*a)->next)    /* compare every address */
          for(b = &(*a)->next; *b; )            /* to the others         */
            if(address_is_same(*a, *b)){
                ADDRESS *t = *b;

                if(!(*a)->personal){            /* preserve personal name */
                    (*a)->personal = (*b)->personal;
                    (*b)->personal = NULL;
                }

                *b      = t->next;
                t->next = NULL;
                mail_free_address(&t);
            }
            else
              b = &(*b)->next;
    }

    if(hdrs)
      fs_give((void **) &hdrs);
    
    return(rlist);
}


/*----------------------------------------------------------------------
    Format and return subject suitable for the reply command

Args:  subject -- subject to build reply subject for
       buf -- buffer to use for writing.  If non supplied, alloc one.
       buflen -- length of buf if supplied, else ignored

Returns: with either "Re:" prepended or not, if already there.
         returned string is allocated.
  ---*/
char *
reply_subject(char *subject, char *buf, size_t buflen)
{
    size_t  l   = (subject && *subject) ? 4*strlen(subject) : 10;
    char   *tmp = fs_get(l + 1), *decoded, *p;

    if(!buf){
        buflen = l + 5;
        buf = fs_get(buflen);
    }

    /* decode any 8bit into tmp buffer */
    decoded = (char *) rfc1522_decode_to_utf8((unsigned char *)tmp, l+1, subject);

    buf[0] = '\0';
    if(decoded                                  /* already "re:" ? */
       && (decoded[0] == 'R' || decoded[0] == 'r')
       && (decoded[1] == 'E' || decoded[1] == 'e')){

        if(decoded[2] == ':')
          snprintf(buf, buflen, "%.*s", (int)(buflen-1), subject);
        else if((decoded[2] == '[') && (p = strchr(decoded, ']'))){
            p++;
            while(*p && isspace((unsigned char)*p)) p++;
            if(p[0] == ':')
              snprintf(buf, buflen, "%.*s", (int)(buflen-1), subject);
        }
    }

    if(!buf[0])
      snprintf(buf, buflen, "Re: %.*s", (int)(buflen-1),
              (subject && *subject) ? subject : "your mail");

    buf[buflen-1] = '\0';

    fs_give((void **) &tmp);
    return(buf);
}


/*----------------------------------------------------------------------
    return initials for the given personal name

Args:  name -- Personal name to extract initials from

Returns: pointer to name overwritten with initials
  ---*/
char *
reply_quote_initials(char *name)
{
    char *s = name,
         *w = name;
    int i, j;
    CBUF_S cbuf;
    UCS ucs;

    cbuf.cbuf[i = 0] = '\0';
    cbuf.cbufp = cbuf.cbuf;
    cbuf.cbufend = cbuf.cbuf;

    /* while there are still characters to look at */
    while(s && *s){
        /* skip to next initial */
        while(*s && (unsigned char) *s == ' ')
          s++;
        
        if(!utf8_to_ucs4_oneatatime((unsigned char) *s++ & 0xff, &cbuf, &ucs, NULL)){
          i++;
          continue;
        }

        /* skip over non-alpha stuff */
        if(i == 0 && !isalnum((unsigned char) cbuf.cbuf[0]))
          goto reset_cbuf;

        /* copy cbuf */
        for(j = 0; j <= i; j++) *w++ =  cbuf.cbuf[j];
        
        /* skip to end of this piece of name */
        while(*s && (unsigned char) *s != ' ')
          s++;

reset_cbuf:
        cbuf.cbuf[i = 0] = '\0';
        cbuf.cbufp = cbuf.cbuf;
        cbuf.cbufend = cbuf.cbuf;
    }

    if(w)
      *w = '\0';

    return(name);
}

/*
 * There is an assumption that MAX_SUBSTITUTION is <= the size of the
 * tokens being substituted for (only in the size of buf below).
 */
#define MAX_SUBSTITUTION 6
#define MAX_PREFIX 63
static char *from_token = "_FROM_";
static char *nick_token = "_NICK_";
static char *init_token = "_INIT_";

/*----------------------------------------------------------------------
    return a quoting string, "> " by default, for replied text

Args:  env -- envelope of message being replied to

Returns: malloc'd array containing quoting string, freed by caller
  ---*/
char *
reply_quote_str(ENVELOPE *env)
{
    char *prefix, *repl, *p, buf[MAX_PREFIX+1], pbf[MAX_SUBSTITUTION+1];

    strncpy(buf, ps_global->VAR_REPLY_STRING, sizeof(buf)-1);
    buf[sizeof(buf)-1] = '\0';

    /* set up the prefix to quote included text */
    if((p = strstr(buf, from_token)) != NULL){
        repl = (env && env->from && env->from->mailbox) ? env->from->mailbox
                                                        : "";
        strncpy(pbf, repl, sizeof(pbf)-1);
        pbf[sizeof(pbf)-1] = '\0';;
        rplstr(p, sizeof(buf)-(p-buf), strlen(from_token), pbf);
    }
    
    if((p = strstr(buf, nick_token)) != NULL){
        repl = (env &&
                env->from &&
                env->from &&
                get_nickname_from_addr(env->from, tmp_20k_buf, 1000))
                 ? tmp_20k_buf : "";
        strncpy(pbf, repl, sizeof(pbf)-1);
        pbf[sizeof(pbf)-1] = '\0';;
        rplstr(p, sizeof(buf)-(p-buf), strlen(nick_token), pbf);
    }

    if((p = strstr(buf, init_token)) != NULL){
        char *q = NULL;
        char  buftmp[MAILTMPLEN];

        snprintf(buftmp, sizeof(buftmp), "%.200s",
         (env && env->from && env->from->personal) ? env->from->personal : "");
        buftmp[sizeof(buftmp)-1] = '\0';

        repl = (env && env->from && env->from->personal)
                 ? reply_quote_initials(q = cpystr((char *)rfc1522_decode_to_utf8(
                                                (unsigned char *)tmp_20k_buf, 
                                                SIZEOF_20KBUF, buftmp)))
                 : "";

        istrncpy(pbf, repl, sizeof(pbf)-1);
        pbf[sizeof(pbf)-1] = '\0';;
        rplstr(p, sizeof(buf)-(p-buf), strlen(init_token), pbf);
        if(q)
          fs_give((void **)&q);
    }
    
    prefix = removing_quotes(cpystr(buf));

    return(prefix);
}

int
reply_quote_str_contains_tokens(void)
{
    return(ps_global->VAR_REPLY_STRING && ps_global->VAR_REPLY_STRING[0] &&
           (strstr(ps_global->VAR_REPLY_STRING, from_token) ||
            strstr(ps_global->VAR_REPLY_STRING, nick_token) ||
            strstr(ps_global->VAR_REPLY_STRING, init_token)));
}


/*----------------------------------------------------------------------
  Build the body for the message number/part being replied to

    Args: 

  Result: BODY structure suitable for sending

  ----------------------------------------------------------------------*/
BODY *
reply_body(MAILSTREAM *stream, ENVELOPE *env, struct mail_bodystruct *orig_body,
           long int msgno, char *sect_prefix, void *msgtext, char *prefix,
           int plustext, ACTION_S *role, int toplevel, REDRAFT_POS_S **redraft_pos)
{
#define SECTBUFLEN 256
    char     *p, *sig = NULL, *section, sect_buf[SECTBUFLEN];
    BODY     *body = NULL, *tmp_body = NULL;
    PART     *part;
    gf_io_t   pc;
    int       impl, template_len = 0, leave_cursor_at_top = 0, reply_raw_body = 0;

    if(sect_prefix)                                     /* SECTBUFLEN = sizeof(sect_buf) */
      snprintf(section = sect_buf, sizeof(sect_buf), "%.*s.1", SECTBUFLEN-3, sect_prefix);
    else
      section = "1";

    sect_buf[sizeof(sect_buf)-1] = '\0';

    if(ps_global->full_header == 2
       && F_ON(F_ENABLE_FULL_HDR_AND_TEXT, ps_global))
      reply_raw_body = 1;

    gf_set_so_writec(&pc, (STORE_S *) msgtext);

    if(toplevel){
        char *filtered;

        impl = 0;
        filtered = detoken(role, env, 0,
                           ps_global->reply.signature_bottom,
                           0, redraft_pos, &impl);
        if(filtered){
            if(*filtered){
                so_puts((STORE_S *)msgtext, filtered);
                if(impl == 1)
                  template_len = strlen(filtered);
                else if(impl == 2)
                  leave_cursor_at_top++;
            }
            
            fs_give((void **)&filtered);
        }
        else
          impl = 1;
    }
    else
      impl = 1;

    if(toplevel &&
       (sig = reply_signature(role, env, redraft_pos, &impl)) &&
        !ps_global->reply.signature_bottom){

        /*
         * If CURSORPOS was set explicitly in sig_file, and there was a
         * template file before that, we need to adjust the offset by the
         * length of the template file. However, if the template had
         * a set CURSORPOS in it then impl was 2 before getting to the
         * signature, so offset wouldn't have been reset by the signature
         * CURSORPOS and offset would already be correct. That case will
         * be ok here because template_len will be 0 and adding it does
         * nothing. If template
         * didn't have CURSORPOS in it, then impl was 1 and got set to 2
         * by the CURSORPOS in the sig. In that case we have to adjust the
         * offset. That's what the next line does. It adjusts it if
         * template_len is nonzero and if CURSORPOS was set in sig_file.
         */
        if(impl == 2)
          (*redraft_pos)->offset += template_len;
        
        if(*sig)
          so_puts((STORE_S *)msgtext, sig);
        
        /*
         * Set sig to NULL because we've already used it. If SIG_AT_BOTTOM
         * is set, we won't have used it yet and want it to be non-NULL.
         */
        fs_give((void **)&sig);
    }

    /*
     * Only put cursor in sig if there is a cursorpos there but not
     * one in the template, and sig-at-bottom.
     */
    if(!(sig && impl == 2 && !leave_cursor_at_top))
      leave_cursor_at_top++;

    if(plustext){
        if(!orig_body
           || orig_body->type == TYPETEXT
           || reply_raw_body
           || !ps_global->reply.keep_attach){
            char *charset = NULL;

            /*------ Simple text-only message ----*/
            body                     = mail_newbody();
            body->type               = TYPETEXT;
            body->contents.text.data = msgtext;
            reply_delimiter(env, role, pc);
            if(ps_global->reply.include_header)
              reply_forward_header(stream, msgno, sect_prefix,
                                   env, pc, prefix);

            if(!orig_body || reply_raw_body || reply_body_text(orig_body, &tmp_body)){
                BODY *bodyp = NULL;

                bodyp = reply_raw_body ? NULL : tmp_body;

                /*
                 * We set the charset in the outgoing message to the same
                 * as the one in the message we're replying to unless it
                 * is the unknown charset. We do that in order to attempt
                 * to preserve the same charset in the reply if possible.
                 * It may be safer to just set it to whatever we want instead
                 * but then the receiver may not be able to read it.
                 */
                if(bodyp
                   && (charset = parameter_val(bodyp->parameter, "charset"))
                   && strucmp(charset, UNKNOWN_CHARSET))
                  set_parameter(&body->parameter, "charset", charset);

                if(charset)
                  fs_give((void **) &charset);

                get_body_part_text(stream, bodyp, msgno,
                                   bodyp ? (p = body_partno(stream, msgno, bodyp))
                                         : sect_prefix,
                                   0L, pc, prefix, NULL, GBPT_NONE);
                if(bodyp && p)
                  fs_give((void **) &p);
            }
            else{
                gf_puts(NEWLINE, pc);
                gf_puts("  [NON-Text Body part not included]", pc);
                gf_puts(NEWLINE, pc);
            }
        }
        else if(orig_body->type == TYPEMULTIPART){
            /*------ Message is Multipart ------*/
            if(orig_body->subtype
               && (!strucmp(orig_body->subtype, "signed")
#ifdef SMIME
                   || !strucmp(orig_body->subtype, OUR_PKCS7_ENCLOSURE_SUBTYPE)
#endif /* SMIME */
                  )
               && orig_body->nested.part){
                /* operate only on the signed part */
                body = reply_body(stream, env,
                                  &orig_body->nested.part->body,
                                  msgno, section, msgtext, prefix,
                                  plustext, role, 0, redraft_pos);
            }
            else if(orig_body->subtype
                    && !strucmp(orig_body->subtype, "mixed")
                    && orig_body->nested.part
                    && orig_body->nested.part->body.type == TYPEMULTIPART
                    && orig_body->nested.part->body.subtype
                    && (!strucmp(orig_body->nested.part->body.subtype, "signed")
#ifdef SMIME
                   || !strucmp(orig_body->nested.part->body.subtype, OUR_PKCS7_ENCLOSURE_SUBTYPE)
#endif /* SMIME */
                  )){
                /* we can call reply_body as in the call above with section
                 * equal to "1", but that adds the multipart text to the
                 * list of attachments. We do not want that, so we redo this
                 * manually.
                 */
                body = copy_body(NULL, orig_body);

                /*
                 * whatever subtype it is, demote it
                 * to plain old MIXED.
                 */
                if(body->subtype)
                  fs_give((void **) &body->subtype);

                body->subtype = cpystr("Mixed");

                if(reply_body_text(&orig_body->nested.part->body.nested.part->body,
                                           &tmp_body)){
                    int partnum;

                    reply_delimiter(env, role, pc);
                    if(ps_global->reply.include_header)
                      reply_forward_header(stream, msgno, sect_prefix,
                                           env, pc, prefix);
                                        /* SECTBUFLEN = sizeof(sect_buf) */
                    snprintf(sect_buf, sizeof(sect_buf), "%.*s%s%.*s",
                            SECTBUFLEN/2-2,
                            sect_prefix ? sect_prefix : "",
                            sect_prefix ? "." : "",
                            SECTBUFLEN/2-2,
                            p = partno(orig_body, tmp_body));
                    sect_buf[sizeof(sect_buf)-1] = '\0';
                    fs_give((void **) &p);
                    get_body_part_text(stream, tmp_body, msgno,
                                       sect_buf, 0L, pc, prefix,
                                       NULL, GBPT_NONE);

                    part = body->nested.part->next;
                    body->nested.part->next = NULL;
                    mail_free_body_part(&body->nested.part);
                    body->nested.part = mail_newbody_part();
                    body->nested.part->body.type = TYPETEXT;
                    body->nested.part->body.subtype = cpystr("Plain");
                    body->nested.part->body.contents.text.data = msgtext;
                    body->nested.part->next = part;
                                        /* SECTBUFLEN = sizeof(sect_buf) */
                    for(partnum = 2; part != NULL; part = part->next){
                        snprintf(sect_buf, sizeof(sect_buf), "%.*s%s%d",
                                SECTBUFLEN/2,
                                sect_prefix ? sect_prefix : "",
                                sect_prefix ? "." : "", partnum++);
                        sect_buf[sizeof(sect_buf)-1] = '\0';

                        if(!fetch_contents(stream, msgno,
                                           sect_buf, &part->body)){
                            break;
                        }
                    }
                }
                else {
                    /*--- Fetch the original pieces ---*/
                    if(!fetch_contents(stream, msgno, sect_prefix, body))
                      q_status_message(SM_ORDER | SM_DING, 3, 4,
                                       _("Error including all message parts"));

                    /*--- No text part, create a blank one ---*/
                    part                          = mail_newbody_part();
                    part->next                    = body->nested.part;
                    body->nested.part             = part;
                    part->body.contents.text.data = msgtext;
                }
            }
            else if(orig_body->subtype
                    && !strucmp(orig_body->subtype, "alternative")
                    && orig_body->nested.part
                    && orig_body->nested.part->next
                    && orig_body->nested.part->next->body.type == TYPEMULTIPART
                    && orig_body->nested.part->next->body.subtype
                    && !strucmp(orig_body->nested.part->next->body.subtype, "MIXED"))
                body = reply_body(stream, env,
                                  &orig_body->nested.part->next->body,
                                  msgno, "2", msgtext, prefix,
                                  plustext, role, 0, redraft_pos);
            else if(orig_body->subtype
                    && !strucmp(orig_body->subtype, "alternative")){
                /* Set up the simple text reply */
                body                     = mail_newbody();
                body->type               = TYPETEXT;
                body->contents.text.data = msgtext;

                if(reply_body_text(orig_body, &tmp_body)){
                    reply_delimiter(env, role, pc);
                    if(ps_global->reply.include_header)
                      reply_forward_header(stream, msgno, sect_prefix,
                                           env, pc, prefix);

                    get_body_part_text(stream, tmp_body, msgno,
                                       p = body_partno(stream,msgno,tmp_body),
                                       0L, pc, prefix, NULL, GBPT_NONE);
                    if(p)
                      fs_give((void **) &p);
                }
                else
                  q_status_message(SM_ORDER | SM_DING, 3, 3,
                            "No suitable multipart text found for inclusion!");
            }
            else{
                body = copy_body(NULL, orig_body);

                /*
                 * whatever subtype it is, demote it
                 * to plain old MIXED.
                 */
                if(body->subtype)
                  fs_give((void **) &body->subtype);

                body->subtype = cpystr("Mixed");

                if(body->nested.part &&
                   body->nested.part->body.type == TYPETEXT) {
                    char *new_charset = NULL;

                    /*---- First part of the message is text -----*/
                    body->nested.part->body.contents.text.data = msgtext;
                    if(body->nested.part->body.subtype &&
                       strucmp(body->nested.part->body.subtype, "Plain")){
                        fs_give((void **)&body->nested.part->body.subtype);
                        body->nested.part->body.subtype = cpystr("Plain");
                    }
                    reply_delimiter(env, role, pc);
                    if(ps_global->reply.include_header)
                      reply_forward_header(stream, msgno, sect_prefix,
                                           env, pc, prefix);

                    if(!(get_body_part_text(stream,
                                            &orig_body->nested.part->body,
                                            msgno, section, 0L, pc, prefix,
                                            &new_charset, GBPT_NONE)
                         && fetch_contents(stream, msgno, sect_prefix, body)))
                      q_status_message(SM_ORDER | SM_DING, 3, 4,
                                       _("Error including all message parts"));
                    else if(new_charset)
                      set_parameter(&body->nested.part->body.parameter, "charset", new_charset);
                }
                else if(orig_body->nested.part->body.type == TYPEMULTIPART
                        && orig_body->nested.part->body.subtype
                        && !strucmp(orig_body->nested.part->body.subtype,
                                    "alternative")
                        && reply_body_text(&orig_body->nested.part->body,
                                           &tmp_body)){
                    int partnum;

                    reply_delimiter(env, role, pc);
                    if(ps_global->reply.include_header)
                      reply_forward_header(stream, msgno, sect_prefix,
                                           env, pc, prefix);
                                        /* SECTBUFLEN = sizeof(sect_buf) */
                    snprintf(sect_buf, sizeof(sect_buf), "%.*s%s%.*s",
                            SECTBUFLEN/2-2,
                            sect_prefix ? sect_prefix : "",
                            sect_prefix ? "." : "",
                            SECTBUFLEN/2-2,
                            p = partno(orig_body, tmp_body));
                    sect_buf[sizeof(sect_buf)-1] = '\0';
                    fs_give((void **) &p);
                    get_body_part_text(stream, tmp_body, msgno,
                                       sect_buf, 0L, pc, prefix,
                                       NULL, GBPT_NONE);

                    part = body->nested.part->next;
                    body->nested.part->next = NULL;
                    mail_free_body_part(&body->nested.part);
                    body->nested.part = mail_newbody_part();
                    body->nested.part->body.type = TYPETEXT;
                    body->nested.part->body.subtype = cpystr("Plain");
                    body->nested.part->body.contents.text.data = msgtext;
                    body->nested.part->next = part;
                                        /* SECTBUFLEN = sizeof(sect_buf) */
                    for(partnum = 2; part != NULL; part = part->next){
                        snprintf(sect_buf, sizeof(sect_buf), "%.*s%s%d",
                                SECTBUFLEN/2,
                                sect_prefix ? sect_prefix : "",
                                sect_prefix ? "." : "", partnum++);
                        sect_buf[sizeof(sect_buf)-1] = '\0';

                        if(!fetch_contents(stream, msgno,
                                           sect_buf, &part->body)){
                            break;
                        }
                    }
                }
                else {
                    /*--- Fetch the original pieces ---*/
                    if(!fetch_contents(stream, msgno, sect_prefix, body))
                      q_status_message(SM_ORDER | SM_DING, 3, 4,
                                       _("Error including all message parts"));

                    /*--- No text part, create a blank one ---*/
                    part                          = mail_newbody_part();
                    part->next                    = body->nested.part;
                    body->nested.part             = part;
                    part->body.contents.text.data = msgtext;
                }
            }
        }
        else{
            /*---- Single non-text message of some sort ----*/
            body              = mail_newbody();
            body->type        = TYPEMULTIPART;
            part              = mail_newbody_part();
            body->nested.part = part;
    
            /*--- The first part, a blank text part to be edited ---*/
            part->body.type               = TYPETEXT;
            part->body.contents.text.data = msgtext;

            /*--- The second part, what ever it is ---*/
            part->next    = mail_newbody_part();
            part          = part->next;
            part->body.id = generate_message_id(NULL);
            copy_body(&(part->body), orig_body);

            /*
             * the idea here is to fetch part into storage object
             */
            if((part->body.contents.text.data = (void *) so_get(PART_SO_TYPE,
                                                            NULL,EDIT_ACCESS)) != NULL){
                if((p = pine_mail_fetch_body(stream, msgno, section,
                                            &part->body.size.bytes, NIL)) != NULL){
                    so_nputs((STORE_S *)part->body.contents.text.data,
                             p, part->body.size.bytes);
                }
                else
                  mail_free_body(&body);
            }
            else
              mail_free_body(&body);
        }
    }
    else{
        /*--------- No text included --------*/
        body                     = mail_newbody();
        body->type               = TYPETEXT;
        body->contents.text.data = msgtext;
    }

    if(!leave_cursor_at_top){
        long  cnt = 0L;
        unsigned char c;

        /* rewind and count chars to start of sig file */
        so_seek((STORE_S *)msgtext, 0L, 0);
        while(so_readc(&c, (STORE_S *)msgtext))
          cnt++;

        if(!*redraft_pos){
            *redraft_pos = (REDRAFT_POS_S *)fs_get(sizeof(**redraft_pos));
            memset((void *)*redraft_pos, 0,sizeof(**redraft_pos));
            (*redraft_pos)->hdrname = cpystr(":");
        }

        /*
         * If explicit cursor positioning in sig file,
         * add offset to start of sig file plus offset into sig file.
         * Else, just offset to start of sig file.
         */
        (*redraft_pos)->offset += cnt;
    }

    if(sig){
        if(*sig)
          so_puts((STORE_S *)msgtext, sig);
        
        fs_give((void **)&sig);
    }

    gf_clear_so_writec((STORE_S *) msgtext);

    return(body);
}


/*
 * reply_part - first replyable multipart of a multipart.
 */
int
reply_body_text(struct mail_bodystruct *body, struct mail_bodystruct **new_body)
{
    if(body){
        switch(body->type){
          case TYPETEXT :
            *new_body = body;
            return(1);

          case TYPEMULTIPART :
            if(body->subtype && !strucmp(body->subtype, "alternative")){
                PART *part;
                int got_one = 0;

                if((part = body->nested.part) != NULL 
                   && part->body.type == TYPEMULTIPART)
                      return reply_body_text(&body->nested.part->body, new_body);

                if(ps_global->force_prefer_plain
                   || (!ps_global->force_no_prefer_plain
                       && F_ON(F_PREFER_PLAIN_TEXT, ps_global))){
                    for(part = body->nested.part; part; part = part->next)
                      if((!part->body.type || part->body.type == TYPETEXT)
                         && (!part->body.subtype
                             || !strucmp(part->body.subtype, "plain"))){
                          *new_body = &part->body;
                          return(1);
                      }
                }

                /*
                 * Else choose last alternative among plain or html parts.
                 * Perhaps we should really be using mime_show() to make this
                 * potentially more general than just plain or html.
                 */
                for(part = body->nested.part; part; part = part->next){
                    if((!part->body.type || part->body.type == TYPETEXT)
                        && ((!part->body.subtype || !strucmp(part->body.subtype, "plain"))
                            ||
                            (part->body.subtype && !strucmp(part->body.subtype, "html")))){
                        got_one++;
                        *new_body = &part->body;
                    }
                }

                if(got_one)
                  return(1);
            }
            else if(body->nested.part)
              /* NOTE: we're only interested in "first" part of mixed */
              return(reply_body_text(&body->nested.part->body, new_body));

            break;

          default:
            break;
        }
    }

    return(0);
}


char *
reply_signature(ACTION_S *role, ENVELOPE *env, REDRAFT_POS_S **redraft_pos, int *impl)
{
    char *sig;
    size_t l;

    sig = detoken(role, env,
                  2, ps_global->reply.signature_bottom ? 0 : 1, 1,
                  redraft_pos, impl);

    if(!ps_global->reply.signature_bottom && (!sig || !*sig)){
        if(sig)
          fs_give((void **)&sig);

        l = 2 * strlen(NEWLINE);
        sig = (char *)fs_get((l+1) * sizeof(char));
        strncpy(sig, NEWLINE, l);
        sig[l] = '\0';
        strncat(sig, NEWLINE, l+1-1-strlen(sig));
        sig[l] = '\0';
        return(sig);
    }

    return(sig);
}


/*
 * Buf is at least size maxlen+1
 */
void
get_addr_data(ENVELOPE *env, IndexColType type, char *buf, size_t maxlen)
{
    ADDRESS *addr = NULL;
    ADDRESS *last_to = NULL;
    ADDRESS *first_addr = NULL, *second_addr = NULL;
    ADDRESS *third_addr = NULL, *fourth_addr = NULL;
    int      cntaddr, l;
    size_t   orig_maxlen;
    char    *p;

    buf[0] = '\0';

    switch(type){
      case iFrom:
        addr = env ? env->from : NULL;
        break;

      case iTo:
        addr = env ? env->to : NULL;
        break;

      case iCc:
        addr = env ? env->cc : NULL;
        break;

      case iSender:
        addr = env ? env->sender : NULL;
        break;

      /*
       * Recips is To and Cc together. We hook the two adrlists together
       * temporarily.
       */
      case iRecips:
        addr = env ? env->to : NULL;
        /* Find end of To list */
        for(last_to = addr; last_to && last_to->next; last_to = last_to->next)
          ;
        
        /* Make the end of To list point to cc list */
        if(last_to)
          last_to->next = (env ? env->cc : NULL);
          
        break;

      /*
       * Initials.
       */
      case iInit:
        if(env && env->from && env->from->personal){
            char *name, *initials = NULL;

            name = (char *)rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf,
                                                  SIZEOF_20KBUF, env->from->personal);
            if(name == env->from->personal){
                strncpy(tmp_20k_buf, name, SIZEOF_20KBUF-1);
                tmp_20k_buf[SIZEOF_20KBUF - 1] = '\0';
                name = tmp_20k_buf;
            }

            if(name && *name){
                initials = reply_quote_initials(name);
                iutf8ncpy(buf, initials, maxlen);
                buf[maxlen] = '\0';
            }
        }

        return;

      default:
        break;
    }

    orig_maxlen = maxlen;

    first_addr = addr;
    /* skip over rest of c-client group addr */
    if(first_addr && first_addr->mailbox && !first_addr->host){
        for(second_addr = first_addr->next;
            second_addr && second_addr->host;
            second_addr = second_addr->next)
          ;
        
        if(second_addr && !second_addr->host)
          second_addr = second_addr->next;
    }
    else if(!(first_addr && first_addr->host && first_addr->host[0] == '.'))
      second_addr = first_addr ? first_addr->next : NULL;

    if(second_addr && second_addr->mailbox && !second_addr->host){
        for(third_addr = second_addr->next;
            third_addr && third_addr->host;
            third_addr = third_addr->next)
          ;
        
        if(third_addr && !third_addr->host)
          third_addr = third_addr->next;
    }
    else if(!(second_addr && second_addr->host && second_addr->host[0] == '.'))
      third_addr = second_addr ? second_addr->next : NULL;

    if(third_addr && third_addr->mailbox && !third_addr->host){
        for(fourth_addr = third_addr->next;
            fourth_addr && fourth_addr->host;
            fourth_addr = fourth_addr->next)
          ;
        
        if(fourth_addr && !fourth_addr->host)
          fourth_addr = fourth_addr->next;
    }
    else if(!(third_addr && third_addr->host && third_addr->host[0] == '.'))
      fourth_addr = third_addr ? third_addr->next : NULL;

    /* Just attempting to make a nice display */
    if(first_addr && ((first_addr->personal && first_addr->personal[0]) ||
                      (first_addr->mailbox && first_addr->mailbox[0]))){
      if(second_addr){
        if((second_addr->personal && second_addr->personal[0]) ||
           (second_addr->mailbox && second_addr->mailbox[0])){
          if(third_addr){
            if((third_addr->personal && third_addr->personal[0]) ||
               (third_addr->mailbox && third_addr->mailbox[0])){
              if(fourth_addr)
                cntaddr = 4;
              else
                cntaddr = 3;
            }
            else
              cntaddr = -1;
          }
          else
            cntaddr = 2;
        }
        else
          cntaddr = -1;
      }
      else
        cntaddr = 1;
    }
    else
      cntaddr = -1;

    p = buf;
    if(cntaddr == 1)
      a_little_addr_string(first_addr, p, maxlen);
    else if(cntaddr == 2){
        a_little_addr_string(first_addr, p, maxlen);
        maxlen -= (l=strlen(p));
        p += l;
        if(maxlen > 7){
            strncpy(p, " and ", maxlen);
            maxlen -= 5;
            p += 5;
            a_little_addr_string(second_addr, p, maxlen);
        }
    }
    else if(cntaddr == 3){
        a_little_addr_string(first_addr, p, maxlen);
        maxlen -= (l=strlen(p));
        p += l;
        if(maxlen > 7){
            strncpy(p, ", ", maxlen);
            maxlen -= 2;
            p += 2;
            a_little_addr_string(second_addr, p, maxlen);
            maxlen -= (l=strlen(p));
            p += l;
            if(maxlen > 7){
                strncpy(p, ", and ", maxlen);
                maxlen -= 6;
                p += 6;
                a_little_addr_string(third_addr, p, maxlen);
            }
        }
    }
    else if(cntaddr > 3){
        a_little_addr_string(first_addr, p, maxlen);
        maxlen -= (l=strlen(p));
        p += l;
        if(maxlen > 7){
            strncpy(p, ", ", maxlen);
            maxlen -= 2;
            p += 2;
            a_little_addr_string(second_addr, p, maxlen);
            maxlen -= (l=strlen(p));
            p += l;
            if(maxlen > 7){
                strncpy(p, ", ", maxlen);
                maxlen -= 2;
                p += 2;
                a_little_addr_string(third_addr, p, maxlen);
                maxlen -= (l=strlen(p));
                p += l;
                if(maxlen >= 12)
                  strncpy(p, ", and others", maxlen);
                else if(maxlen >= 3)
                  strncpy(p, "...", maxlen);
            }
        }
    }
    else if(addr){
        char *a_string;

        a_string = addr_list_string(addr, NULL, 0);
        iutf8ncpy(buf, a_string, maxlen);

        fs_give((void **)&a_string);
    }

    if(last_to)
      last_to->next = NULL;

    buf[orig_maxlen] = '\0';
}


/*
 * Buf is at least size maxlen+1
 */
void
get_news_data(ENVELOPE *env, IndexColType type, char *buf, size_t maxlen)
{
    int      cntnews = 0, orig_maxlen;
    char    *news = NULL, *p, *q;

    switch(type){
      case iNews:
      case iNewsAndTo:
      case iToAndNews:
      case iNewsAndRecips:
      case iRecipsAndNews:
        news = env ? env->newsgroups : NULL;
        break;

      case iCurNews:
        if(ps_global->mail_stream && IS_NEWS(ps_global->mail_stream))
          news = ps_global->cur_folder;

        break;

      default:
        break;
    }

    orig_maxlen = maxlen;

    if(news){
        q = news;
        while(isspace((unsigned char)*q))
          q++;

        if(*q)
          cntnews++;
        
        while((q = strindex(q, ',')) != NULL){
            q++;
            while(isspace((unsigned char)*q))
              q++;
            
            if(*q)
              cntnews++;
            else
              break;
        }
    }

    if(cntnews == 1){
        istrncpy(buf, news, maxlen);
        buf[maxlen] = '\0';
        removing_leading_and_trailing_white_space(buf);
    }
    else if(cntnews == 2){
        p = buf;
        q = news;
        while(isspace((unsigned char)*q))
          q++;
        
        while(maxlen > 0 && *q && !isspace((unsigned char)*q) && *q != ','){
            *p++ = *q++;
            maxlen--;
        }
        
        if(maxlen > 7){
            strncpy(p, " and ", maxlen);
            p += 5;
            maxlen -= 5;
        }

        while(isspace((unsigned char)*q) || *q == ',')
          q++;

        while(maxlen > 0 && *q && !isspace((unsigned char)*q) && *q != ','){
            *p++ = *q++;
            maxlen--;
        }

        *p = '\0';

        istrncpy(tmp_20k_buf, buf, 10000);
        strncpy(buf, tmp_20k_buf, orig_maxlen);
    }
    else if(cntnews > 2){
        char b[100];

        p = buf;
        q = news;
        while(isspace((unsigned char)*q))
          q++;
        
        while(maxlen > 0 && *q && !isspace((unsigned char)*q) && *q != ','){
            *p++ = *q++;
            maxlen--;
        }
        
        *p = '\0';
        snprintf(b, sizeof(b), " and %d other newsgroups", cntnews-1);
        b[sizeof(b)-1] = '\0';
        if(maxlen >= strlen(b))
          strncpy(p, b, maxlen);
        else if(maxlen >= 3)
          strncpy(p, "...", maxlen);

        buf[orig_maxlen] = '\0';

        istrncpy(tmp_20k_buf, buf, 10000);
        tmp_20k_buf[10000-1] = '\0';
        strncpy(buf, tmp_20k_buf, orig_maxlen);
    }

    buf[orig_maxlen] = '\0';
}

void
shorten_subject(char *origsubj)
{ 
  char *s, *t, *u;
  int endlist = 0;

  if(origsubj == NULL || *origsubj == '\0')
    return;

  for(t=s=origsubj; *s ; s++){
    switch(*s){
        /* this transforms "A [B [C] D" into "A D" should this be
         * "A [B D"?
         */ 
        case '[' : if((u = strchr(s+1,']')) != NULL){ 
                        s = u; 
                        endlist = 1;
                   }
                   else
                        *t++ = *s;
                   break;
        case ' ' : if(endlist == 0) *t++ = *s; break;
        default  : endlist = 0; *t++ = *s; break;
    }
  }
  *t = '\0';
}

/*
 * Buf is at least size maxlen+1
 */
char *
get_reply_data(ENVELOPE *env, ACTION_S *role, IndexColType type, char *buf, size_t maxlen)
{
    char        *space = NULL;
    IndexColType addrtype;

    buf[0] = '\0';

    switch(type){
      case iRDate: case iSDate: case iSTime: case iSTime24:
      case iS1Date: case iS2Date: case iS3Date: case iS4Date:
      case iSDateIso: case iSDateIsoS:
      case iSDateS1: case iSDateS2: case iSDateS3: case iSDateS4: 
      case iSDateTime:
      case iSDateTimeIso: case iSDateTimeIsoS:
      case iSDateTimeS1: case iSDateTimeS2: case iSDateTimeS3: case iSDateTimeS4: 
      case iSDateTime24:
      case iSDateTimeIso24: case iSDateTimeIsoS24:
      case iSDateTimeS124: case iSDateTimeS224: case iSDateTimeS324: case iSDateTimeS424: 
      case iDateIso: case iDateIsoS: case iTime24: case iTime12:
      case iDay: case iDayOrdinal: case iDay2Digit:
      case iMonAbb: case iMonLong: case iMon: case iMon2Digit:
      case iYear: case iYear2Digit:
      case iDate: case iLDate:
      case iTimezone: case iDayOfWeekAbb: case iDayOfWeek:
      case iPrefDate: case iPrefTime: case iPrefDateTime:
        if(env && env->date && env->date[0] && maxlen >= 20)
          date_str((char *) env->date, type, 1, buf, maxlen+1, 0);

        break;

      case iCurDate:
      case iCurDateIso:
      case iCurDateIsoS:
      case iCurTime24:
      case iCurTime12:
      case iCurDay:
      case iCurDay2Digit:
      case iCurDayOfWeek:
      case iCurDayOfWeekAbb:
      case iCurMon:
      case iCurMon2Digit:
      case iCurMonLong:
      case iCurMonAbb:
      case iCurYear:
      case iCurYear2Digit:
      case iCurPrefDate:
      case iCurPrefDateTime:
      case iCurPrefTime:
      case iLstMon:
      case iLstMon2Digit:
      case iLstMonLong:
      case iLstMonAbb:
      case iLstMonYear:
      case iLstMonYear2Digit:
      case iLstYear:
      case iLstYear2Digit:
        if(maxlen >= 20)
          date_str(NULL, type, 1, buf, maxlen+1, 0);

        break;

      case iFrom:
      case iTo:
      case iCc:
      case iSender:
      case iRecips:
      case iInit:
        get_addr_data(env, type, buf, maxlen);
        break;

      case iRoleNick:
        if(role && role->nick){
            strncpy(buf, role->nick, maxlen);
            buf[maxlen] = '\0';
        }
        break;

      case iNewLine:
        if(maxlen >= strlen(NEWLINE)){
            strncpy(buf, NEWLINE, maxlen);
            buf[maxlen] = '\0';
        }
        break;

      case iAddress:
      case iMailbox:
        if(env && env->from && env->from->mailbox && env->from->mailbox[0] &&
           strlen(env->from->mailbox) <= maxlen){
            strncpy(buf, env->from->mailbox, maxlen);
            buf[maxlen] = '\0';
            if(type == iAddress &&
               env->from->host &&
               env->from->host[0] &&
               env->from->host[0] != '.' &&
               strlen(buf) + strlen(env->from->host) + 1 <= maxlen){
                strncat(buf, "@", maxlen+1-1-strlen(buf));
                buf[maxlen] = '\0';
                strncat(buf, env->from->host, maxlen+1-1-strlen(buf));
                buf[maxlen] = '\0';
            }
        }

        break;

      case iNews:
      case iCurNews:
        get_news_data(env, type, buf, maxlen);
        break;

      case iToAndNews:
      case iNewsAndTo:
      case iRecipsAndNews:
      case iNewsAndRecips:
        if(type == iToAndNews || type == iNewsAndTo)
          addrtype = iTo;
        else
          addrtype = iRecips;

        if(env && env->newsgroups){
            space = (char *)fs_get((maxlen+1) * sizeof(char));
            get_news_data(env, type, space, maxlen);
        }

        get_addr_data(env, addrtype, buf, maxlen);

        if(space && *space && *buf){
            if(strlen(space) + strlen(buf) + 5 > maxlen){
                if(strlen(space) > maxlen/2)
                  get_news_data(env, type, space, maxlen - strlen(buf) - 5);
                else
                  get_addr_data(env, addrtype, buf, maxlen - strlen(space) - 5);
            }

            if(type == iToAndNews || type == iRecipsAndNews)
              snprintf(tmp_20k_buf, SIZEOF_20KBUF, "%s and %s", buf, space);
            else
              snprintf(tmp_20k_buf, SIZEOF_20KBUF, "%s and %s", space, buf);

            tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';

            strncpy(buf, tmp_20k_buf, maxlen);
            buf[maxlen] = '\0';
        }
        else if(space && *space){
            strncpy(buf, space, maxlen);
            buf[maxlen] = '\0';
        }
        
        if(space)
          fs_give((void **)&space);

        break;

      case iSubject:
      case iShortSubject:
        if(env && env->subject){
            size_t n, len;
            unsigned char *p, *tmp = NULL;

            if((n = 4*strlen(env->subject)) > SIZEOF_20KBUF-1){
                len = n+1;
                p = tmp = (unsigned char *)fs_get(len * sizeof(char));
            }
            else{
                len = SIZEOF_20KBUF;
                p = (unsigned char *)tmp_20k_buf;
            }
          
            istrncpy(buf, (char *)rfc1522_decode_to_utf8(p, len, env->subject), maxlen);

            buf[maxlen] = '\0';

            if(tmp)
              fs_give((void **)&tmp);

            if(type == iShortSubject)
              shorten_subject(buf);
        }

        break;
    
      case iMsgID:
        if(env && env->message_id){
            strncpy(buf, env->message_id, maxlen);
            buf[maxlen] = '\0';
        }

        break;
    
      default:
        break;
    }

    buf[maxlen] = '\0';
    return(buf);
}


/*
 * reply_delimiter - output formatted reply delimiter for given envelope
 *                   with supplied character writing function.
 */
void
reply_delimiter(ENVELOPE *env, ACTION_S *role, gf_io_t pc)
{
#define MAX_DELIM 2000
    char           buf[MAX_DELIM+1];
    char          *p;
    char          *filtered = NULL;
    int            contains_newline_token = 0;


    if(!env)
      return;

    strncpy(buf, ps_global->VAR_REPLY_INTRO, MAX_DELIM);
    buf[MAX_DELIM] = '\0';
    /* preserve exact default behavior from before */
    if(!strcmp(buf, DEFAULT_REPLY_INTRO)){
        struct date d;
        int include_date;

        parse_date((char *) env->date, &d);
        include_date = !(d.day == -1 || d.month == -1 || d.year == -1);
        if(include_date){
            gf_puts("On ", pc);                 /* All delims have... */
            if(d.wkday != -1){                  /* "On day, date month year" */
                gf_puts(day_abbrev(d.wkday), pc);       /* in common */
                gf_puts(", ", pc);
            }

            gf_puts(int2string(d.day), pc);
            (*pc)(' ');
            gf_puts(month_abbrev(d.month), pc);
            (*pc)(' ');
            gf_puts(int2string(d.year), pc);
        }

        if(env->from
           && ((env->from->personal && env->from->personal[0])
               || (env->from->mailbox && env->from->mailbox[0]))){
            char buftmp[MAILTMPLEN];

            a_little_addr_string(env->from, buftmp, sizeof(buftmp)-1);
            if(include_date)
              gf_puts(", ", pc);

            gf_puts(buftmp, pc);
            gf_puts(" wrote:", pc);
        }
        else{
            if(include_date)
              gf_puts(", it was written", pc);
            else
              gf_puts("It was written", pc);
        }

    }
    else{
        /*
         * This is here for backwards compatibility. There didn't used
         * to be a _NEWLINE_ token. The user would enter text that should
         * all fit on one line and then that was followed by two newlines.
         * Also, truncation occurs if it is long.
         * Now, if _NEWLINE_ is not in the text, same thing still works
         * the same. However, if _NEWLINE_ is in there, then all bets are
         * off and the user is on his or her own. No automatic newlines
         * are added, only those that come from the tokens. No truncation
         * is done, the user is trusted to get it right. Newlines may be
         * embedded so that the leadin is multi-line.
         */
        contains_newline_token = (strstr(buf, "_NEWLINE_") != NULL);
        filtered = detoken_src(buf, FOR_REPLY_INTRO, env, role,
                               NULL, NULL);

        /* try to truncate if too long */
        if(!contains_newline_token && filtered && utf8_width(filtered) > 80){
            int ended_with_colon = 0;
            int ended_with_quote = 0;
            int ended_with_quote_colon = 0;
            int l;

            l = strlen(filtered);

            if(filtered[l-1] == ':'){
                ended_with_colon = ':';
                if(filtered[l-2] == QUOTE || filtered[l-2] == '\'')
                  ended_with_quote_colon = filtered[l-2];
            }
            else if(filtered[l-1] == QUOTE || filtered[l-1] == '\'')
              ended_with_quote = filtered[l-1];

            /* try to find space to break at */
            for(p = &filtered[75]; p > &filtered[60] && 
                  !isspace((unsigned char)*p); p--)
              ;
            
            if(!isspace((unsigned char)*p))
              p = &filtered[75];

            *p++ = '.';
            *p++ = '.';
            *p++ = '.';
            if(ended_with_quote_colon){
                *p++ = ended_with_quote_colon;
                *p++ = ':';
            }
            else if(ended_with_colon)
              *p++ = ended_with_colon;
            else if(ended_with_quote)
              *p++ = ended_with_quote;

            *p = '\0';
        }

        if(filtered && *filtered)
          gf_puts(filtered, pc);
    }

    /* and end with two newlines unless no leadin at all */
    if(!contains_newline_token){
        if(!strcmp(buf, DEFAULT_REPLY_INTRO) || (filtered && *filtered)){
            gf_puts(NEWLINE, pc);
            gf_puts(NEWLINE, pc);
        }
    }

    if(filtered)
      fs_give((void **)&filtered);
}


void
free_redraft_pos(REDRAFT_POS_S **redraft_pos)
{
    if(redraft_pos && *redraft_pos){
        if((*redraft_pos)->hdrname)
          fs_give((void **)&(*redraft_pos)->hdrname);
        
        fs_give((void **)redraft_pos);
    }
}


/*----------------------------------------------------------------------
  Build the body for the message number/part being forwarded as ATTACHMENT

    Args: 

  Result: PARTS suitably attached to body

  ----------------------------------------------------------------------*/
int
forward_mime_msg(MAILSTREAM *stream, long int msgno, char *section, ENVELOPE *env, struct mail_body_part **partp, void *msgtext)
{
    char           *tmp_text;
    unsigned long   len;
    BODY           *b;

    *partp              = mail_newbody_part();
    b                   = &(*partp)->body;
    b->type             = TYPEMESSAGE;
    b->id               = generate_message_id(NULL);
    b->description      = cpystr("Forwarded Message");
    b->nested.msg       = mail_newmsg();
    b->disposition.type = cpystr("inline");

    /*---- Package each message in a storage object ----*/
    if((b->contents.text.data = (void *) so_get(PART_SO_TYPE,NULL,EDIT_ACCESS))
       && (tmp_text = mail_fetch_header(stream,msgno,section,NIL,NIL,FT_PEEK))
       && *tmp_text){
        so_puts((STORE_S *) b->contents.text.data, tmp_text);

        b->size.bytes = strlen(tmp_text);
        so_puts((STORE_S *) b->contents.text.data, "\015\012");
        if((tmp_text = pine_mail_fetch_text (stream,msgno,section,&len,NIL)) != NULL){
            so_nputs((STORE_S *)b->contents.text.data,tmp_text,(long) len);
            b->size.bytes += len;
            return(1);
        }
    }

    return(0);
}


/*
 * forward_delimiter - return delimiter for forwarded text
 */
void
forward_delimiter(gf_io_t pc)
{
    gf_puts(NEWLINE, pc);
    /* TRANSLATORS: When a message is forwarded by the user this is the
       text that shows where the forwarded part of the message begins. */
    gf_puts(_("---------- Forwarded message ----------"), pc);
    gf_puts(NEWLINE, pc);
}


/*----------------------------------------------------------------------
    Wrapper for header formatting tool

    Args: stream --
          msgno --
          env --
          pc --
          prefix --

  Result: header suitable for reply/forward text written using "pc"

  ----------------------------------------------------------------------*/
void
reply_forward_header(MAILSTREAM *stream, long int msgno, char *part, ENVELOPE *env,
                     gf_io_t pc, char *prefix)
{
    int      rv;
    HEADER_S h;
    char   **list, **new_list = NULL;

    list = ps_global->VAR_VIEW_HEADERS;

    /*
     * If VIEW_HEADERS is set, we should remove BCC from the list so that
     * the user doesn't inadvertently forward the BCC header.
     */
    if(list && list[0]){
        int    i, cnt = 0;
        char **p;

        while(list[cnt++])
          ;

        p = new_list = (char **) fs_get((cnt+1) * sizeof(char *));

        for(i=0; list[i]; i++)
          if(strucmp(list[i], "bcc"))
            *p++ = cpystr(list[i]);
        
        *p = NULL;

        if(new_list && new_list[0])
          list = new_list;

    }

    HD_INIT(&h, list, ps_global->view_all_except, FE_DEFAULT & ~FE_BCC);
    if((rv = format_header(stream, msgno, part, env, &h,
                           prefix, NULL, FM_NOINDENT, NULL, pc)) != 0){
        if(rv == 1)
          gf_puts("  [Error fetching message header data]", pc);
    }
    else
      gf_puts(NEWLINE, pc);             /* write header delimiter */
    
    if(new_list)
      free_list_array(&new_list);
}


/*----------------------------------------------------------------------
  Build the subject for the message number being forwarded

    Args: pine_state -- The usual pine structure
          msgno      -- The message number to build subject for

  Result: malloc'd string containing new subject or NULL on error

  ----------------------------------------------------------------------*/
char *
forward_subject(ENVELOPE *env, int flags)
{
    size_t l;
    char  *p, buftmp[MAILTMPLEN];
    
    if(!env)
      return(NULL);

    dprint((9, "checking subject: \"%s\"\n",
               env->subject ? env->subject : "NULL"));

    if(env->subject && env->subject[0]){                /* add (fwd)? */
        snprintf(buftmp, sizeof(buftmp), "%s", env->subject);
        buftmp[sizeof(buftmp)-1] = '\0';
        /* decode any 8bit (copy to the temp buffer if decoding doesn't) */
        if(rfc1522_decode_to_utf8((unsigned char *) tmp_20k_buf,
                                  SIZEOF_20KBUF, buftmp) == (unsigned char *) buftmp)
          strncpy(tmp_20k_buf, buftmp, SIZEOF_20KBUF);

        tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';

        removing_trailing_white_space(tmp_20k_buf);
        l = strlen(tmp_20k_buf);
        if(l < 5 || strcmp(tmp_20k_buf+l-5,"(fwd)")){
            char *s = cpystr(tmp_20k_buf);
            snprintf(tmp_20k_buf, SIZEOF_20KBUF, "%.1000s (fwd)", s);
            tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';
            fs_give((void **) &s);
        }

        /*
         * HACK:  composer can't handle embedded double quotes in attachment
         * comments so we substitute two single quotes.
         */
        if(flags & FS_CONVERT_QUOTES)
          while((p = strchr(tmp_20k_buf, QUOTE)) != NULL)
            (void)rplstr(p, SIZEOF_20KBUF-(p-tmp_20k_buf), 1, "''");

        return(cpystr(tmp_20k_buf));

    }

    return(cpystr("Forwarded mail...."));
}


/*----------------------------------------------------------------------
  Build the body for the message number/part being forwarded

    Args: 

  Result: BODY structure suitable for sending

  ----------------------------------------------------------------------*/
BODY *
forward_body(MAILSTREAM *stream, ENVELOPE *env, struct mail_bodystruct *orig_body,
             long int msgno, char *sect_prefix, void *msgtext, int flags)
{
    BODY    *body = NULL, *text_body, *tmp_body;
    PART    *part;
    gf_io_t  pc;
    char    *tmp_text, *section, sect_buf[256];
    int      forward_raw_body = 0;

    /*
     * Check to see if messages got expunged out from underneath us. This
     * could have happened during the prompt to the user asking whether to
     * include the message as an attachment. Either the message is gone or
     * it might be at a different sequence number. We'd better bail.
     */
    if(ps_global->full_header == 2
       && F_ON(F_ENABLE_FULL_HDR_AND_TEXT, ps_global))
      forward_raw_body = 1;
    if(sp_expunge_count(stream))
      return(NULL);

    if(sect_prefix && forward_raw_body == 0)
      snprintf(section = sect_buf, sizeof(sect_buf), "%s.1", sect_prefix);
    else if(sect_prefix && forward_raw_body)
      section = sect_prefix;
    else if(!sect_prefix && forward_raw_body)
      section = NULL;
    else
      section = "1";

    sect_buf[sizeof(sect_buf)-1] = '\0';

    gf_set_so_writec(&pc, (STORE_S *) msgtext);
    if(!orig_body || orig_body->type == TYPETEXT || forward_raw_body) {
        char *charset = NULL;

        /*---- Message has a single text part -----*/
        body                     = mail_newbody();
        body->type               = TYPETEXT;
        body->contents.text.data = msgtext;
        if(orig_body
           && (charset = parameter_val(orig_body->parameter, "charset")))
          set_parameter(&body->parameter, "charset", charset);

        if(charset)
          fs_give((void **) &charset);

        if(!(flags & FWD_ANON)){
            forward_delimiter(pc);
            reply_forward_header(stream, msgno, sect_prefix, env, pc, "");
        }

        if(!get_body_part_text(stream, forward_raw_body ? NULL : orig_body,
                               msgno, section, 0L, pc, NULL, NULL, GBPT_NONE)){
            mail_free_body(&body);
            return(NULL);
        }
    }
    else if(orig_body->type == TYPEMULTIPART) {
        if(orig_body->subtype 
                && ((!strucmp(orig_body->subtype, "signed") && orig_body->nested.part)
#ifdef SMIME
                    || (!strucmp(orig_body->subtype, "mixed") 
                          && orig_body->nested.part
                          && orig_body->nested.part->body.type ==  TYPEMULTIPART
                          && orig_body->nested.part->body.subtype
                          && (!strucmp(orig_body->nested.part->body.subtype, OUR_PKCS7_ENCLOSURE_SUBTYPE)
                                || !strucmp(orig_body->nested.part->body.subtype, "signed")))
                    || !strucmp(orig_body->subtype, OUR_PKCS7_ENCLOSURE_SUBTYPE)
#endif /* SMIME */
           )){
            /* only operate on the signed data (not the signature) */
            body = forward_body(stream, env, &orig_body->nested.part->body,
                        msgno, 
                        orig_body->nested.part->body.type ==  TYPEMULTIPART 
                                ? section : sect_prefix, msgtext, flags);
        }
        /*---- Message is multipart ----*/
        else if(!(orig_body->subtype && !strucmp(orig_body->subtype,
                                                 "alternative")
                  && (body = forward_multi_alt(stream, env, orig_body, msgno,
                                               sect_prefix, msgtext,
                                               pc, flags)))){
            /*--- Copy the body and entire structure  ---*/
            body = copy_body(NULL, orig_body);

            /*
             * whatever subtype it is, demote it
             * to plain old MIXED.
             */
            if(body->subtype)
              fs_give((void **) &body->subtype);

            body->subtype = cpystr("Mixed");

            /*--- The text part of the message ---*/
            if(!body->nested.part){
                q_status_message(SM_ORDER | SM_DING, 3, 6,
                                 "Error referencing body part 1");
                mail_free_body(&body);
            }
            else if(body->nested.part->body.type == TYPETEXT) {
                char *new_charset = NULL;

                /*--- The first part is text ----*/
                text_body                     = &body->nested.part->body;
                text_body->contents.text.data = msgtext;
                if(text_body->subtype && strucmp(text_body->subtype, "Plain")){
                    /* this text is going to the composer, it should be Plain */
                    fs_give((void **)&text_body->subtype);
                    text_body->subtype = cpystr("PLAIN");
                }
                if(!(flags & FWD_ANON)){
                    forward_delimiter(pc);
                    reply_forward_header(stream, msgno,
                                         sect_prefix, env, pc, "");
                }

                if(!(get_body_part_text(stream, &orig_body->nested.part->body,
                                        msgno, section, 0L, pc,
                                        NULL, &new_charset, GBPT_NONE)
                     && fetch_contents(stream, msgno, sect_prefix, body)))
                  mail_free_body(&body);
                else if(new_charset)
                  set_parameter(&text_body->parameter, "charset", new_charset);

/* BUG: ? matter that we're not setting body.size.bytes */
            }
            else if(body->nested.part->body.type == TYPEMULTIPART
                    && body->nested.part->body.subtype
                    && !strucmp(body->nested.part->body.subtype, "alternative")
                    && (tmp_body = forward_multi_alt(stream, env,
                                                     &body->nested.part->body,
                                                     msgno, sect_prefix,
                                                     msgtext, pc,
                                                     flags | FWD_NESTED))){
              /* for the forward_multi_alt call above, we want to pass
               * sect_prefix instead of section so we can obtain the header.
               * Set the FWD_NESTED flag so we fetch the right body_part.
               */ 
                int partnum;

                part = body->nested.part->next;
                body->nested.part->next = NULL;
                mail_free_body_part(&body->nested.part);
                body->nested.part = mail_newbody_part();
                body->nested.part->body = *tmp_body;
                body->nested.part->next = part;

                for(partnum = 2; part != NULL; part = part->next){
                    snprintf(sect_buf, sizeof(sect_buf), "%s%s%d",
                            sect_prefix ? sect_prefix : "",
                            sect_prefix ? "." : "", partnum++);
                    sect_buf[sizeof(sect_buf)-1] = '\0';

                    if(!fetch_contents(stream, msgno, sect_buf, &part->body)){
                        mail_free_body(&body);
                        break;
                    }
                }
            }
            else {
                if(fetch_contents(stream, msgno, sect_prefix, body)){
                    /*--- Create a new blank text part ---*/
                    part                          = mail_newbody_part();
                    part->next                    = body->nested.part;
                    body->nested.part             = part;
                    part->body.contents.text.data = msgtext;
                }
                else
                  mail_free_body(&body);
            }
        }
    }
    else {
        /*---- A single part message, not of type text ----*/
        body                     = mail_newbody();
        body->type               = TYPEMULTIPART;
        part                     = mail_newbody_part();
        body->nested.part      = part;

        /*--- The first part, a blank text part to be edited ---*/
        part->body.type            = TYPETEXT;
        part->body.contents.text.data = msgtext;

        /*--- The second part, what ever it is ---*/
        part->next               = mail_newbody_part();
        part                     = part->next;
        part->body.id            = generate_message_id(NULL);
        copy_body(&(part->body), orig_body);

        /*
         * the idea here is to fetch part into storage object
         */
        if((part->body.contents.text.data = (void *) so_get(PART_SO_TYPE, NULL,
                                                           EDIT_ACCESS)) != NULL){
            if((tmp_text = pine_mail_fetch_body(stream, msgno, section,
                                         &part->body.size.bytes, NIL)) != NULL)
              so_nputs((STORE_S *)part->body.contents.text.data, tmp_text,
                       part->body.size.bytes);
            else
              mail_free_body(&body);
        }
        else
          mail_free_body(&body);
    }

    gf_clear_so_writec((STORE_S *) msgtext);

    return(body);
}



/*
 * bounce_msg_body - build body from specified message suitable
 *                   for sending as bounced message
 */
char *
bounce_msg_body(MAILSTREAM *stream,
                long int rawno,
                char *part,
                char **to,
                char *subject,
                ENVELOPE **outgoingp,
                BODY **bodyp,
                int *seenp)
{
    char     *h, *p, *errstr = NULL;
    int       i;
    STORE_S  *msgtext;
    gf_io_t   pc;

    *outgoingp           = mail_newenvelope();
    (*outgoingp)->subject    = cpystr(subject ? subject : "Resent mail....");

    /*
     * Fill in destination if we were given one.  If so, note that we
     * call p_s_s() below such that it won't prompt...
     */
    if(to && *to){
        static char *fakedomain = "@";
        char        *tmp_a_string;

        /* rfc822_parse_adrlist feels free to destroy input so copy */
        tmp_a_string = cpystr(*to);
        rfc822_parse_adrlist(&(*outgoingp)->to, tmp_a_string,
                             (F_ON(F_COMPOSE_REJECTS_UNQUAL, ps_global))
                             ? fakedomain : ps_global->maildomain);
        fs_give((void **) &tmp_a_string);
    }

    /* build remail'd header */
    if((h = mail_fetch_header(stream, rawno, part, NULL, 0, FT_PEEK)) != NULL){
        for(p = h, i = 0; (p = strchr(p, ':')) != NULL; p++)
          i++;

        /* allocate it */
        (*outgoingp)->remail = (char *) fs_get(strlen(h) + (2 * i) + 1);

        /*
         * copy it, "X-"ing out transport headers bothersome to
         * software but potentially useful to the human recipient...
         */
        p = (*outgoingp)->remail;
        bounce_mask_header(&p, h);
        do
          if(*h == '\015' && *(h+1) == '\012'){
              *p++ = *h++;              /* copy CR LF */
              *p++ = *h++;
              bounce_mask_header(&p, h);
          }
        while((*p++ = *h++) != '\0');
    }
    /* BUG: else complain? */

    /* NOT bound for the composer, so no need for PicoText */
    if(!(msgtext = so_get(CharStar, NULL, EDIT_ACCESS))){
        mail_free_envelope(outgoingp);
        return(_("Error allocating message text"));
    }

    /* mark object for special handling */
    so_attr(msgtext, "rawbody", "1");

    /*
     * Build a fake body description.  It's ignored by pine_rfc822_header,
     * but we need to set it to something that makes set_mime_types
     * not sniff it and pine_rfc822_output_body not re-encode it.
     * Setting the encoding to (ENCMAX + 1) will work and shouldn't cause
     * problems unless something tries to access body_encodings[] using
     * it without proper precautions.  We don't want to use ENCOTHER
     * cause that tells set_mime_types to sniff it, and we don't want to
     * use ENC8BIT since that tells pine_rfc822_output_body to qp-encode
     * it.  When there's time, it'd be nice to clean this interaction
     * up...
     */
    *bodyp                       = mail_newbody();
    (*bodyp)->type               = TYPETEXT;
    (*bodyp)->encoding           = ENCMAX + 1;
    (*bodyp)->subtype            = cpystr("Plain");
    (*bodyp)->contents.text.data = (void *) msgtext;
    gf_set_so_writec(&pc, msgtext);

    if(seenp && rawno > 0L && stream && rawno <= stream->nmsgs){
        MESSAGECACHE *mc;

        if((mc = mail_elt(stream,  rawno)) != NULL)
          *seenp = mc->seen;
    }

    /* pass NULL body to force mail_fetchtext */
    if(!get_body_part_text(stream, NULL, rawno, part, 0L, pc, NULL, NULL, GBPT_NONE))
      errstr = _("Error fetching message contents. Can't Bounce message");

    gf_clear_so_writec(msgtext);

    return(errstr);
}



/*----------------------------------------------------------------------
    Mask off any header entries we don't want xport software to see

Args:  d -- destination string pointer pointer
       s -- source string pointer pointer

       Postfix uses Delivered-To to detect loops.
       Received line counting is also used to detect loops in places.

  ----*/
void
bounce_mask_header(char **d, char *s)
{
    if(((*s == 'R' || *s == 'r')
        && (!struncmp(s+1, "esent-", 6) || !struncmp(s+1, "eceived:", 8)
            || !struncmp(s+1, "eturn-Path", 10)))
       || !struncmp(s, "Delivered-To:", 13)){
        *(*d)++ = 'X';                          /* write mask */
        *(*d)++ = '-';
    }
}

        
/*----------------------------------------------------------------------
    Fetch and format text for forwarding

Args:  stream  -- Mail stream to fetch text from
       body    -- Body structure of message being forwarded
       msg_no  -- Message number of text for forward
       part_no -- Part number of text to forward
       partial -- If this is > 0 a partial fetch will be done and it will
                    be done using FT_PEEK so the message will remain unseen.
       pc      -- Function to write to
       prefix  -- Prefix for each line
       ret_charset -- If we translate to another charset return that
                      new charset here

Returns:  true if OK, false if problem occurred while filtering

If the text is richtext, it will be converted to plain text, since there's
no rich text editing capabilities in Pine (yet).

It's up to calling routines to plug in signature appropriately

As with all internal text, NVT end-of-line conventions are observed.
DOESN'T sanity check the prefix given!!!
  ----*/
int
get_body_part_text(MAILSTREAM *stream, struct mail_bodystruct *body,
                   long int msg_no, char *part_no, long partial, gf_io_t pc,
                   char *prefix, char **ret_charset, unsigned flags)
{
    int         we_cancel = 0, dashdata, wrapflags = GFW_FORCOMPOSE, flow_res = 0;
    FILTLIST_S  filters[12];
    long        len;
    char       *err, *charset, *prefix_p = NULL;
    int         filtcnt = 0;
    char       *free_this = NULL;
    DELQ_S      dq;

    memset(filters, 0, sizeof(filters));
    if(ret_charset)
      *ret_charset = NULL;

    if(!pc_is_picotext(pc))
      we_cancel = busy_cue(NULL, NULL, 1);

    /* if null body, we must be talking to a non-IMAP2bis server.
     * No MIME parsing provided, so we just grab the message text...
     */
    if(body == NULL){
        char         *text, *decode_error;
        gf_io_t       gc;
        SourceType    src = CharStar;
        int           rv = 0;

        (void) pine_mail_fetchstructure(stream, msg_no, NULL);

        if((text = pine_mail_fetch_text(stream, msg_no, part_no, NULL, 0)) != NULL){
            gf_set_readc(&gc, text, (unsigned long)strlen(text), src, 0);

            gf_filter_init();           /* no filters needed */
            if(prefix)
              gf_link_filter(gf_prefix, gf_prefix_opt(prefix));
            if((decode_error = gf_pipe(gc, pc)) != NULL){
                snprintf(tmp_20k_buf, SIZEOF_20KBUF, "%s%s    [Formatting error: %s]%s",
                        NEWLINE, NEWLINE,
                        decode_error, NEWLINE);
                tmp_20k_buf[SIZEOF_20KBUF-1] = '\0';
                gf_puts(tmp_20k_buf, pc);
                rv++;
            }
        }
        else{
            gf_puts(NEWLINE, pc);
            gf_puts(_("    [ERROR fetching text of message]"), pc);
            gf_puts(NEWLINE, pc);
            gf_puts(NEWLINE, pc);
            rv++;
        }

        if(we_cancel)
          cancel_busy_cue(-1);

        return(rv == 0);
    }

    charset = parameter_val(body->parameter, "charset");

    if(charset && strucmp(charset, "utf-8") && strucmp(charset, "us-ascii")){
        if(ret_charset)
          *ret_charset = "UTF-8";
    }

    if(charset)
      fs_give((void **) &charset);

    /*
     * just use detach, but add an auxiliary filter to insert prefix,
     * and, perhaps, digest richtext
     */
    if(ps_global->full_header != 2
       && !ps_global->postpone_no_flow
       && (!body->subtype || !strucmp(body->subtype, "plain"))){
        char *parmval;

        flow_res = (F_OFF(F_QUELL_FLOWED_TEXT, ps_global)
                     && F_OFF(F_STRIP_WS_BEFORE_SEND, ps_global)
                     && (!prefix || (strucmp(prefix,"> ") == 0)
                         || strucmp(prefix, ">") == 0));
        if((parmval = parameter_val(body->parameter,
                                       "format")) != NULL){
            if(!strucmp(parmval, "flowed")){
                wrapflags |= GFW_FLOWED;

                fs_give((void **) &parmval);
                if((parmval = parameter_val(body->parameter, "delsp")) != NULL){
                    if(!strucmp(parmval, "yes")){
                        filters[filtcnt++].filter = gf_preflow;
                        wrapflags |= GFW_DELSP;
                    }

                    fs_give((void **) &parmval);
                }

                /*
                 * if there's no prefix we're forwarding text
                 * otherwise it's reply text.  unless the user's
                 * tied our hands, alter the prefix to continue flowed
                 * formatting...
                 */
                if(flow_res && ps_global->reply.use_flowed)
                  wrapflags |= GFW_FLOW_RESULT;

                filters[filtcnt].filter = gf_wrap;
                /* 
                 * The 80 will cause longer lines than what is likely
                 * set by composer_fillcol, so we'll have longer
                 * quoted and forwarded lines than the lines we type.
                 * We're fine with that since the alternative is the
                 * possible wrapping of lines we shouldn't have, which
                 * is mitigated by this higher 80 limit.
                 *
                 * If we were to go back to using composer_fillcol,
                 * the correct value is composer_fillcol + 1, pine
                 * is off-by-one from pico.
                 */
                filters[filtcnt++].data = gf_wrap_filter_opt(
                    MAX(MIN(ps_global->ttyo->screen_cols
                            - (prefix ? strlen(prefix) : 0),
                            80 - (prefix ? strlen(prefix) : 0)),
                        30), /* doesn't have to be 30 */
                    990, /* 998 is the SMTP limit */
                    NULL, 0, wrapflags);
            }
        }

        /*
         * if not flowed, remove trailing whitespace to reduce
         * confusion, since we're sending out as flowed if we
         * can.  At some future point, we might try 
         * plugging in a user-option-controlled heuristic
         * flowing filter 
         *
         * We also want to fold "> " quotes so we get the
         * attributions correct.
         */
        if(flow_res && ps_global->reply.use_flowed && prefix && !strucmp(prefix, "> "))
          *(prefix_p = prefix + 1) = '\0';
        ps_global->reply.use_flowed = 1; /* reset for next call */
        if(!(wrapflags & GFW_FLOWED)
           && flow_res){
            filters[filtcnt].filter = gf_line_test;
            filters[filtcnt++].data = gf_line_test_opt(twsp_strip, NULL);

            filters[filtcnt].filter = gf_line_test;
            filters[filtcnt++].data = gf_line_test_opt(quote_fold, NULL);
        }
    }
    else if(body->subtype){
        int plain_opt = 1;

        if(strucmp(body->subtype,"richtext") == 0){
            filters[filtcnt].filter = gf_rich2plain;
            filters[filtcnt++].data = gf_rich2plain_opt(&plain_opt);
        }
        else if(strucmp(body->subtype,"enriched") == 0){
            filters[filtcnt].filter = gf_enriched2plain;
            filters[filtcnt++].data = gf_enriched2plain_opt(&plain_opt);
        }
        else if(strucmp(body->subtype,"html") == 0){
            if((flags & GBPT_HTML_OK) != GBPT_HTML_OK){
                filters[filtcnt].filter = gf_html2plain;
                filters[filtcnt++].data = gf_html2plain_opt(NULL,
                                                            ps_global->ttyo->screen_cols,
                                                            non_messageview_margin(),
                                                            NULL, NULL, GFHP_STRIPPED);
            }
        }
    }

    if(prefix){
        if(ps_global->reply.strip_signature){
            dashdata = 0;
            filters[filtcnt].filter = gf_line_test;
            filters[filtcnt++].data = gf_line_test_opt(sigdash_strip, &dashdata);
        }

        filters[filtcnt].filter = gf_prefix;
        filters[filtcnt++].data = gf_prefix_opt(prefix);

        if(wrapflags & GFW_FLOWED || flow_res){
            filters[filtcnt].filter = gf_line_test;
            filters[filtcnt++].data = gf_line_test_opt(post_quote_space, NULL);
        }
    }

    if(flags & GBPT_DELQUOTES){
        memset(&dq, 0, sizeof(dq));
        dq.lines = Q_DEL_ALL;
        dq.is_flowed = 0;
        dq.indent_length = 0;
        dq.saved_line = &free_this;
        dq.handlesp   = NULL;
        dq.do_color   = 0;
        dq.delete_all = 1;

        filters[filtcnt].filter = gf_line_test;
        filters[filtcnt++].data = gf_line_test_opt(delete_quotes, &dq);
    }

    err = detach(stream, msg_no, part_no, partial, &len, pc,
                 filters[0].filter ? filters : NULL,
                 ((flags & GBPT_PEEK) ? FT_PEEK : 0)
                 | ((flags & GBPT_NOINTR) ? DT_NOINTR : 0));

    if(free_this)
      fs_give((void **) &free_this);

    if(prefix_p)
      *prefix_p = ' ';

    if (err != (char *) NULL)
       /* TRANSLATORS: The first arg is error text, the %ld is the message number */
       q_status_message2(SM_ORDER, 3, 4, "%s: message number %ld",
                         err, (void *) msg_no);

    if(we_cancel)
      cancel_busy_cue(-1);

    return((int) len);
}


int
quote_fold(long int linenum, char *line, LT_INS_S **ins, void *local)
{
    char *p;

    if(*line == '>'){
        for(p = line; *p; p++){
            if(isspace((unsigned char) *p)){
                if(*(p+1) == '>')
                  ins = gf_line_test_new_ins(ins, p, "", -1);
            }
            else if(*p != '>')
              break;
        }
    }

    return(0);
}


int
twsp_strip(long int linenum, char *line, LT_INS_S **ins, void *local)
{
    char *p, *ws = NULL;

    for(p = line; *p; p++){
      /* don't strip trailing space on signature line */
      if(*line == '-' && *(line+1) == '-' && *(line+2) == ' ' && !*(line+3))
        break;

      if(isspace((unsigned char) *p)){
          if(!ws)
            ws = p;
      }
      else
        ws = NULL;
    }

    if(ws)
      ins = gf_line_test_new_ins(ins, ws, "", -(p - ws));

    return(0);
}

int
post_quote_space(long int linenum, char *line, LT_INS_S **ins, void *local)
{
    char *p;

    for(p = line; *p; p++)
      if(*p != '>'){
          if(p != line && *p != ' ')
            ins = gf_line_test_new_ins(ins, p, " ", 1);

          break;
      }

    return(0);
}


int
sigdash_strip(long int linenum, char *line, LT_INS_S **ins, void *local)
{
    if(*((int *)local)
       || (*line == '-' && *(line+1) == '-'
           && *(line+2) == ' ' && !*(line+3))){
        *((int *) local) = 1;
        return(2);              /* skip this line! */
    }

    return(0);
}


/*----------------------------------------------------------------------
  return the c-client reference name for the given end_body part
  ----*/
char *
body_partno(MAILSTREAM *stream, long int msgno, struct mail_bodystruct *end_body)
{
    BODY *body;

    (void) pine_mail_fetchstructure(stream, msgno, &body);
    return(partno(body, end_body));
}


/*----------------------------------------------------------------------
  return the c-client reference name for the given end_body part
  ----*/
char *
partno(struct mail_bodystruct *body, struct mail_bodystruct *end_body)
{
#define PARTTMPLEN 64
    PART *part;
    int   num = 0;
    char  tmp[PARTTMPLEN], *p = NULL;

    if(body && body->type == TYPEMULTIPART) {
        part = body->nested.part;       /* first body part */

        do {                            /* for each part */
            num++;                      /* PARTTMPLEN = sizeof(tmp) */
            if(&part->body == end_body || (p = partno(&part->body, end_body))){
                snprintf(tmp, sizeof(tmp), "%d%s%.*s", num, (p) ? "." : "",
                        PARTTMPLEN-12, (p) ? p : "");
                tmp[sizeof(tmp)-1] = '\0';
                if(p)
                  fs_give((void **)&p);

                return(cpystr(tmp));
            }
        } while ((part = part->next) != NULL);  /* until done */

        return(NULL);
    }
    else if(body && body->type == TYPEMESSAGE && body->subtype 
            && !strucmp(body->subtype, "rfc822")){
        return(partno(body->nested.msg->body, end_body));
    }

    return((body == end_body) ? cpystr("1") : NULL);
}


/*----------------------------------------------------------------------
   Fill in the contents of each body part

Args: stream      -- Stream the message is on
      msgno       -- Message number the body structure is for
      section     -- body section associated with body pointer
      body        -- Body pointer to fill in

Result: 1 if all went OK, 0 if there was a problem

This function copies the contents from an original message/body to
a new message/body.  It recurses down all multipart levels.

If one or more part (but not all) can't be fetched, a status message
will be queued.
 ----*/
int
fetch_contents(MAILSTREAM *stream, long int msgno, char *section, struct mail_bodystruct *body)
{
    char *tp;
    int   got_one = 0;

    if(!body->id)
      body->id = generate_message_id(NULL);
          
    if(body->type == TYPEMULTIPART){
        char  subsection[256], *subp;
        int   n, last_one = 10;         /* remember worst case */
        PART *part     = body->nested.part;

        if(!(part = body->nested.part))
          return(0);

        subp = subsection;
        if(section && *section){
            for(n = 0;
                n < sizeof(subsection)-20 && (*subp = section[n]); n++, subp++)
              ;

            *subp++ = '.';
        }

        n = 1;
        do {
            snprintf(subp, sizeof(subsection)-(subp-subsection), "%d", n++);
            subsection[sizeof(subsection)-1] = '\0';
            got_one  = fetch_contents(stream, msgno, subsection, &part->body);
            last_one = MIN(last_one, got_one);
        }
        while((part = part->next) != NULL);

        return(last_one);
    }

    if(body->contents.text.data)
      return(1);                        /* already taken care of... */

    if(body->type == TYPEMESSAGE){
        if(body->subtype && strucmp(body->subtype,"external-body")){
            /*
             * the idea here is to fetch everything into storage objects
             */
            body->contents.text.data = (void *) so_get(PART_SO_TYPE, NULL,
                                                    EDIT_ACCESS);
            if(body->contents.text.data
               && (tp = pine_mail_fetch_body(stream, msgno, section,
                                       &body->size.bytes, NIL))){
                so_truncate((STORE_S *)body->contents.text.data, 
                            body->size.bytes + 2048);
                so_nputs((STORE_S *)body->contents.text.data, tp,
                         body->size.bytes);
                got_one = 1;
            }
            else
              q_status_message1(SM_ORDER | SM_DING, 3, 3,
                                _("Error fetching part %s"), section);
        } else {
            got_one = 1;
        }
    } else {
        /*
         * the idea here is to fetch everything into storage objects
         * so, grab one, then fetch the body part
         */
        body->contents.text.data = (void *)so_get(PART_SO_TYPE,NULL,EDIT_ACCESS);
        if(body->contents.text.data
           && (tp=pine_mail_fetch_body(stream, msgno, section,
                                       &body->size.bytes, NIL))){
            so_truncate((STORE_S *)body->contents.text.data, 
                            body->size.bytes + 2048);
            so_nputs((STORE_S *)body->contents.text.data, tp,
                     body->size.bytes);
            got_one = 1;
        }
        else
          q_status_message1(SM_ORDER | SM_DING, 3, 3,
                            _("Error fetching part %s"), section);
    }

    return(got_one);
}


/*----------------------------------------------------------------------
    Copy the body structure

Args: new_body -- Pointer to already allocated body, or NULL, if none
      old_body -- The Body to copy


 This is traverses the body structure recursively copying all elements.
The new_body parameter can be NULL in which case a new body is
allocated. Alternatively it can point to an already allocated body
structure. This is used when copying body parts since a PART includes a 
BODY. The contents fields are *not* filled in.
  ----*/

BODY *
copy_body(struct mail_bodystruct *new_body, struct mail_bodystruct *old_body)
{
    if(old_body == NULL)
      return(NULL);

    if(new_body == NULL)
      new_body = mail_newbody();

    new_body->type = old_body->type;
    new_body->encoding = old_body->encoding;

    if(old_body->subtype)
      new_body->subtype = cpystr(old_body->subtype);

    new_body->parameter = copy_parameters(old_body->parameter);

    if(old_body->id)
      new_body->id = cpystr(old_body->id);

    if(old_body->description)
      new_body->description = cpystr(old_body->description);

    if(old_body->disposition.type)
      new_body->disposition.type = cpystr(old_body->disposition.type);

    new_body->disposition.parameter
                            = copy_parameters(old_body->disposition.parameter);
    
    new_body->size = old_body->size;

    if(new_body->type == TYPEMESSAGE
       && new_body->subtype && !strucmp(new_body->subtype, "rfc822")){
        new_body->nested.msg = mail_newmsg();
        new_body->nested.msg->body
                                 = copy_body(NULL, old_body->nested.msg->body);
    }
    else if(new_body->type == TYPEMULTIPART) {
        PART **new_partp, *old_part;

        new_partp = &new_body->nested.part;
        for(old_part = old_body->nested.part;
            old_part != NULL;
            old_part = old_part->next){
            *new_partp = mail_newbody_part();
            copy_body(&(*new_partp)->body, &old_part->body);
            new_partp = &(*new_partp)->next;
        }
    }

    return(new_body);
}


/*----------------------------------------------------------------------
    Copy the MIME parameter list
 
 Allocates storage for new part, and returns pointer to new parameter
list. If old_p is NULL, NULL is returned.
 ----*/
PARAMETER *
copy_parameters(PARAMETER *old_p)
{
    PARAMETER *new_p, *p1, *p2;

    if(old_p == NULL)
      return((PARAMETER *)NULL);

    new_p = p2 = NULL;
    for(p1 = old_p; p1 != NULL; p1 = p1->next){
        set_parameter(&p2, p1->attribute, p1->value);
        if(new_p == NULL)
          new_p = p2;
    }

    return(new_p);
}
    

/*----------------------------------------------------------------------
    Make a complete copy of an envelope and all it's fields

Args:    e -- the envelope to copy

Result:  returns the new envelope, or NULL, if the given envelope was NULL

  ----*/

ENVELOPE *    
copy_envelope(register ENVELOPE *e)
{
    register ENVELOPE *e2;

    if(!e)
      return(NULL);

    e2              = mail_newenvelope();
    e2->remail      = e->remail      ? cpystr(e->remail)              : NULL;
    e2->return_path = e->return_path ? rfc822_cpy_adr(e->return_path) : NULL;
    e2->date        = e->date        ? (unsigned char *)cpystr((char *) e->date)
                                                                      : NULL;
    e2->from        = e->from        ? rfc822_cpy_adr(e->from)        : NULL;
    e2->sender      = e->sender      ? rfc822_cpy_adr(e->sender)      : NULL;
    e2->reply_to    = e->reply_to    ? rfc822_cpy_adr(e->reply_to)    : NULL;
    e2->subject     = e->subject     ? cpystr(e->subject)             : NULL;
    e2->to          = e->to          ? rfc822_cpy_adr(e->to)          : NULL;
    e2->cc          = e->cc          ? rfc822_cpy_adr(e->cc)          : NULL;
    e2->bcc         = e->bcc         ? rfc822_cpy_adr(e->bcc)         : NULL;
    e2->in_reply_to = e->in_reply_to ? cpystr(e->in_reply_to)         : NULL;
    e2->newsgroups  = e->newsgroups  ? cpystr(e->newsgroups)          : NULL;
    e2->message_id  = e->message_id  ? cpystr(e->message_id)          : NULL;
    e2->references  = e->references  ? cpystr(e->references)          : NULL;
    e2->followup_to = e->followup_to ? cpystr(e->references)          : NULL;
    return(e2);
}


/*----------------------------------------------------------------------
     Generate the "In-reply-to" text from message header

  Args: message -- Envelope of original message

  Result: returns an alloc'd string or NULL if there is a problem
 ----*/
char *
reply_in_reply_to(ENVELOPE *env)
{
    return((env && env->message_id) ? cpystr(env->message_id) : NULL);
}


/*----------------------------------------------------------------------
        Generate a unique message id string.

   Args: ps -- The usual pine structure

  Result: Alloc'd unique string is returned

Uniqueness is guaranteed by using the host name, process id, date to the
second and a single unique character
*----------------------------------------------------------------------*/
char *
generate_message_id(ACTION_S *role)
{
    char  *id, *leftpart, *hostpart, *prehostpart;

    if(role && role->from)
      prehostpart = cpystr(role->from->host ? role->from->host : "huh");
    else if(ps_global->maildomain)  /* as in generate_from() */
      prehostpart = cpystr(ps_global->maildomain);
    else
      prehostpart = cpystr(ps_global->hostname);

    if(F_ON(F_ROT13_MESSAGE_ID, ps_global)){
       hostpart  = rot13(prehostpart);
       leftpart  = rot13(oauth2_generate_state());
    } else {
       hostpart  = prehostpart;
       leftpart  = oauth2_generate_state();
    }

    id = fs_get(strlen(leftpart) + strlen(hostpart) + 4);
    sprintf(id, "<%s@%s>", leftpart, hostpart);

    fs_give((void **) &hostpart);
    fs_give((void **) &leftpart);
    prehostpart = NULL;

    return(id);
}


char *
generate_user_agent(void)
{
    char         buf[128];
    char         rev[128];

    if(F_ON(F_QUELL_USERAGENT, ps_global))
      return(NULL);

    snprintf(buf, sizeof(buf),
             "%sAlpine %s (%s %s)",
             (pith_opt_user_agent_prefix) ? (*pith_opt_user_agent_prefix)() : "",
             ALPINE_VERSION, SYSTYPE,
             get_alpine_revision_string(rev, sizeof(rev)));

    return(cpystr(buf));
}


char *
rot13(char *src)
{
    char byte, cap, *p, *ret = NULL;

    if(src && *src){
        ret = (char *) fs_get((strlen(src)+1) * sizeof(char));
        p = ret;
        while((byte = *src++) != '\0'){
            cap   = byte & 32;
            byte &= ~cap;
            *p++ = ((byte >= 'A') && (byte <= 'Z')
                    ? ((byte - 'A' + 13) % 26 + 'A') : byte) | cap;
        }

        *p = '\0';
    }

    return(ret);
}

char *
rot5n(char *src)
{
    char byte, *p, *ret = NULL;

    if(src && *src){
        ret = (char *) fs_get((strlen(src)+1) * sizeof(char));
        p = ret;
        while((byte = *src++) != '\0')
            *p++ = ((byte >= '0') && (byte <= '9')
                    ? ((byte - '0' + 5) % 10 + '0') : byte);
        *p = '\0';
    }

    return(ret);
}


/*----------------------------------------------------------------------
  Return the first true address pointer (modulo group syntax allowance)

  Args: addr  -- Address list

 Result: First real address pointer, or NULL
  ----------------------------------------------------------------------*/
ADDRESS *
first_addr(struct mail_address *addr)
{
    while(addr && !addr->host)
      addr = addr->next;

    return(addr);
}


/*----------------------------------------------------------------------
           lit -- this is the source
   prenewlines -- prefix the file contents with this many newlines
  postnewlines -- postfix the file contents with this many newlines
        is_sig -- this is a signature (not a template)
  decode_constants -- change C-style constants into their values
  ----*/
char *
get_signature_lit(char *lit, int prenewlines, int postnewlines, int is_sig, int decode_constants)
{
    char *sig = NULL;

    /*
     * Should make this smart enough not to do the copying and double
     * allocation of space.
     */
    if(lit){
        char  *tmplit = NULL, *p, *q, *d, save;
        size_t len;

        if(decode_constants){
            tmplit = (char *) fs_get((strlen(lit)+1) * sizeof(char));
            tmplit[0] = '\0';
            cstring_to_string(lit, tmplit);
        }
        else
          tmplit = cpystr(lit);

        len = strlen(tmplit) + 5 + (prenewlines+postnewlines) * strlen(NEWLINE);
        sig = (char *) fs_get((len+1) * sizeof(char));
        memset(sig, 0, len+1);
        d = sig;
        while(prenewlines--)
          sstrncpy(&d, NEWLINE, len-(d-sig));

        if(is_sig && F_ON(F_ENABLE_SIGDASHES, ps_global) &&
           !sigdashes_are_present(tmplit)){
            sstrncpy(&d, SIGDASHES, len-(d-sig));
            sstrncpy(&d, NEWLINE, len-(d-sig));
        }

        sig[len] = '\0';

        p = tmplit;
        while(*p){
            /* get a line */
            q = strpbrk(p, "\n\r");
            if(q){
                save = *q;
                *q = '\0';
            }

            /*
             * Strip trailing space if we are doing a signature and
             * this line is not sigdashes.
             */
            if(is_sig && strcmp(p, SIGDASHES))
              removing_trailing_white_space(p);

            while((d-sig) <= len && (*d = *p++) != '\0')
              d++;

            if(q){
                if((d-sig) <= len)
                  *d++ = save;
                  
                p = q+1;
            }
            else
              break;
        }

        while(postnewlines--)
          sstrncpy(&d, NEWLINE, len-(d-sig));

        sig[len] = '\0';

        if((d-sig) <= len)
          *d = '\0';

        if(tmplit)
          fs_give((void **) &tmplit);
    }

    return(sig);
}


int
sigdashes_are_present(char *sig)
{
    char *p;

    p = srchstr(sig, SIGDASHES);
    while(p && !((p == sig || (p[-1] == '\n' || p[-1] == '\r')) &&
                 (p[3] == '\0' || p[3] == '\n' || p[3] == '\r')))
      p = srchstr(p+1, SIGDASHES);
    
    return(p ? 1 : 0);
}


/*----------------------------------------------------------------------
  Acquire the pinerc defined signature file pathname

  ----*/
char *
signature_path(char *sname, char *sbuf, size_t len)
{
    *sbuf = '\0';
    if(sname && *sname){
        size_t spl = strlen(sname);
        if(IS_REMOTE(sname)){
            if(spl < len - 1)
              strncpy(sbuf, sname, len-1);
        }
        else if(is_absolute_path(sname)){
            strncpy(sbuf, sname, len-1);
            sbuf[len-1] = '\0';
            fnexpand(sbuf, len);
        }
        else if(ps_global->VAR_OPER_DIR){
            if(strlen(ps_global->VAR_OPER_DIR) + spl < len - 1)
              build_path(sbuf, ps_global->VAR_OPER_DIR, sname, len);
        }
        else{
            char *lc = last_cmpnt(ps_global->pinerc);

            sbuf[0] = '\0';
            if(lc != NULL){
                strncpy(sbuf,ps_global->pinerc,MIN(len-1,lc-ps_global->pinerc));
                sbuf[MIN(len-1,lc-ps_global->pinerc)] = '\0';
            }

            strncat(sbuf, sname, MAX(len-1-strlen(sbuf), 0));
            sbuf[len-1] = '\0';
        }
    }

    return(*sbuf ? sbuf : NULL);
}


char *
simple_read_remote_file(char *name, char *subtype)
{
    int        try_cache;
    REMDATA_S *rd;
    char      *file = NULL;


    dprint((7, "simple_read_remote_file(%s, %s)\n", name ? name : "?", subtype ? subtype : "?"));

    /*
     * We could parse the name here to find what type it is. So far we
     * only have type RemImap.
     */
    rd = rd_create_remote(RemImap, name, subtype,
                          NULL, _("Error: "), _("Can't fetch remote configuration."));
    if(!rd)
      goto bail_out;
    
    try_cache = rd_read_metadata(rd);

    if(rd->access == MaybeRorW){
        if(rd->read_status == 'R')
          rd->access = ReadOnly;
        else
          rd->access = ReadWrite;
    }

    if(rd->access != NoExists){

        rd_check_remvalid(rd, 1L);

        /*
         * If the cached info says it is readonly but
         * it looks like it's been fixed now, change it to readwrite.
         */
        if(rd->read_status == 'R'){
            /*
             * We go to this trouble since readonly sigfiles
             * are likely a mistake. They are usually supposed to be
             * readwrite so we open it and check if it's been fixed.
             */
            rd_check_readonly_access(rd);
            if(rd->read_status == 'W'){
                rd->access = ReadWrite;
                rd->flags |= REM_OUTOFDATE;
            }
            else
              rd->access = ReadOnly;
        }

        if(rd->flags & REM_OUTOFDATE){
            if(rd_update_local(rd) != 0){

                dprint((1,
                       "simple_read_remote_file: rd_update_local failed\n"));
                /*
                 * Don't give up altogether. We still may be
                 * able to use a cached copy.
                 */
            }
            else{
                dprint((7,
                       "%s: copied remote to local (%ld)\n",
                       rd->rn ? rd->rn : "?", (long)rd->last_use));
            }
        }

        if(rd->access == ReadWrite)
          rd->flags |= DO_REMTRIM;
    }

    /* If we couldn't get to remote folder, try using the cached copy */
    if(rd->access == NoExists || rd->flags & REM_OUTOFDATE){
        if(try_cache){
            rd->access = ReadOnly;
            rd->flags |= USE_OLD_CACHE;
            q_status_message(SM_ORDER, 3, 4,
             "Can't contact remote server, using cached copy");
            dprint((2,
    "Can't open remote file %s, using local cached copy %s readonly\n",
                   rd->rn ? rd->rn : "?",
                   rd->lf ? rd->lf : "?"));
        }
        else{
            rd->flags &= ~DO_REMTRIM;
            goto bail_out;
        }
    }

    file = read_file(rd->lf, READ_FROM_LOCALE);

bail_out:
    if(rd)
      rd_close_remdata(&rd);

    return(file);
}

/* special handling for messages that contain a mixed part in the 
 * multipart alternative section.
 */
BODY *
forward_multi_alt_mixed(MAILSTREAM *stream, ENVELOPE *env, struct mail_bodystruct *orig_body,
                long int msgno, char *sect_prefix, void *msgtext, gf_io_t pc, int flags)
{
#define FWDTMPLEN 256
    BODY *body = NULL, *text_body = NULL;
    PART *part = NULL;
    char  prefix_buf[FWDTMPLEN];
    int   partnum;
    char  *section, sect_buf[256];
    int   forward_raw_body = 0;

    if(orig_body
        && orig_body->type == TYPEMULTIPART
        && orig_body->subtype 
        && !strucmp(orig_body->subtype, "alternative"))
        for(part = orig_body->nested.part, partnum = 1;
            part;
            part = part->next, partnum++)
            if(part->body.type == TYPEMULTIPART
               && part->body.subtype 
               && !strucmp(part->body.subtype, "MIXED"))
               break;

    if(part == NULL) return NULL;

    snprintf(prefix_buf, sizeof(prefix_buf), "%.*s%s%s%d",
                FWDTMPLEN/2, sect_prefix ? sect_prefix : "",
                sect_prefix ? "." : "", flags & FWD_NESTED ? "1." : "",
                partnum);
    prefix_buf[sizeof(prefix_buf)-1] = '\0';

    if(ps_global->full_header == 2
       && F_ON(F_ENABLE_FULL_HDR_AND_TEXT, ps_global))
      forward_raw_body = 1;
    if(sp_expunge_count(stream))
      return(NULL);

    if(sect_prefix && forward_raw_body == 0)
      snprintf(section = sect_buf, sizeof(sect_buf), "%s.1", sect_prefix);
    else if(sect_prefix && forward_raw_body)
      section = sect_prefix;
    else if(!sect_prefix && forward_raw_body)
      section = NULL;
    else
      section = "1";
    sect_buf[sizeof(sect_buf)-1] = '\0';

    body = copy_body(NULL, &part->body);

    /*--- The text part of the message ---*/
    if(!body->nested.part){
        q_status_message(SM_ORDER | SM_DING, 3, 6,
                         "Error referencing body part 1");
        mail_free_body(&body);
    }
    else if(body->nested.part->body.type == TYPETEXT) {
        char *new_charset = NULL;

        /*--- The first part is text ----*/
        text_body                     = &body->nested.part->body;
        text_body->contents.text.data = msgtext;
        if(text_body->subtype && strucmp(text_body->subtype, "Plain")){
            /* this text is going to the composer, it should be Plain */
            fs_give((void **)&text_body->subtype);
            text_body->subtype = cpystr("PLAIN");
        }
        if(!(flags & FWD_ANON)){
            forward_delimiter(pc);
            reply_forward_header(stream, msgno,
                                 sect_prefix, env, pc, "");
        }

        if(!(get_body_part_text(stream, &part->body,
                                msgno, section, 0L, pc,
                                NULL, &new_charset, GBPT_NONE)
             && fetch_contents(stream, msgno, prefix_buf, body)))
          mail_free_body(&body);
        else if(new_charset)
          set_parameter(&text_body->parameter, "charset", new_charset);
    }
    return(body);
}


/*----------------------------------------------------------------------
  Build the body for the multipart/alternative part

    Args: 

  Result: 

  ----------------------------------------------------------------------*/
BODY *
forward_multi_alt(MAILSTREAM *stream, ENVELOPE *env, struct mail_bodystruct *orig_body,
                  long int msgno, char *sect_prefix, void *msgtext, gf_io_t pc, int flags)
{
#define FWDTMPLEN 256
    BODY *body = NULL;
    PART *part = NULL, *bestpart = NULL;
    char  tmp_buf[FWDTMPLEN];
    char *new_charset = NULL;
    int   partnum, bestpartnum;

    /* try multipart mixed first */
    if((body = forward_multi_alt_mixed(stream, env, orig_body, 
                msgno, sect_prefix, msgtext, pc, flags)) != NULL)
      return body;

    if(ps_global->force_prefer_plain
       || (!ps_global->force_no_prefer_plain
           && F_ON(F_PREFER_PLAIN_TEXT, ps_global))){
        for(part = orig_body->nested.part, partnum = 1;
            part;
            part = part->next, partnum++)
          if((!part->body.type || part->body.type == TYPETEXT)
             && (!part->body.subtype
                 || !strucmp(part->body.subtype, "plain")))
              break;
    }

    /*
     * Else choose last alternative among plain or html parts.
     * Perhaps we should really be using mime_show() to make this
     * potentially more general than just plain or html.
     */
    if(!part){
        for(part = orig_body->nested.part, partnum = 1;
            part;
            part = part->next, partnum++){
            if((!part->body.type || part->body.type == TYPETEXT)
                && ((!part->body.subtype || !strucmp(part->body.subtype, "plain"))
                    ||
                    (part->body.subtype && !strucmp(part->body.subtype, "html")))){
                bestpart = part;
                bestpartnum = partnum;
            }
        }

        part = bestpart;
        partnum = bestpartnum;
    }

    /*
     * IF something's interesting insert it
     * AND forget the rest of the multipart
     */
    if(part){
        body                     =  mail_newbody();
        body->type               = TYPETEXT;
        body->contents.text.data = msgtext;

        /* record character set, flowing, etc */
        body->parameter = copy_parameters(part->body.parameter);
        body->size.bytes = part->body.size.bytes;

        if(!(flags & FWD_ANON)){
            forward_delimiter(pc);
            reply_forward_header(stream, msgno, sect_prefix, env, pc, "");
        }
                                /* FWDTMPLEN = sizeof(tmp_buf) */
        snprintf(tmp_buf, sizeof(tmp_buf), "%.*s%s%s%d",
                FWDTMPLEN/2, sect_prefix ? sect_prefix : "",
                sect_prefix ? "." : "", flags & FWD_NESTED ? "1." : "",
                partnum);
        tmp_buf[sizeof(tmp_buf)-1] = '\0';
        get_body_part_text(stream, &part->body, msgno, tmp_buf, 0L, pc,
                           NULL, &new_charset, GBPT_NONE);

        /*
         * get_body_part_text translated the data to a new charset.
         * We need to record that fact in body.
         */
        if(new_charset)
          set_parameter(&body->parameter, "charset", new_charset);
    }
    else
      q_status_message(SM_ORDER | SM_DING, 3, 3,
                       "No suitable part found.  Forwarding as attachment");

    return(body);
}


void
reply_append_addr(struct mail_address **dest, struct mail_address *src)
{
    for( ; *dest; dest = &(*dest)->next)
      ;

    *dest = src;
}