/*

 * $LynxId: LYMail.c,v 1.99 2018/03/18 19:16:29 tom Exp $

 */

#include <HTUtils.h>

#include <HTParse.h>

#include <LYGlobalDefs.h>

#include <HTAlert.h>

#include <LYCurses.h>

#include <LYSignal.h>

#include <LYUtils.h>

#include <LYClean.h>

#include <LYStrings.h>

#include <GridText.h>

#include <LYMail.h>

#include <LYEdit.h>

#include <LYCharSets.h>		/* to get current charset for mail header */

#include <LYLeaks.h>

#define MAX_SUBJECT 70

BOOLEAN term_letter;		/* Global variable for async i/o. */

static void terminate_letter(int sig GCC_UNUSED)

{

    term_letter = TRUE;

    /* Reassert the AST */

    signal(SIGINT, terminate_letter);

#if USE_VMS_MAILER || defined(PDCURSES)

    /*

     * Refresh the screen to get rid of the "interrupt" message.

     */

    if (!dump_output_immediately) {

	lynx_force_repaint();

	LYrefresh();

    }

#endif /* VMS */

}

/* HTUnEscape with control-code nuking */

static void SafeHTUnEscape(char *string)

{

    int i;

    int flg = FALSE;

    HTUnEscape(string);

    for (i = 0; string[i] != '\0'; i++) {

	/* FIXME: this is no longer explicitly 7-bit ASCII,

	   but are there portability problems? */

	if ((!LYIsASCII(string[i])) || !isprint(UCH(string[i]))) {

	    string[i] = '?';

	    flg = TRUE;

	}

    }

    if (flg)

	HTAlert(MAILTO_SQUASH_CTL);

}

static void remove_tildes(char *string)

{

    /*

     * Change the first character to a space if it is a '~'.

     */

    if (*string == '~')

	*string = ' ';

}

static void comma_append(char **dst,

			 char *src)

{

    if (*src) {

	while (*src == ',' || isspace(UCH(*src)))

	    src++;

	if (*src) {

	    if (isEmpty(*dst)) {

		StrAllocCopy(*dst, src);

	    } else {

		StrAllocCat(*dst, ",");

		StrAllocCat(*dst, src);

	    }

	}

    }

}

static void extract_field(char **dst,

			  char *src,

			  const char *keyword)

{

    int len = (int) strlen(keyword);

    char *cp, *cp1;

    cp = (src + 1);

    while (*cp != '\0') {

	if ((*(cp - 1) == '?' || *(cp - 1) == '&') &&

	    !strncasecomp(cp, keyword, len)) {

	    cp += len;

	    if ((cp1 = StrChr(cp, '&')) != NULL) {

		*cp1 = '\0';

	    }

	    comma_append(dst, cp);

	    if (cp1) {

		*cp1 = '&';

		cp = cp1;

		cp1 = NULL;

	    } else {

		break;

	    }

	}

	cp++;

    }

    CTRACE((tfp, "extract_field(%s) = '%s'\n", keyword, *dst));

}

/*

 * Seek and handle a subject=foo.  - FM

 */

static void extract_subject(char *dst,

			    char *src)

{

    const char *keyword = "subject=";

    int len = (int) strlen(keyword);

    char *cp, *cp1;

    cp = (src + 1);

    while (*cp != '\0') {

	if ((*(cp - 1) == '?' || *(cp - 1) == '&') &&

	    !strncasecomp(cp, keyword, len))

	    break;

	cp++;

    }

    if (*cp) {

	cp += len;

	if ((cp1 = StrChr(cp, '&')) != NULL) {

	    *cp1 = '\0';

	}

	if (*cp) {

	    LYStrNCpy(dst, cp, MAX_SUBJECT);

	    SafeHTUnEscape(dst);

	}

	if (cp1) {

	    *cp1 = '&';

	    cp1 = NULL;

	}

    }

    CTRACE((tfp, "extract_subject(%s) = '%s'\n", keyword, NONNULL(dst)));

}

/*

 * Seek and handle body=foo fields.  - FM

 */

static void extract_body(char **dst,

			 char *src)

