~ubuntu-branches/debian/stretch/alpine/stretch

#if !defined(lint) && !defined(DOS)

static char rcsid[] = "$Id: send.c 1204 2009-02-02 19:54:23Z hubert@u.washington.edu $";

#endif

/*

 * ========================================================================

 * Copyright 2006-2008 University of Washington

 * Copyright 2013 Eduardo Chappa

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * ========================================================================

 */

#include "../pith/headers.h"

#include "../pith/send.h"

#include "../pith/state.h"

#include "../pith/conf.h"

#include "../pith/store.h"

#include "../pith/mimedesc.h"

#include "../pith/context.h"

#include "../pith/status.h"

#include "../pith/folder.h"

#include "../pith/bldaddr.h"

#include "../pith/pipe.h"

#include "../pith/mailview.h"

#include "../pith/mailindx.h"

#include "../pith/list.h"

#include "../pith/filter.h"

#include "../pith/reply.h"

#include "../pith/addrstring.h"

#include "../pith/rfc2231.h"

#include "../pith/stream.h"

#include "../pith/util.h"

#include "../pith/adrbklib.h"

#include "../pith/options.h"

#include "../pith/busy.h"

#include "../pith/text.h"

#include "../pith/imap.h"

#include "../pith/ablookup.h"

#include "../pith/sort.h"

#include "../pith/smime.h"

#include "../c-client/smtp.h"

#include "../c-client/nntp.h"

/* this is used in pine_send and pine_simple_send */

/* name::type::canedit::writehdr::localcopy::rcptto */

PINEFIELD pf_template[] = {

  {"X-Auth-Received",    FreeText,	0, 1, 1, 0},	/* N_AUTHRCVD */

  {"From",        Address,	0, 1, 1, 0},

  {"Reply-To",    Address,	0, 1, 1, 0},

  {TONAME,        Address,	1, 1, 1, 1},

  {CCNAME,        Address,	1, 1, 1, 1},

  {"bcc",         Address,	1, 0, 1, 1},

  {"Newsgroups",  FreeText,	1, 1, 1, 0},

  {"Fcc",         Fcc,		1, 0, 0, 0},

  {"Lcc",         Address,	1, 0, 1, 1},

  {"Attchmnt",    Attachment,	1, 1, 1, 0},

  {SUBJNAME,      Subject,	1, 1, 1, 0},

  {"References",  FreeText,	0, 1, 1, 0},

  {"Date",        FreeText,	0, 1, 1, 0},

  {"In-Reply-To", FreeText,	0, 1, 1, 0},

  {"Message-ID",  FreeText,	0, 1, 1, 0},

  {PRIORITYNAME,  FreeText,	0, 1, 1, 0},

  {"User-Agent",  FreeText,	0, 1, 1, 0},

  {"To",          Address,	0, 0, 0, 0},	/* N_NOBODY */

  {"X-Post-Error",FreeText,	0, 0, 0, 0},	/* N_POSTERR */

  {"X-Reply-UID", FreeText,	0, 0, 0, 0},	/* N_RPLUID */

  {"X-Reply-Mbox",FreeText,	0, 0, 0, 0},	/* N_RPLMBOX */

  {"X-SMTP-Server",FreeText,	0, 0, 0, 0},	/* N_SMTP */

  {"X-NNTP-Server",FreeText,	0, 0, 0, 0},	/* N_NNTP */

  {"X-Cursor-Pos",FreeText,	0, 0, 0, 0},	/* N_CURPOS */

  {"X-Our-ReplyTo",FreeText,	0, 0, 0, 0},	/* N_OURREPLYTO */

  {OUR_HDRS_LIST, FreeText,	0, 0, 0, 0},	/* N_OURHDRS */

#if	!(defined(DOS) || defined(OS2)) || defined(NOAUTH)

  {"X-X-Sender",    Address,	0, 1, 1, 0},

#endif

  {NULL,         FreeText}

};

PRIORITY_S priorities[] = {

    {1, "Highest"},

    {2, "High"},

    {3, "Normal"},

    {4, "Low"},

    {5, "Lowest"},

    {0, NULL}

};

#define ctrl(c) ((c) & 0x1f)

/* which message part to test for xliteration */

typedef enum {MsgBody, HdrText} MsgPart;

/*

 * Internal prototypes

 */