{

    const char *keyword = "body=";

    int len = (int) strlen(keyword);

    int i;

    char *cp, *cp0, *cp1, *temp = 0;

    cp = (src + 1);

    while (*cp != '\0') {

	if ((*(cp - 1) == '?' || *(cp - 1) == '&') &&

	    !strncasecomp(cp, keyword, len)) {

	    cp += len;

	    if ((cp1 = StrChr(cp, '&')) != NULL) {

		*cp1 = '\0';

	    }

	    if (*cp) {

		/*

		 * Break up the value into lines with a maximum length of 78. 

		 * - FM

		 */

		StrAllocCopy(temp, cp);

		HTUnEscape(temp);

		cp0 = temp;

		while ((cp = StrChr(cp0, '\n')) != NULL) {

		    *cp = '\0';

		    if (cp > cp0) {

			if (*(cp - 1) == '\r') {

			    *(cp - 1) = '\0';

			}

		    }

		    i = 0;

		    len = (int) strlen(cp0);

		    while (len > 78) {

			HTSprintf(dst, "%.78s\n", &cp0[i]);

			i += 78;

			len = (int) strlen(&cp0[i]);

		    }

		    HTSprintf(dst, "%s\n", &cp0[i]);

		    cp0 = (cp + 1);

		}

		i = 0;

		len = (int) strlen(cp0);

		while (len > 78) {

		    HTSprintf(dst, "%.78s\n", &cp0[i]);

		    i += 78;

		    len = (int) strlen(&cp0[i]);

		}

		if (len) {

		    HTSprintf(dst, "%s\n", &cp0[i]);

		}

		FREE(temp);

	    }

	    if (cp1) {

		*cp1 = '&';

		cp = cp1;

		cp1 = NULL;

	    } else {

		break;

	    }

	}

	cp++;

    }

    CTRACE((tfp, "extract_body(%s) = '%s'\n", keyword, NONNULL(*dst)));

}

/*

 * Convert any Explorer semi-colon Internet address separators to commas - FM

 */

static BOOLEAN trim_comma(char *address)

{

    if (address[(strlen(address) - 1)] == ',')

	address[(strlen(address) - 1)] = '\0';

    return (BOOL) (*address == '\0');

}

/*

 * Convert any Explorer semi-colon Internet address separators to commas - FM

 */

static BOOLEAN convert_explorer(char *address)

{

    char *cp = address;

    char *cp0;

    char *cp1;

    while ((cp1 = StrChr(cp, '@')) != NULL) {

	cp1++;

	if ((cp0 = StrChr(cp1, ';')) != NULL) {

	    *cp0 = ',';

	    cp1 = cp0 + 1;

	}

	cp = cp1;

    }

    return trim_comma(address);

}

/*

 * reply_by_mail() prompts line-by-line for header information, allowing

 * scrolling of the screen.

 */

static int header_prompt(const char *label,

			 char **result,

			 unsigned limit)

{

    char buffer[LINESIZE];

    int ok;

    if (*result != 0) {

	LYaddstr(CTRL_U_TO_ERASE);

	LYStrNCpy(buffer, *result, sizeof(buffer) - 1);

    } else

	*buffer = 0;

    if (limit > sizeof(buffer))

	limit = sizeof(buffer);

    LYaddstr(gettext(label));

    LYaddstr(": ");

    ok = (LYGetStr(buffer, FALSE, limit, NORECALL) >= 0

	  && !term_letter);

    LYaddstr("\n");

    if (ok) {

	remove_tildes(buffer);

	StrAllocCopy(*result, buffer);

    }

    term_letter = FALSE;

    return ok;

}

static void show_addresses(char *addresses)

{

    char *cp = addresses;

    char *cp1;

    while ((cp1 = StrChr(cp, ',')) != NULL) {

	*cp1 = '\0';

	while (*cp == ' ')

	    cp++;

	if (*cp) {

	    LYaddstr(cp);

	    LYaddstr(",\n  ");

	}

	*cp1 = ',';

	cp = (cp1 + 1);

    }

    if (*cp) {

	LYaddstr(cp);

    }

}

#if USE_BLAT_MAILER

/*

 * blat's options-file parser (see makeargv.cpp) treats backslash and double

 * quote characters specially.  lynx doesn't.  Do a conversion as we write the

 * option.

 *

 * Other quirks (reading blat 3.06):

 * + Whitespace not in quotes terminates a line.

 * + Blat allows a comment-character to terminate a line.  By default, that

 *   is a semicolon.

 *

 * Given that, the simplest thing to do is to always quote the string, using

 * escaping to handle special cases.

 */

static void blat_option(FILE *fp, const char *option, const char *value)

{

    if (non_empty(value)) {

	char *result = malloc(strlen(option) + 4 + 4 * strlen(value));

	char *working = result;

	CTRACE((tfp, "blat_option(opt=\"%s\", value=\"%s\")\n", option, value));

	sprintf(working, "%s \"", option);

	working += strlen(working);

	while (*value != '\0') {

	    unsigned ch = UCH(*value);

	    switch (ch) {

	    case '\\':

		*working++ = '\\';

		*working++ = '\\';

		break;

	    case '"':

		*working++ = '\\';

		*working++ = '"';

		break;

	    default:

		if (ch < ' ' || ch > '~') {

		    sprintf(working, "\\%03o", ch);

		} else {

		    *working++ = ch;

		}

		break;

	    }

	    ++value;

	}

	*working++ = '"';

	*working++ = '\n';

	*working = 0;

	CTRACE((tfp, "->%s", result));

	fputs(result, fp);

	FREE(result);

    }

}

/*

syntax for blat 2.6.2:

Blat <filename> -t <recipient> [optional switches (see below)]

-bodyF <filename> : file with the message body

-t <recipient>    : recipient list (comma separated)

-s <subj>         : subject line

-f <sender>       : overrides the default sender address (must be known to server)

-i <addr>         : a 'From:' address, not necessarily known to the SMTP server.

-c <recipient>    : carbon copy recipient list (comma separated)

-b <recipient>    : blind carbon copy recipient list (comma separated)

-help             : displays the help message.

-mime             : MIME Quoted-Printable Content-Transfer-Encoding.

-q                : supresses *all* output.

-server <addr>    : overrides the default SMTP server to be used.

*/

static char *blat_cmd(char *filename,

		      char *address,

		      char *subject,

		      char *ccaddr,

		      char *mail_addr)

{

    char *b_cmd = NULL;

    if (mail_is_altblat) {

	const char *format = "%s %s -t %s -s %s %s%s%s";

	HTAddParam(&b_cmd, format, 1, ALTBLAT_MAIL);

	HTAddParam(&b_cmd, format, 2, filename);

	HTAddParam(&b_cmd, format, 3, address);

	HTAddParam(&b_cmd, format, 4, subject);

	HTAddToCmd(&b_cmd, format, 5, ALTBLAT_MAIL_FLAGS);

	if (non_empty(ccaddr)) {

	    HTAddToCmd(&b_cmd, format, 6, " -c ");

	    HTAddParam(&b_cmd, format, 7, NonNull(ccaddr));

	}

	HTEndParam(&b_cmd, format, 8);

    } else {

	const char *format = "%s -of %s";

	char bl_cmd_file[LY_MAXPATH];

	FILE *fp;

#ifdef __CYGWIN__

	char dosname[LY_MAXPATH];

#else

	char *dosname;

#endif

	bl_cmd_file[0] = '\0';

	if ((fp = LYOpenTemp(bl_cmd_file, ".blt", "w")) == NULL) {

	    HTAlert(FORM_MAILTO_FAILED);

	    return NULL;

	}

	HTAddParam(&b_cmd, format, 1, BLAT_MAIL);

	ConvertToWin32Path(filename, dosname);

	blat_option(fp, "-bodyF", dosname);

	blat_option(fp, "-t", address);

	blat_option(fp, "-s", subject);

	blat_option(fp, "-f", mail_addr);

	blat_option(fp, "-c", ccaddr);

	LYCloseOutput(fp);

	ConvertToWin32Path(bl_cmd_file, dosname);

	HTAddParam(&b_cmd, format, 2, dosname);

	HTEndParam(&b_cmd, format, 3);

    }

    return b_cmd;

}

#endif /* USE_BLAT_MAILER */

#if USE_VMS_MAILER

BOOLEAN LYMailPMDF(void)

{

    return (system_mail != 0)

	? !strncasecomp(system_mail, "PMDF SEND", 9)

	: FALSE;

}

/*

 * Add all of the people in the address field to the command

 */

static void vms_append_addrs(char **cmd, char *address, char *option)

{

    BOOLEAN first = TRUE;

    char *cp;

    char *address_ptr1;

    char *address_ptr2;

    address_ptr1 = address;

    do {

	if ((cp = StrChr(address_ptr1, ',')) != NULL) {

	    address_ptr2 = (cp + 1);

	    *cp = '\0';

	} else {

	    address_ptr2 = NULL;

	}

	/*

	 * 4 letters is arbitrarily the smallest possible mail address, at

	 * least for lynx.  That way extra spaces won't confuse the mailer and

	 * give a blank address.

	 */

	if (strlen(address_ptr1) > 3) {

	    if (!first) {

		StrAllocCat(*cmd, ",");

	    }

	    HTSprintf(cmd, mail_adrs, address_ptr1);

	    if (*option && LYMailPMDF())

		StrAllocCat(*cmd, option);

	    first = FALSE;

	}

	address_ptr1 = address_ptr2;

    } while (address_ptr1 != NULL);

}