long       post_rfc822_output(char *, ENVELOPE *, BODY *, soutr_t, TCPSTREAM *, long);

int        l_flush_net(int);

int        l_putc(int);

int	   pine_write_header_line(char *, char *, STORE_S *);

int	   pine_write_params(PARAMETER *, STORE_S *);

char      *tidy_smtp_mess(char *, char *, char *, size_t);

int	   lmc_body_header_line(char *, int);

int	   lmc_body_header_finish(void);

int	   pwbh_finish(int, STORE_S *);

int	   sent_percent(void);

unsigned short *setup_avoid_table(void);

#ifndef	_WINDOWS

int	   mta_handoff(METAENV *, BODY *, char *, size_t, void (*)(char *, int),

		       void (*)(PIPE_S *, int, void *));

char	  *post_handoff(METAENV *, BODY *, char *, size_t, void (*)(char *, int),

			void (*)(PIPE_S *, int, void *));

char	  *mta_parse_post(METAENV *, BODY *, char *, char *, size_t, void (*)(char *, int),

			  void (*)(PIPE_S *, int, void *));

long	   pine_pipe_soutr_nl(void *, char *);

#endif

char	  *smtp_command(char *, size_t);

void	  *piped_smtp_open(char *, char *, unsigned long);

void	  *piped_aopen(NETMBX *, char *, char *);

long	   piped_soutr(void *, char *);

long	   piped_sout(void *, char *, unsigned long);

char	  *piped_getline(void *);

void	   piped_close(void *);

void	   piped_abort(void *);

char	  *piped_host(void *);

unsigned long piped_port(void *);

char	  *posting_characterset(void *, char *, MsgPart);

int        body_is_translatable(void *, char *);

int        text_is_translatable(void *, char *);

int        dummy_putc(int);

unsigned long *init_charsetchecker(char *);

int        representable_in_charset(unsigned long, char *);

char      *most_preferred_charset(unsigned long);

/* 

 * Storage object where the FCC (or postponed msg) is to be written.

 * This is amazingly bogus.  Much work was done to put messages 

 * together and encode them as they went to the tmp file for sendmail

 * or into the SMTP slot (especially for for DOS, to prevent a temporary

 * file (and needlessly copying the message).

 * 

 * HOWEVER, since there's no piping into c-client routines

 * (particularly mail_append() which copies the fcc), the fcc will have

 * to be copied to disk.  This global tells pine's copy of the rfc822

 * output functions where to also write the message bytes for the fcc.

 * With piping in the c-client we could just have two pipes to shove

 * down rather than messing with damn copies.  FIX THIS!

 *

 * The function open_fcc, locates the actual folder and creates it if

 * requested before any mailing or posting is done.

 */

struct local_message_copy lmc;

/*

 * Locally global pointer to stream used for sending/posting.

 * It's also used to indicate when/if we write the Bcc: field in

 * the header.

 */

static SENDSTREAM *sending_stream = NULL;

static struct hooks {

    void	*rfc822_out;			/* Message outputter */

} sending_hooks;

static FILE	  *verbose_send_output = NULL;

static long	   send_bytes_sent, send_bytes_to_send;

static METAENV	  *send_header = NULL;

/*

 * Hooks for prompts and confirmations

 */

int (*pith_opt_daemon_confirm)(void);

static NETDRIVER piped_io = {

    piped_smtp_open,		/* open a connection */

    piped_aopen,		/* open an authenticated connection */

    piped_getline,		/* get a line */

    NULL,			/* get a buffer */

    piped_soutr,		/* output pushed data */

    piped_sout,			/* output string */

    piped_close,		/* close connection */

    piped_host,			/* return host name */

    piped_host,			/* remotehost */

    piped_port,			/* return port number */

    piped_host			/* return local host (NOTE: same as host!) */

};

/*

 * Since c-client preallocates, it's necessary here to define a limit

 * such that we don't blow up in c-client (see rfc822_address_line()).

 */

#define	MAX_SINGLE_ADDR	MAILTMPLEN

#define AVOID_2022_JP_FOR_PUNC "AVOID_2022_JP_FOR_PUNC"

/*

 * Phone home hash controls

 */

#define PH_HASHBITS	24

#define PH_MAXHASH	(1<<(PH_HASHBITS))

/*

 * postponed_stream - return stream associated with postponed messages

 *                    in argument.

 */

int