static void remove_quotes(char *string)

{

    while (*string != 0) {

	if (StrChr("\"&|", *string) != 0)

	    *string = ' ';

	string++;

    }

}

#else

#if CAN_PIPE_TO_MAILER

/*

 * Open a pipe to the mailer

 */

FILE *LYPipeToMailer(void)

{

    char *buffer = NULL;

    FILE *fp = NULL;

    if (LYSystemMail()) {

	HTSprintf0(&buffer, "%s %s", system_mail, system_mail_flags);

	fp = popen(buffer, "w");

	CTRACE((tfp, "popen(%s) %s\n", buffer, fp != 0 ? "OK" : "FAIL"));

	FREE(buffer);

    }

    return fp;

}

#else /* DOS, Win32, etc. */

int LYSendMailFile(char *the_address,

		   char *the_filename,

		   char *the_subject GCC_UNUSED,

		   char *the_ccaddr GCC_UNUSED,

		   char *message)

{

    char *cmd = NULL;

    int code;

    if (!LYSystemMail())

	return 0;

#if USE_BLAT_MAILER

    if (mail_is_blat) {

	cmd = blat_cmd(the_filename,

		       the_address,

		       the_subject,

		       the_ccaddr,

		       personal_mail_address);

    } else

#endif

#ifdef __DJGPP__

    if (LYGetEnv("SHELL")) {

	extern char *shell;

	const char *c_option;

	const char *format = "%s %s %s -t %s -F %s";

	if (dj_is_bash) {

	    c_option = "-c";

	} else {

	    c_option = "/c";

	}

	HTAddParam(&cmd, format, 1, shell);

	HTAddParam(&cmd, format, 2, c_option);

	HTAddParam(&cmd, format, 3, system_mail);

	HTAddParam(&cmd, format, 4, the_address);

	HTAddParam(&cmd, format, 5, the_filename);

	HTEndParam(&cmd, format, 6);

    } else

#endif /* __DJGPP__ */

    {

	const char *format = "%s -t %s -F %s";

	HTAddParam(&cmd, format, 1, system_mail);

	HTAddParam(&cmd, format, 2, the_address);

	HTAddParam(&cmd, format, 3, the_filename);

	HTEndParam(&cmd, format, 4);

    }

    stop_curses();

    SetOutputMode(O_TEXT);

    printf("%s\n\n$ %s\n\n%s",

	   *message ? message : gettext("Sending"),

	   cmd, PLEASE_WAIT);

    code = LYSystem(cmd);

    LYSleepMsg();

    start_curses();

    SetOutputMode(O_BINARY);

    FREE(cmd);

    return code;

}

#endif /* CAN_PIPE_TO_FILE */

#endif /* USE_VMS_MAILER */

/*

 *  mailform() sends form content to the mailto address(es). - FM

 */

void mailform(const char *mailto_address,

	      const char *mailto_subject,

	      const char *mailto_content,

	      const char *mailto_type)