postponed_stream(MAILSTREAM **streamp, char *mbox, char *type, int checknmsgs)

{

    MAILSTREAM *stream = NULL;

    CONTEXT_S  *p_cntxt = NULL;

    char       *p, *q, tmp[MAILTMPLEN], *fullname = NULL;

    int	        exists;

    if(!(streamp && mbox))

      return(0);

    *streamp = NULL;

    /*

     * find default context to look for folder...

     *

     * The "mbox" is assumed to be local if we're given what looks

     * like an absolute path.  This is different from Goto/Save

     * where we do alot of work to interpret paths relative to the

     * server.  This reason is to support all the pre-4.00 pinerc'

     * that specified a path and because there's yet to be a way

     * in c-client to specify otherwise in the face of a remote

     * context.

     */

    if(!is_absolute_path(mbox)

       && !(p_cntxt = default_save_context(ps_global->context_list)))

      p_cntxt = ps_global->context_list;

    /* check to see if the folder exists, the user wants to continue

     * and that we can actually read something in...

     */

    exists = folder_name_exists(p_cntxt, mbox, &fullname);

    if(fullname)

      mbox = fullname;

    if(exists & FEX_ISFILE){

	context_apply(tmp, p_cntxt, mbox, sizeof(tmp));

	if(!(IS_REMOTE(tmp) || is_absolute_path(tmp))){

	    /*

	     * The mbox is relative to the home directory.

	     * Make it absolute so we can compare it to

	     * stream->mailbox.

	     */

	    build_path(tmp_20k_buf, ps_global->ui.homedir, tmp,

		       SIZEOF_20KBUF);

	    strncpy(tmp, tmp_20k_buf, sizeof(tmp));

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

	}

	if((stream = ps_global->mail_stream)

	   && !(stream->mailbox

		&& ((*tmp != '{' && !strcmp(tmp, stream->mailbox))

		    || (*tmp == '{'

			&& same_stream(tmp, stream)

			&& (p = strchr(tmp, '}'))

			&& (q = strchr(stream->mailbox,'}'))

			&& !strcmp(p + 1, q + 1)))))

	  stream = NULL;

	if(!stream){

	    stream = context_open(p_cntxt, NULL, mbox,

				  SP_USEPOOL|SP_TEMPUSE, NULL);

	    if(stream && !stream->halfopen){

		if(stream->nmsgs > 0)

		  refresh_sort(stream, sp_msgmap(stream), SRT_NON);

		if(checknmsgs && stream->nmsgs < 1){

		    pine_mail_close(stream);

		    exists = 0;

		    stream = NULL;

		}

	    }

	    else{

		q_status_message2(SM_ORDER | SM_DING, 3, 3,

				  _("Can't open %s mailbox: %s"), type, mbox);

		if(stream)

		  pine_mail_close(stream);

		exists = 0;

		stream = NULL;

	    }

	}

    }

    else{

	if(F_ON(F_ALT_COMPOSE_MENU, ps_global)){

	    q_status_message1(SM_ORDER | SM_DING, 3, 3,

			     _("%s message folder doesn't exist!"), type);

	}

    }

    if(fullname)

      fs_give((void **) &fullname);

    *streamp = stream;

    return(exists);

}

int

redraft_work(MAILSTREAM **streamp, long int cont_msg, ENVELOPE **outgoing,

	     struct mail_bodystruct **body, char **fcc, char **lcc,

	     REPLY_S **reply, REDRAFT_POS_S **redraft_pos, PINEFIELD **custom,

	     ACTION_S **role, int flags, STORE_S *so)