{

    FILE *fd;

    char *address = NULL;

    char *ccaddr = NULL;

    char *keywords = NULL;

    char *cp = NULL;

    char self[MAX_SUBJECT + 10];

    char subject[MAX_SUBJECT + 10];

    char *searchpart = NULL;

    char buf[512];

    int len, i;

#if USE_VMS_MAILER

    static char *cmd;

    char *command = NULL;

    BOOLEAN isPMDF = LYMailPMDF();

    char hdrfile[LY_MAXPATH];

#endif

#if !CAN_PIPE_TO_MAILER

    char my_tmpfile[LY_MAXPATH];

#endif

    CTRACE((tfp, "mailto_address: \"%s\"\n", NONNULL(mailto_address)));

    CTRACE((tfp, "mailto_subject: \"%s\"\n", NONNULL(mailto_subject)));

    CTRACE((tfp, "mailto_content: \"%s\"\n", NONNULL(mailto_content)));

    CTRACE((tfp, "mailto_type:    \"%s\"\n", NONNULL(mailto_type)));

    if (!LYSystemMail())

	return;

    if (!mailto_address || !mailto_content) {

	HTAlert(BAD_FORM_MAILTO);

	return;

    }

    subject[0] = '\0';

    self[0] = '\0';

    if ((cp = StrChr(mailto_address, '\n')) != NULL)

	*cp = '\0';

    StrAllocCopy(address, mailto_address);

    /*

     * Check for a ?searchpart.  - FM

     */

    if ((cp = StrChr(address, '?')) != NULL) {

	StrAllocCopy(searchpart, cp);

	*cp = '\0';

	cp = (searchpart + 1);

	if (*cp != '\0') {

	    /*

	     * Seek and handle a subject=foo.  - FM

	     */

	    extract_subject(subject, searchpart);

	    /*

	     * Seek and handle to=address(es) fields.  Appends to address.  -

	     * FM

	     */

	    extract_field(&address, searchpart, "to=");

	    /*

	     * Seek and handle cc=address(es) fields.  Excludes Bcc=address(es)

	     * as unsafe.  We may append our own cc (below) as a list for the

	     * actual mailing.  - FM

	     */

	    extract_field(&ccaddr, searchpart, "cc=");

	    /*

	     * Seek and handle keywords=term(s) fields.  - FM

	     */

	    extract_field(&keywords, searchpart, "keywords=");

	    if (keywords != NULL) {

		if (*keywords != '\0') {

		    SafeHTUnEscape(keywords);

		} else {

		    FREE(keywords);

		}

	    }

	    FREE(searchpart);

	}

    }

    if (convert_explorer(address)) {

	HTAlert(BAD_FORM_MAILTO);

	goto cleanup;

    }

    if (ccaddr != NULL) {

	if (convert_explorer(ccaddr)) {

	    FREE(ccaddr);

	}

    }

    /*

     * Unescape the address and ccaddr fields.  - FM

     */

    SafeHTUnEscape(address);

    if (ccaddr != NULL) {

	SafeHTUnEscape(ccaddr);

    }

    /*

     * Allow user to edit the default Subject - FM

     */

    if (subject[0] == '\0') {

	if (non_empty(mailto_subject)) {

	    LYStrNCpy(subject, mailto_subject, MAX_SUBJECT);

	} else {

	    sprintf(subject, "mailto:%.63s", address);

	}

    }

    _statusline(SUBJECT_PROMPT);

    if (LYGetStr(subject, FALSE, MAX_SUBJECT, NORECALL) < 0) {

	/*

	 * User cancelled via ^G. - FM

	 */

	HTInfoMsg(FORM_MAILTO_CANCELLED);

	goto cleanup;

    }

    /*

     * Allow user to specify a self copy via a CC:  entry, if permitted.  - FM

     */

    if (!LYNoCc) {

	sprintf(self, "%.*s", MAX_SUBJECT,

		isEmpty(personal_mail_address) ? "" : personal_mail_address);

	_statusline("Cc: ");

	if (LYGetStr(self, FALSE, MAX_SUBJECT, NORECALL) < 0) {

	    /*

	     * User cancelled via ^G. - FM

	     */

	    HTInfoMsg(FORM_MAILTO_CANCELLED);

	    goto cleanup;

	}

	remove_tildes(self);

	if (ccaddr == NULL) {

	    StrAllocCopy(ccaddr, self);

	} else {

	    StrAllocCat(ccaddr, ",");

	    StrAllocCat(ccaddr, self);

	}

    }

#if CAN_PIPE_TO_MAILER

    if ((fd = LYPipeToMailer()) == 0) {

	HTAlert(FORM_MAILTO_FAILED);

	goto cleanup;

    }

    if (non_empty(mailto_type)) {

	fprintf(fd, "Mime-Version: 1.0\n");

	fprintf(fd, "Content-Type: %s\n", mailto_type);

    }

    fprintf(fd, "To: %s\n", address);

    if (non_empty(personal_mail_address))

	fprintf(fd, "From: %s\n", personal_mail_address);

    if (non_empty(ccaddr))

	fprintf(fd, "Cc: %s\n", ccaddr);

    fprintf(fd, "Subject: %s\n\n", subject);

    if (non_empty(keywords))

	fprintf(fd, "Keywords: %s\n", keywords);

    _statusline(SENDING_FORM_CONTENT);

#else /* e.g., VMS, DOS */

    if ((fd = LYOpenTemp(my_tmpfile, ".txt", "w")) == NULL) {

	HTAlert(FORM_MAILTO_FAILED);

	goto cleanup;

    }

#if USE_VMS_MAILER

    if (isPMDF) {

	FILE *hfd;

	if ((hfd = LYOpenTemp(hdrfile, ".txt", "w")) == NULL) {

	    HTAlert(FORM_MAILTO_FAILED);

	    LYCloseTempFP(fd);

	    goto cleanup;

	}

	if (non_empty(mailto_type)) {

	    fprintf(hfd, "Mime-Version: 1.0\n");

	    fprintf(hfd, "Content-Type: %s\n", mailto_type);

	    if (non_empty(personal_mail_address))

		fprintf(hfd, "From: %s\n", personal_mail_address);

	}

	/*

	 * For PMDF, put any keywords and the subject in the header file and

	 * close it.  - FM

	 */

	if (non_empty(keywords)) {

	    fprintf(hfd, "Keywords: %s\n", keywords);

	}

	fprintf(hfd, "Subject: %s\n\n", subject);

	LYCloseTempFP(hfd);

    } else if (mailto_type &&

	       !strncasecomp(mailto_type, "multipart/form-data", 19)) {

	/*

	 * Ugh!  There's no good way to include headers while we're still using

	 * "generic" VMS MAIL, so we'll put this in the body of the message.  -

	 * FM

	 */

	fprintf(fd, "X-Content-Type: %s\n\n", mailto_type);

    }

#else /* !VMS (DOS) */

#if USE_BLAT_MAILER

    if (mail_is_blat) {

	if (strlen(subject) > MAX_SUBJECT)

	    subject[MAX_SUBJECT] = '\0';

    } else

#endif

    {

	if (non_empty(mailto_type)) {

	    fprintf(fd, "Mime-Version: 1.0\n");

	    fprintf(fd, "Content-Type: %s\n", mailto_type);

	}

	fprintf(fd, "To: %s\n", address);

	if (non_empty(personal_mail_address))

	    fprintf(fd, "From: %s\n", personal_mail_address);

	fprintf(fd, "Subject: %.70s\n\n", subject);

    }

#endif /* VMS */

#endif /* CAN_PIPE_TO_MAILER */

    /*

     * Break up the content into lines with a maximum length of 78.  If the

     * ENCTYPE was text/plain, we have physical newlines and should take them

     * into account.  Otherwise, the actual newline characters in the content

     * are hex escaped.  - FM

     */

    while ((cp = StrChr(mailto_content, '\n')) != NULL) {

	*cp = '\0';

	i = 0;

	len = (int) strlen(mailto_content);

	while (len > 78) {

	    LYStrNCpy(buf, &mailto_content[i], 78);

	    fprintf(fd, "%s\n", buf);

	    i += 78;

	    len = (int) strlen(&mailto_content[i]);

	}

	fprintf(fd, "%s\n", &mailto_content[i]);

	mailto_content = (cp + 1);

    }

    i = 0;

    len = (int) strlen(mailto_content);

    while (len > 78) {

	LYStrNCpy(buf, &mailto_content[i], 78);

	fprintf(fd, "%s\n", buf);

	i += 78;

	len = (int) strlen(&mailto_content[i]);

    }

    if (len)

	fprintf(fd, "%s\n", &mailto_content[i]);

#if CAN_PIPE_TO_MAILER

    pclose(fd);

    LYSleepMsg();

#else

    LYCloseTempFP(fd);

#if USE_VMS_MAILER

    /*

     * Set the mail command.  - FM

     */

    if (isPMDF) {

	/*

	 * Now set up the command.  - FM

	 */

	HTSprintf0(&cmd,

		   "%s %s %s,%s ",

		   system_mail,

		   system_mail_flags,

		   hdrfile,

		   my_tmpfile);

    } else {

	/*

	 * For "generic" VMS MAIL, include the subject in the command, and

	 * ignore any keywords to minimize risk of them making the line too

	 * long or having problem characters.  - FM

	 */

	HTSprintf0(&cmd,

		   "%s %s%s/subject=\"%s\" %s ",

		   system_mail,

		   system_mail_flags,

		   (strncasecomp(system_mail, "MAIL", 4) ? "" : "/noself"),

		   subject,

		   my_tmpfile);

    }

    StrAllocCopy(command, cmd);

    vms_append_addrs(&command, address, "");

    if (non_empty(ccaddr)) {

	vms_append_addrs(&command, ccaddr, "/CC");

    }

    stop_curses();

    printf("%s\n\n$ %s\n\n%s", SENDING_FORM_CONTENT, command, PLEASE_WAIT);

    LYSystem(command);		/* Mail (VMS) */

    FREE(command);