{

    MAILSTREAM	*stream;

    ENVELOPE	*e = NULL;

    BODY	*b;

    PART        *part;

    PINEFIELD   *pf;

    gf_io_t	 pc;

    char	*extras, **fields, **values, *p;

    char        *hdrs[2], *h, *charset;

    char       **smtp_servers = NULL, **nntp_servers = NULL;

    int		 i, pine_generated = 0, our_replyto = 0;

    int          added_to_role = 0;

    unsigned	 gbpt_flags = GBPT_NONE;

    MESSAGECACHE *mc;

    if(!(streamp && *streamp))

      return(redraft_cleanup(streamp, TRUE, flags));

    stream = *streamp;

    if(flags & REDRAFT_HTML)

      gbpt_flags |= GBPT_HTML_OK;

    /* grok any user-defined or non-c-client headers */

    if((e = pine_mail_fetchstructure(stream, cont_msg, &b)) != NULL){

	/*

	 * The custom headers to look for in the suspended message should

	 * have been stored in the X-Our-Headers header. So first we get

	 * that list. If we can't find it (version that stored the

	 * message < 4.30) then we use the global custom list.

	 */

	hdrs[0] = OUR_HDRS_LIST;

	hdrs[1] = NULL;

	if((h = pine_fetchheader_lines(stream, cont_msg, NULL, hdrs)) != NULL){

	    int    commas = 0;

	    char **list;

	    char  *hdrval = NULL;

	    if((hdrval = strindex(h, ':')) != NULL){

		for(hdrval++; *hdrval && isspace((unsigned char)*hdrval); 

		    hdrval++)

		  ;

	    }

	    /* count elements in list */

	    for(p = hdrval; p && *p; p++)

	      if(*p == ',')

		commas++;

	    if(hdrval && (list = parse_list(hdrval,commas+1,0,NULL)) != NULL){

		*custom = parse_custom_hdrs(list, Replace);

		add_defaults_from_list(*custom,

				       ps_global->VAR_CUSTOM_HDRS);

		free_list_array(&list);

	    }

	    if(*custom && !(*custom)->name){

		free_customs(*custom);

		*custom = NULL;

	    }

	    fs_give((void **)&h);

	}

	if(!*custom)

	  *custom = parse_custom_hdrs(ps_global->VAR_CUSTOM_HDRS, UseAsDef);

#define INDEX_FCC         0

#define INDEX_POSTERR     1

#define INDEX_REPLYUID    2

#define INDEX_REPLYMBOX   3

#define INDEX_SMTP        4

#define INDEX_NNTP        5

#define INDEX_CURSORPOS   6

#define INDEX_OUR_REPLYTO 7

#define INDEX_LCC         8	/* MUST REMAIN LAST FIELD DECLARED */

#define FIELD_COUNT       9

	i = count_custom_hdrs_pf(*custom,1) + FIELD_COUNT + 1;

	/*

	 * Having these two fields separated isn't the slickest, but

	 * converting the pointer array for fetchheader_lines() to

	 * a list of structures or some such for simple_header_parse()

	 * is too goonie.  We could do something like re-use c-client's

	 * PARAMETER struct which is a simple char * pairing, but that

	 * doesn't make sense to pass to fetchheader_lines()...

	 */

	fields = (char **) fs_get((size_t) i * sizeof(char *));

	values = (char **) fs_get((size_t) i * sizeof(char *));

	memset(fields, 0, (size_t) i * sizeof(char *));

	memset(values, 0, (size_t) i * sizeof(char *));

	fields[i = INDEX_FCC] = "Fcc";	/* Fcc: special case */

	fields[++i]   = "X-Post-Error";	/* posting errors too */

	fields[++i]   = "X-Reply-UID";	/* Reply'd to msg's UID */

	fields[++i]   = "X-Reply-Mbox";	/* Reply'd to msg's Mailbox */

	fields[++i]   = "X-SMTP-Server";/* SMTP server to use */

	fields[++i]   = "X-NNTP-Server";/* NNTP server to use */

	fields[++i]   = "X-Cursor-Pos";	/* Cursor position */

	fields[++i]   = "X-Our-ReplyTo";	/* ReplyTo is real */

	fields[++i]   = "Lcc";		/* Lcc: too... */

	if(++i != FIELD_COUNT)

	  panic("Fix FIELD_COUNT");

	for(pf = *custom; pf && pf->name; pf = pf->next)

	  if(!pf->standard)

	    fields[i++] = pf->name;		/* assign custom fields */

	if((extras = pine_fetchheader_lines(stream, cont_msg, NULL,fields)) != NULL){

	    simple_header_parse(extras, fields, values);

	    fs_give((void **) &extras);

	    /*

	     * translate RFC 1522 strings,

	     * starting with "Lcc" field

	     */

	    for(i = INDEX_LCC; fields[i]; i++)

	      if(values[i]){

		  size_t len;

		  char *bufp, *biggerbuf = NULL;

		  if((len=4*strlen(values[i])) > SIZEOF_20KBUF-1){

		      len++;

		      biggerbuf = (char *)fs_get(len * sizeof(char));

		      bufp = biggerbuf;

		  }

		  else{

		      bufp = tmp_20k_buf;

		      len = SIZEOF_20KBUF;

		  }

		  p = (char *)rfc1522_decode_to_utf8((unsigned char*)bufp, len, values[i]);

		  if(p == tmp_20k_buf){

		      fs_give((void **)&values[i]);

		      values[i] = cpystr(p);

		  }

		  if(biggerbuf)

		    fs_give((void **)&biggerbuf);

	      }

	    for(pf = *custom, i = FIELD_COUNT;

		pf && pf->name;

		pf = pf->next){

		if(pf->standard){

		    /*

		     * Because the value is already in the envelope.

		     */

		    pf->cstmtype = NoMatch;

		    continue;

		}

		if(values[i]){	/* use this instead of default */

		    if(pf->textbuf)

		      fs_give((void **)&pf->textbuf);

		    pf->textbuf = values[i]; /* freed in pine_send! */

		}

		else if(pf->textbuf)  /* was erased before postpone */

		  fs_give((void **)&pf->textbuf);

		i++;

	    }

	    if(values[INDEX_FCC])		/* If "Fcc:" was there...  */

	      pine_generated = 1;		/* we put it there? */

	    /*

	     * Since c-client fills in the reply_to field in the envelope

	     * even if there isn't a Reply-To header in the message we

	     * have to work around that. When we postpone we add

	     * a second header that has value "Empty" if there really

	     * was a Reply-To and it was empty. It has the

	     * value "Full" if we put the Reply-To contents there

	     * intentionally (and it isn't empty).

	     */

	    if(values[INDEX_OUR_REPLYTO]){

		if(values[INDEX_OUR_REPLYTO][0] == 'E')

		  our_replyto = 'E';  /* we put an empty one there */

		else if(values[INDEX_OUR_REPLYTO][0] == 'F')

		  our_replyto = 'F';  /* we put it there */

		fs_give((void **) &values[INDEX_OUR_REPLYTO]);

	    }

	    if(fcc)				/* fcc: special case... */

	      *fcc = values[INDEX_FCC] ? values[INDEX_FCC] : cpystr("");

	    else if(values[INDEX_FCC])

	      fs_give((void **) &values[INDEX_FCC]);

	    if(values[INDEX_POSTERR]){		/* x-post-error?!?1 */

		q_status_message(SM_ORDER|SM_DING, 4, 4,

				 values[INDEX_POSTERR]);

		fs_give((void **) &values[INDEX_POSTERR]);

	    }

	    if(values[INDEX_REPLYUID]){

		if(reply)

		  *reply = build_reply_uid(values[INDEX_REPLYUID]);

		fs_give((void **) &values[INDEX_REPLYUID]);

		if(values[INDEX_REPLYMBOX] && reply && *reply)

		  (*reply)->origmbox = cpystr(values[INDEX_REPLYMBOX]);

		if(reply && *reply && !(*reply)->origmbox && (*reply)->mailbox)

		  (*reply)->origmbox = cpystr((*reply)->mailbox);

	    }

	    if(values[INDEX_REPLYMBOX])

	      fs_give((void **) &values[INDEX_REPLYMBOX]);

	    if(values[INDEX_SMTP]){

		char  *q;

		size_t cnt = 0;

		/*

		 * Turn the space delimited list of smtp servers into

		 * a char ** list.

		 */

		p = values[INDEX_SMTP];

		do{

		    if(!*p || isspace((unsigned char) *p))

		      cnt++;

		} while(*p++);

		smtp_servers = (char **) fs_get((cnt+1) * sizeof(char *));

		memset(smtp_servers, 0, (cnt+1) * sizeof(char *));

		cnt = 0;

		q = p = values[INDEX_SMTP];

		do{

		    if(!*p || isspace((unsigned char) *p)){

			if(*p){

			    *p = '\0';

			    smtp_servers[cnt++] = cpystr(q);

			    *p = ' ';

			    q = p+1;

			}

			else

			  smtp_servers[cnt++] = cpystr(q);

		    }

		} while(*p++);

		fs_give((void **) &values[INDEX_SMTP]);

	    }

	    if(values[INDEX_NNTP]){

		char  *q;

		size_t cnt = 0;

		/*

		 * Turn the space delimited list of smtp nntp into

		 * a char ** list.

		 */

		p = values[INDEX_NNTP];

		do{

		    if(!*p || isspace((unsigned char) *p))

		      cnt++;

		} while(*p++);

		nntp_servers = (char **) fs_get((cnt+1) * sizeof(char *));

		memset(nntp_servers, 0, (cnt+1) * sizeof(char *));

		cnt = 0;

		q = p = values[INDEX_NNTP];

		do{

		    if(!*p || isspace((unsigned char) *p)){

			if(*p){

			    *p = '\0';

			    nntp_servers[cnt++] = cpystr(q);

			    *p = ' ';

			    q = p+1;

			}

			else

			  nntp_servers[cnt++] = cpystr(q);

		    }

		} while(*p++);

		fs_give((void **) &values[INDEX_NNTP]);

	    }

	    if(values[INDEX_CURSORPOS]){

		/*

		 * The redraft cursor position is written as two fields

		 * separated by a space. First comes the name of the

		 * header field we're in, or just a ":" if we're in the

		 * body. Then comes the offset into that header or into

		 * the body.

		 */

		if(redraft_pos){

		    char *q1, *q2;

		    *redraft_pos

			      = (REDRAFT_POS_S *)fs_get(sizeof(REDRAFT_POS_S));

		    (*redraft_pos)->offset = 0L;

		    q1 = skip_white_space(values[INDEX_CURSORPOS]);

		    if(*q1 && (q2 = strindex(q1, SPACE))){

			*q2 = '\0';

			(*redraft_pos)->hdrname = cpystr(q1);

			q1 = skip_white_space(q2+1);

			if(*q1)

			  (*redraft_pos)->offset = atol(q1);

		    }

		    else

		      (*redraft_pos)->hdrname = cpystr(":");

		}

		fs_give((void **) &values[INDEX_CURSORPOS]);

	    }

	    if(lcc)

	      *lcc = values[INDEX_LCC];

	    else

	      fs_give((void **) &values[INDEX_LCC]);

	}

	fs_give((void **)&fields);

	fs_give((void **)&values);

	*outgoing = copy_envelope(e);

	/*

	 * If the postponed message has a From which is different from

	 * the default, it is either because allow-changing-from is on

	 * or because there was a role with a from that allowed it to happen.

	 * If allow-changing-from is not on, put this back in a role

	 * so that it will be allowed again in pine_send.

	 */

	if(role && *role == NULL &&

	   !ps_global->never_allow_changing_from &&

	   *outgoing){

	    /*

	     * Now check to see if the from is different from default from.

	     */

	    ADDRESS *deffrom;

	    deffrom = generate_from();

	    if(!((*outgoing)->from &&

		 address_is_same(deffrom, (*outgoing)->from) &&

	         ((!(deffrom->personal && deffrom->personal[0]) &&

		   !((*outgoing)->from->personal &&

		     (*outgoing)->from->personal[0])) ||

		  (deffrom->personal && (*outgoing)->from->personal &&

		   !strcmp(deffrom->personal, (*outgoing)->from->personal))))){

		*role = (ACTION_S *)fs_get(sizeof(**role));

		memset((void *)*role, 0, sizeof(**role));

		if(!(*outgoing)->from)

		  (*outgoing)->from = mail_newaddr();

		(*role)->from = (*outgoing)->from;

		(*outgoing)->from = NULL;

		added_to_role++;

	    }

	    mail_free_address(&deffrom);

	}

	/*

	 * Look at each empty address and see if the user has specified

	 * a default for that field or not.  If they have, that means

	 * they have erased it before postponing, so they won't want

	 * the default to come back.  If they haven't specified a default,

	 * then the default should be generated in pine_send.  We prevent

	 * the default from being assigned by assigning an empty address

	 * to the variable here.

	 *

	 * BUG: We should do this for custom Address headers, too, but

	 * there isn't such a thing yet.

	 */

	if(!(*outgoing)->to && hdr_is_in_list("to", *custom))

	  (*outgoing)->to = mail_newaddr();

	if(!(*outgoing)->cc && hdr_is_in_list("cc", *custom))

	  (*outgoing)->cc = mail_newaddr();

	if(!(*outgoing)->bcc && hdr_is_in_list("bcc", *custom))

	  (*outgoing)->bcc = mail_newaddr();

	if(our_replyto == 'E'){

	    /* user erased reply-to before postponing */

	    if((*outgoing)->reply_to)

	      mail_free_address(&(*outgoing)->reply_to);