/**
* mutt_do_pager - Display some page-able text to the user
* @param banner Message for status bar
* @param tempfile File to display
* @param do_color Flags, see #PagerFlags
* @param info Info about current mailbox (OPTIONAL)
* @retval 0 Success
* @retval -1 Error
*/
int mutt_do_pager(const char *banner, const char *tempfile, PagerFlags do_color,
struct Pager *info)
{
int rc;
if (!C_Pager || (mutt_str_strcmp(C_Pager, "builtin") == 0))
rc = mutt_pager(banner, tempfile, do_color, info);
else
{
char cmd[256];
mutt_endwin();
mutt_file_expand_fmt_quote(cmd, sizeof(cmd), C_Pager, tempfile);
if (mutt_system(cmd) == -1)
{
mutt_error(_("Error running \"%s\""), cmd);
rc = -1;
}
else
rc = 0;
mutt_file_unlink(tempfile);
}
return rc;
}
/* This function allows the user to specify a command to read stdout from in
place of a normal file. If the last character in the string is a pipe (|),
then we assume it is a commmand to run instead of a normal file. */
FILE *mutt_open_read (const char *path, pid_t * thepid)
{
FILE *f;
struct stat s;
int len = str_len (path);
if (path[len - 1] == '|') {
/* read from a pipe */
char *s = str_dup (path);
s[len - 1] = 0;
mutt_endwin (NULL);
*thepid = mutt_create_filter (s, NULL, &f, NULL);
mem_free (&s);
}
else {
if (stat (path, &s) < 0)
return (NULL);
if (S_ISDIR (s.st_mode)) {
errno = EINVAL;
return (NULL);
}
f = fopen (path, "r");
*thepid = -1;
}
return (f);
}
int mix_send_message (LIST *chain, const char *tempfile)
{
char cmd[HUGE_STRING];
char tmp[HUGE_STRING];
char cd_quoted[STRING];
int i;
snprintf (cmd, sizeof (cmd), "cat %s | %s -m ", tempfile, Mixmaster);
for (i = 0; chain; chain = chain->next, i = 1)
{
strfcpy (tmp, cmd, sizeof (tmp));
mutt_quote_filename (cd_quoted, sizeof (cd_quoted), (char *) chain->data);
snprintf (cmd, sizeof (cmd), "%s%s%s", tmp, i ? "," : " -l ", cd_quoted);
}
if (!option (OPTNOCURSES))
mutt_endwin (NULL);
if ((i = mutt_system (cmd)))
{
fprintf (stderr, _("Error sending message, child exited %d.\n"), i);
if (!option (OPTNOCURSES))
{
mutt_any_key_to_continue (NULL);
mutt_error _("Error sending message.");
}
}
unlink (tempfile);
return i;
}
FILE* io_open_read(const char* path, pid_t* thepid) {
FILE *f;
struct stat s;
size_t len = str_len (path);
if (!len)
return NULL;
if (path[len - 1] == '|') {
/* read from a pipe */
char *s = str_dup (path);
s[len - 1] = 0;
#if 0
/* XXX */
mutt_endwin (NULL);
#endif
*thepid = command_filter(s, NULL, &f, NULL);
mem_free (&s);
}
else {
if (stat (path, &s) < 0)
return (NULL);
if (S_ISDIR (s.st_mode)) {
errno = EINVAL;
return (NULL);
}
f = fopen (path, "r");
*thepid = -1;
}
return (f);
}
/**
* mutt_edit_file - Let the user edit a file
* @param editor User's editor config
* @param file File to edit
*/
void mutt_edit_file(const char *editor, const char *file)
{
char cmd[STR_COMMAND];
mutt_endwin();
mutt_file_expand_fmt_quote(cmd, sizeof(cmd), editor, file);
if (mutt_system(cmd) != 0)
{
mutt_error(_("Error running \"%s\""), cmd);
}
/* the terminal may have been resized while the editor owned it */
mutt_resize_screen();
keypad(stdscr, true);
clearok(stdscr, true);
}
/* invoke a command in a subshell */
void mutt_shell_escape (void)
{
char buf[LONG_STRING];
buf[0] = 0;
if (mutt_get_field (_("Shell command: "), buf, sizeof (buf), M_CMD) == 0) {
if (!buf[0] && Shell)
strfcpy (buf, Shell, sizeof (buf));
if(buf[0]) {
CLEARLINE (LINES-1);
mutt_endwin (NULL);
fflush (stdout);
if (mutt_system (buf) != 0 || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
}
}
}
/* return 1 if require full screen redraw, 0 otherwise */
int mutt_compose_attachment (BODY *a)
{
char type[STRING];
char command[STRING];
char newfile[_POSIX_PATH_MAX] = "";
rfc1524_entry *entry = rfc1524_new_entry ();
short unlink_newfile = 0;
int rc = 0;
snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
if (rfc1524_mailcap_lookup (a, type, entry, M_COMPOSE))
{
if (entry->composecommand || entry->composetypecommand)
{
if (entry->composetypecommand)
strfcpy (command, entry->composetypecommand, sizeof (command));
else
strfcpy (command, entry->composecommand, sizeof (command));
if (rfc1524_expand_filename (entry->nametemplate,
a->filename, newfile, sizeof (newfile)))
{
dprint(1, (debugfile, "oldfile: %s\t newfile: %s\n",
a->filename, newfile));
if (safe_symlink (a->filename, newfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), M_YES) != M_YES)
goto bailout;
}
else
unlink_newfile = 1;
}
else
strfcpy(newfile, a->filename, sizeof(newfile));
if (rfc1524_expand_command (a, newfile, type,
command, sizeof (command)))
{
/* For now, editing requires a file, no piping */
mutt_error _("Mailcap compose entry requires %%s");
}
else
{
int r;
mutt_endwin (NULL);
if ((r = mutt_system (command)) == -1)
mutt_error (_("Error running \"%s\"!"), command);
if (r != -1 && entry->composetypecommand)
{
BODY *b;
FILE *fp, *tfp;
char tempfile[_POSIX_PATH_MAX];
if ((fp = safe_fopen (a->filename, "r")) == NULL)
{
mutt_perror _("Failure to open file to parse headers.");
goto bailout;
}
b = mutt_read_mime_header (fp, 0);
if (b)
{
if (b->parameter)
{
mutt_free_parameter (&a->parameter);
a->parameter = b->parameter;
b->parameter = NULL;
}
if (b->description) {
FREE (&a->description);
a->description = b->description;
b->description = NULL;
}
if (b->form_name)
{
FREE (&a->form_name);
a->form_name = b->form_name;
b->form_name = NULL;
}
/* Remove headers by copying out data to another file, then
* copying the file back */
fseeko (fp, b->offset, 0);
mutt_mktemp (tempfile, sizeof (tempfile));
if ((tfp = safe_fopen (tempfile, "w")) == NULL)
{
mutt_perror _("Failure to open file to strip headers.");
goto bailout;
}
mutt_copy_stream (fp, tfp);
safe_fclose (&fp);
safe_fclose (&tfp);
mutt_unlink (a->filename);
if (mutt_rename_file (tempfile, a->filename) != 0)
{
mutt_perror _("Failure to rename file.");
goto bailout;
}
mutt_free_body (&b);
}
}
}
}
}
else
{
rfc1524_free_entry (&entry);
mutt_message (_("No mailcap compose entry for %s, creating empty file."),
type);
return 1;
}
rc = 1;
bailout:
if(unlink_newfile)
unlink(newfile);
rfc1524_free_entry (&entry);
return rc;
}
/* returns 1 on success, 0 on error */
int mutt_pipe_attachment (FILE *fp, BODY *b, const char *path, char *outfile)
{
pid_t thepid;
int out = -1;
int rv = 0;
if (outfile && *outfile)
if ((out = safe_open (outfile, O_CREAT | O_EXCL | O_WRONLY)) < 0)
{
mutt_perror ("open");
return 0;
}
mutt_endwin (NULL);
if (fp)
{
/* recv case */
STATE s;
memset (&s, 0, sizeof (STATE));
if (outfile && *outfile)
thepid = mutt_create_filter_fd (path, &s.fpout, NULL, NULL, -1, out, -1);
else
thepid = mutt_create_filter (path, &s.fpout, NULL, NULL);
if (thepid < 0)
{
mutt_perror _("Can't create filter");
goto bail;
}
s.fpin = fp;
mutt_decode_attachment (b, &s);
safe_fclose (&s.fpout);
}
else
{
/* send case */
FILE *ifp, *ofp;
if ((ifp = fopen (b->filename, "r")) == NULL)
{
mutt_perror ("fopen");
if (outfile && *outfile)
{
close (out);
unlink (outfile);
}
return 0;
}
if (outfile && *outfile)
thepid = mutt_create_filter_fd (path, &ofp, NULL, NULL, -1, out, -1);
else
thepid = mutt_create_filter (path, &ofp, NULL, NULL);
if (thepid < 0)
{
mutt_perror _("Can't create filter");
safe_fclose (&ifp);
goto bail;
}
mutt_copy_stream (ifp, ofp);
safe_fclose (&ofp);
safe_fclose (&ifp);
}
rv = 1;
bail:
if (outfile && *outfile)
close (out);
/*
* check for error exit from child process
*/
if (mutt_wait_filter (thepid) != 0)
rv = 0;
if (rv == 0 || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
return rv;
}
/* returns -1 on error, 0 or the return code from mutt_do_pager() on success */
int mutt_view_attachment (FILE *fp, BODY *a, int flag, HEADER *hdr,
ATTACHPTR **idx, short idxlen)
{
char tempfile[_POSIX_PATH_MAX] = "";
char pagerfile[_POSIX_PATH_MAX] = "";
int is_message;
int use_mailcap;
int use_pipe = 0;
int use_pager = 1;
char type[STRING];
char command[HUGE_STRING];
char descrip[STRING];
char *fname;
rfc1524_entry *entry = NULL;
int rc = -1;
int unlink_tempfile = 0;
is_message = mutt_is_message_type(a->type, a->subtype);
if (WithCrypto && is_message && a->hdr && (a->hdr->security & ENCRYPT) &&
!crypt_valid_passphrase(a->hdr->security))
return (rc);
use_mailcap = (flag == M_MAILCAP ||
(flag == M_REGULAR && mutt_needs_mailcap (a)));
snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
if (use_mailcap)
{
entry = rfc1524_new_entry ();
if (!rfc1524_mailcap_lookup (a, type, entry, 0))
{
if (flag == M_REGULAR)
{
/* fallback to view as text */
rfc1524_free_entry (&entry);
mutt_error _("No matching mailcap entry found. Viewing as text.");
flag = M_AS_TEXT;
use_mailcap = 0;
}
else
goto return_error;
}
}
if (use_mailcap)
{
if (!entry->command)
{
mutt_error _("MIME type not defined. Cannot view attachment.");
goto return_error;
}
strfcpy (command, entry->command, sizeof (command));
if (fp)
{
fname = safe_strdup (a->filename);
mutt_sanitize_filename (fname, 1);
}
else
fname = a->filename;
if (rfc1524_expand_filename (entry->nametemplate, fname,
tempfile, sizeof (tempfile)))
{
if (fp == NULL && mutt_strcmp(tempfile, a->filename))
{
/* send case: the file is already there */
if (safe_symlink (a->filename, tempfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), M_YES) == M_YES)
strfcpy (tempfile, a->filename, sizeof (tempfile));
else
goto return_error;
}
else
unlink_tempfile = 1;
}
}
else if (fp == NULL) /* send case */
strfcpy (tempfile, a->filename, sizeof (tempfile));
if (fp)
{
/* recv case: we need to save the attachment to a file */
FREE (&fname);
if (mutt_save_attachment (fp, a, tempfile, 0, NULL) == -1)
goto return_error;
}
use_pipe = rfc1524_expand_command (a, tempfile, type,
command, sizeof (command));
use_pager = entry->copiousoutput;
}
if (use_pager)
{
if (fp && !use_mailcap && a->filename)
{
/* recv case */
strfcpy (pagerfile, a->filename, sizeof (pagerfile));
mutt_adv_mktemp (pagerfile, sizeof(pagerfile));
}
else
mutt_mktemp (pagerfile, sizeof (pagerfile));
}
if (use_mailcap)
{
pid_t thepid = 0;
int tempfd = -1, pagerfd = -1;
if (!use_pager)
mutt_endwin (NULL);
if (use_pager || use_pipe)
{
if (use_pager && ((pagerfd = safe_open (pagerfile, O_CREAT | O_EXCL | O_WRONLY)) == -1))
{
mutt_perror ("open");
goto return_error;
}
if (use_pipe && ((tempfd = open (tempfile, 0)) == -1))
{
if(pagerfd != -1)
close(pagerfd);
mutt_perror ("open");
goto return_error;
}
if ((thepid = mutt_create_filter_fd (command, NULL, NULL, NULL,
use_pipe ? tempfd : -1, use_pager ? pagerfd : -1, -1)) == -1)
{
if(pagerfd != -1)
close(pagerfd);
if(tempfd != -1)
close(tempfd);
mutt_error _("Cannot create filter");
goto return_error;
}
if (use_pager)
{
if (a->description)
snprintf (descrip, sizeof (descrip),
_("---Command: %-20.20s Description: %s"),
command, a->description);
else
snprintf (descrip, sizeof (descrip),
_("---Command: %-30.30s Attachment: %s"), command, type);
}
if ((mutt_wait_filter (thepid) || (entry->needsterminal &&
option (OPTWAITKEY))) && !use_pager)
mutt_any_key_to_continue (NULL);
if (tempfd != -1)
close (tempfd);
if (pagerfd != -1)
close (pagerfd);
}
else
{
/* interactive command */
if (mutt_system (command) ||
(entry->needsterminal && option (OPTWAITKEY)))
mutt_any_key_to_continue (NULL);
}
}
else
{
/* Don't use mailcap; the attachment is viewed in the pager */
if (flag == M_AS_TEXT)
{
/* just let me see the raw data */
if (mutt_save_attachment (fp, a, pagerfile, 0, NULL))
goto return_error;
}
else
{
/* Use built-in handler */
set_option (OPTVIEWATTACH); /* disable the "use 'v' to view this part"
* message in case of error */
if (mutt_decode_save_attachment (fp, a, pagerfile, M_DISPLAY, 0))
{
unset_option (OPTVIEWATTACH);
goto return_error;
}
unset_option (OPTVIEWATTACH);
}
if (a->description)
strfcpy (descrip, a->description, sizeof (descrip));
else if (a->filename)
snprintf (descrip, sizeof (descrip), _("---Attachment: %s: %s"),
a->filename, type);
else
snprintf (descrip, sizeof (descrip), _("---Attachment: %s"), type);
}
/* We only reach this point if there have been no errors */
if (use_pager)
{
pager_t info;
memset (&info, 0, sizeof (info));
info.fp = fp;
info.bdy = a;
info.ctx = Context;
info.idx = idx;
info.idxlen = idxlen;
info.hdr = hdr;
rc = mutt_do_pager (descrip, pagerfile,
M_PAGER_ATTACHMENT | (is_message ? M_PAGER_MESSAGE : 0), &info);
*pagerfile = '\0';
}
else
rc = 0;
return_error:
if (entry)
rfc1524_free_entry (&entry);
if (fp && tempfile[0])
mutt_unlink (tempfile);
else if (unlink_tempfile)
unlink(tempfile);
if (pagerfile[0])
mutt_unlink (pagerfile);
return rc;
}
/*
* Currently, this only works for send mode, as it assumes that the
* BODY->filename actually contains the information. I'm not sure
* we want to deal with editing attachments we've already received,
* so this should be ok.
*
* Returns 1 if editor found, 0 if not (useful to tell calling menu to
* redraw)
*/
int mutt_edit_attachment (BODY *a)
{
char type[STRING];
char command[STRING];
char newfile[_POSIX_PATH_MAX] = "";
rfc1524_entry *entry = rfc1524_new_entry ();
short unlink_newfile = 0;
int rc = 0;
snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
if (rfc1524_mailcap_lookup (a, type, entry, M_EDIT))
{
if (entry->editcommand)
{
strfcpy (command, entry->editcommand, sizeof (command));
if (rfc1524_expand_filename (entry->nametemplate,
a->filename, newfile, sizeof (newfile)))
{
dprint(1, (debugfile, "oldfile: %s\t newfile: %s\n",
a->filename, newfile));
if (safe_symlink (a->filename, newfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), M_YES) != M_YES)
goto bailout;
}
else
unlink_newfile = 1;
}
else
strfcpy(newfile, a->filename, sizeof(newfile));
if (rfc1524_expand_command (a, newfile, type,
command, sizeof (command)))
{
/* For now, editing requires a file, no piping */
mutt_error _("Mailcap Edit entry requires %%s");
goto bailout;
}
else
{
mutt_endwin (NULL);
if (mutt_system (command) == -1)
{
mutt_error (_("Error running \"%s\"!"), command);
goto bailout;
}
}
}
}
else if (a->type == TYPETEXT)
{
/* On text, default to editor */
mutt_edit_file (NONULL (Editor), a->filename);
}
else
{
rfc1524_free_entry (&entry);
mutt_error (_("No mailcap edit entry for %s"),type);
return 0;
}
rc = 1;
bailout:
if(unlink_newfile)
unlink(newfile);
rfc1524_free_entry (&entry);
return rc;
}
static int _mutt_pipe_message (HEADER *h, char *cmd,
int decode,
int print,
int split,
char *sep)
{
int i, rc = 0;
pid_t thepid;
FILE *fpout;
/* mutt_endwin (NULL);
is this really needed here ?
it makes the screen flicker on pgp and s/mime messages,
before asking for a passphrase...
Oliver Ehli */
if (h)
{
mutt_message_hook (Context, h, M_MESSAGEHOOK);
if (WithCrypto && decode)
{
mutt_parse_mime_message (Context, h);
if(h->security & ENCRYPT && !crypt_valid_passphrase(h->security))
return 1;
}
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
{
mutt_perror _("Can't create filter process");
return 1;
}
pipe_msg (h, fpout, decode, print);
safe_fclose (&fpout);
rc = mutt_wait_filter (thepid);
}
else
{ /* handle tagged messages */
if (WithCrypto && decode)
{
for (i = 0; i < Context->vcount; i++)
if(Context->hdrs[Context->v2r[i]]->tagged)
{
mutt_message_hook (Context, Context->hdrs[Context->v2r[i]], M_MESSAGEHOOK);
mutt_parse_mime_message(Context, Context->hdrs[Context->v2r[i]]);
if (Context->hdrs[Context->v2r[i]]->security & ENCRYPT &&
!crypt_valid_passphrase(Context->hdrs[Context->v2r[i]]->security))
return 1;
}
}
if (split)
{
for (i = 0; i < Context->vcount; i++)
{
if (Context->hdrs[Context->v2r[i]]->tagged)
{
mutt_message_hook (Context, Context->hdrs[Context->v2r[i]], M_MESSAGEHOOK);
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
{
mutt_perror _("Can't create filter process");
return 1;
}
pipe_msg (Context->hdrs[Context->v2r[i]], fpout, decode, print);
/* add the message separator */
if (sep) fputs (sep, fpout);
safe_fclose (&fpout);
if (mutt_wait_filter (thepid) != 0)
rc = 1;
}
}
}
else
{
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
{
mutt_perror _("Can't create filter process");
return 1;
}
for (i = 0; i < Context->vcount; i++)
{
if (Context->hdrs[Context->v2r[i]]->tagged)
{
mutt_message_hook (Context, Context->hdrs[Context->v2r[i]], M_MESSAGEHOOK);
pipe_msg (Context->hdrs[Context->v2r[i]], fpout, decode, print);
/* add the message separator */
if (sep) fputs (sep, fpout);
}
}
safe_fclose (&fpout);
if (mutt_wait_filter (thepid) != 0)
rc = 1;
}
}
if (rc || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
return rc;
}
/**
* crypt_extract_keys_from_messages - Extract keys from a message
* @param el List of Emails to process
*
* The extracted keys will be added to the user's keyring.
*/
void crypt_extract_keys_from_messages(struct EmailList *el)
{
char tempfname[PATH_MAX], *mbox = NULL;
struct Address *tmp = NULL;
if (!WithCrypto)
return;
mutt_mktemp(tempfname, sizeof(tempfname));
FILE *fp_out = mutt_file_fopen(tempfname, "w");
if (!fp_out)
{
mutt_perror(tempfname);
return;
}
if (WithCrypto & APPLICATION_PGP)
OptDontHandlePgpKeys = true;
struct EmailNode *en = NULL;
STAILQ_FOREACH(en, el, entries)
{
struct Email *e = en->email;
mutt_parse_mime_message(Context->mailbox, e);
if (e->security & SEC_ENCRYPT && !crypt_valid_passphrase(e->security))
{
mutt_file_fclose(&fp_out);
break;
}
if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & APPLICATION_PGP))
{
mutt_copy_message_ctx(fp_out, Context->mailbox, e,
MUTT_CM_DECODE | MUTT_CM_CHARCONV, 0);
fflush(fp_out);
mutt_endwin();
puts(_("Trying to extract PGP keys...\n"));
crypt_pgp_invoke_import(tempfname);
}
if (((WithCrypto & APPLICATION_SMIME) != 0) && (e->security & APPLICATION_SMIME))
{
if (e->security & SEC_ENCRYPT)
{
mutt_copy_message_ctx(fp_out, Context->mailbox, e,
MUTT_CM_NOHEADER | MUTT_CM_DECODE_CRYPT | MUTT_CM_DECODE_SMIME,
0);
}
else
mutt_copy_message_ctx(fp_out, Context->mailbox, e, 0, 0);
fflush(fp_out);
if (e->env->from)
tmp = mutt_expand_aliases(e->env->from);
else if (e->env->sender)
tmp = mutt_expand_aliases(e->env->sender);
mbox = tmp ? tmp->mailbox : NULL;
if (mbox)
{
mutt_endwin();
puts(_("Trying to extract S/MIME certificates..."));
crypt_smime_invoke_import(tempfname, mbox);
tmp = NULL;
}
}
rewind(fp_out);
}
mutt_file_fclose(&fp_out);
if (isendwin())
mutt_any_key_to_continue(NULL);
mutt_file_unlink(tempfname);
if (WithCrypto & APPLICATION_PGP)
OptDontHandlePgpKeys = false;
}
/**
* mutt_protect - Encrypt and/or sign a message
* @param msg Header of the message
* @param keylist List of keys to encrypt to (space-separated)
* @retval 0 Success
* @retval -1 Error
*/
int mutt_protect(struct Email *msg, char *keylist)
{
struct Body *pbody = NULL, *tmp_pbody = NULL;
struct Body *tmp_smime_pbody = NULL;
struct Body *tmp_pgp_pbody = NULL;
int flags = (WithCrypto & APPLICATION_PGP) ? msg->security : 0;
if (!WithCrypto)
return -1;
if (!(msg->security & (SEC_ENCRYPT | SEC_SIGN)))
return 0;
if ((msg->security & SEC_SIGN) && !crypt_valid_passphrase(msg->security))
return -1;
if (((WithCrypto & APPLICATION_PGP) != 0) && ((msg->security & PGP_INLINE) == PGP_INLINE))
{
if ((msg->content->type != TYPE_TEXT) ||
(mutt_str_strcasecmp(msg->content->subtype, "plain") != 0))
{
if (query_quadoption(C_PgpMimeAuto,
_("Inline PGP can't be used with attachments. "
"Revert to PGP/MIME?")) != MUTT_YES)
{
mutt_error(
_("Mail not sent: inline PGP can't be used with attachments"));
return -1;
}
}
else if (mutt_str_strcasecmp("flowed", mutt_param_get(&msg->content->parameter, "format")) == 0)
{
if ((query_quadoption(C_PgpMimeAuto,
_("Inline PGP can't be used with format=flowed. "
"Revert to PGP/MIME?"))) != MUTT_YES)
{
mutt_error(
_("Mail not sent: inline PGP can't be used with format=flowed"));
return -1;
}
}
else
{
/* they really want to send it inline... go for it */
if (!isendwin())
{
mutt_endwin();
puts(_("Invoking PGP..."));
}
pbody = crypt_pgp_traditional_encryptsign(msg->content, flags, keylist);
if (pbody)
{
msg->content = pbody;
return 0;
}
/* otherwise inline won't work...ask for revert */
if (query_quadoption(
C_PgpMimeAuto,
_("Message can't be sent inline. Revert to using PGP/MIME?")) != MUTT_YES)
{
mutt_error(_("Mail not sent"));
return -1;
}
}
/* go ahead with PGP/MIME */
}
if (!isendwin())
mutt_endwin();
if (WithCrypto & APPLICATION_SMIME)
tmp_smime_pbody = msg->content;
if (WithCrypto & APPLICATION_PGP)
tmp_pgp_pbody = msg->content;
if (C_CryptUsePka && (msg->security & SEC_SIGN))
{
/* Set sender (necessary for e.g. PKA). */
const char *mailbox = NULL;
struct Address *from = msg->env->from;
if (!from)
from = mutt_default_from();
mailbox = from->mailbox;
if (!mailbox && C_EnvelopeFromAddress)
mailbox = C_EnvelopeFromAddress->mailbox;
if (((WithCrypto & APPLICATION_SMIME) != 0) && (msg->security & APPLICATION_SMIME))
crypt_smime_set_sender(mailbox);
else if (((WithCrypto & APPLICATION_PGP) != 0) && (msg->security & APPLICATION_PGP))
crypt_pgp_set_sender(mailbox);
if (!msg->env->from)
mutt_addr_free(&from);
}
if (C_CryptProtectedHeadersWrite)
{
struct Envelope *protected_headers = mutt_env_new();
mutt_str_replace(&protected_headers->subject, msg->env->subject);
/* Note: if other headers get added, such as to, cc, then a call to
* mutt_env_to_intl() will need to be added here too. */
mutt_prepare_envelope(protected_headers, 0);
mutt_env_free(&msg->content->mime_headers);
msg->content->mime_headers = protected_headers;
}
if (msg->security & SEC_SIGN)
{
if (((WithCrypto & APPLICATION_SMIME) != 0) && (msg->security & APPLICATION_SMIME))
{
tmp_pbody = crypt_smime_sign_message(msg->content);
if (!tmp_pbody)
goto bail;
pbody = tmp_pbody;
tmp_smime_pbody = tmp_pbody;
}
if (((WithCrypto & APPLICATION_PGP) != 0) && (msg->security & APPLICATION_PGP) &&
(!(flags & SEC_ENCRYPT) || C_PgpRetainableSigs))
{
tmp_pbody = crypt_pgp_sign_message(msg->content);
if (!tmp_pbody)
goto bail;
flags &= ~SEC_SIGN;
pbody = tmp_pbody;
tmp_pgp_pbody = tmp_pbody;
}
if ((WithCrypto != 0) && (msg->security & APPLICATION_SMIME) &&
(msg->security & APPLICATION_PGP))
{
/* here comes the draft ;-) */
}
}
if (msg->security & SEC_ENCRYPT)
{
if (((WithCrypto & APPLICATION_SMIME) != 0) && (msg->security & APPLICATION_SMIME))
{
tmp_pbody = crypt_smime_build_smime_entity(tmp_smime_pbody, keylist);
if (!tmp_pbody)
{
/* signed ? free it! */
goto bail;
}
/* free tmp_body if messages was signed AND encrypted ... */
if ((tmp_smime_pbody != msg->content) && (tmp_smime_pbody != tmp_pbody))
{
/* detach and don't delete msg->content,
* which tmp_smime_pbody->parts after signing. */
tmp_smime_pbody->parts = tmp_smime_pbody->parts->next;
msg->content->next = NULL;
mutt_body_free(&tmp_smime_pbody);
}
pbody = tmp_pbody;
}
if (((WithCrypto & APPLICATION_PGP) != 0) && (msg->security & APPLICATION_PGP))
{
pbody = crypt_pgp_encrypt_message(tmp_pgp_pbody, keylist, (flags & SEC_SIGN));
if (!pbody)
{
/* did we perform a retainable signature? */
if (flags != msg->security)
{
/* remove the outer multipart layer */
tmp_pgp_pbody = mutt_remove_multipart(tmp_pgp_pbody);
/* get rid of the signature */
mutt_body_free(&tmp_pgp_pbody->next);
}
goto bail;
}
/* destroy temporary signature envelope when doing retainable
* signatures.
*/
if (flags != msg->security)
{
tmp_pgp_pbody = mutt_remove_multipart(tmp_pgp_pbody);
mutt_body_free(&tmp_pgp_pbody->next);
}
}
}
if (pbody)
{
msg->content = pbody;
return 0;
}
bail:
mutt_env_free(&msg->content->mime_headers);
return -1;
}
int main(int argc, char **argv)
{
char folder[_POSIX_PATH_MAX] = "";
int flags = 0;
/* set default locale */
setlocale(LC_ALL, "");
/* initialization of main output routines with default values */
mutt_error = mutt_message = mutt_nocurses_error;
/* parse command line options */
parse_argv(argc, argv);
if (arg_version == 1)
{
show_version();
exit(RETURN_SUCCESS);
} else if (arg_version == 2)
{
show_version_verbose();
exit(RETURN_SUCCESS);
}
if (arg_execute)
{
init(commands);
is_mutt_init = true;
}
if (arg_expand_alias)
{
struct list_t *alias;
if (!is_mutt_init)
init(commands);
for(alias = aliases; alias; alias = alias->next)
{
struct address *a = mutt_lookup_alias(alias->data);
if (a)
{
printf("alias->data %s\n", alias->data);
mutt_write_address_list(a, stdout, 0, 0);
}
}
exit(RETURN_SUCCESS);
}
if (arg_query_conf)
{
if (!is_mutt_init)
init(commands);
if (queries)
return mutt_query_variables(queries);
exit(RETURN_SUCCESS);
}
if (arg_emulate_mailx) {
sendflags |= SENDMAILX;
}
if (arg_mailbox)
strfcpy(folder, arg_mailbox, sizeof(folder));
if (arg_mailbox_type)
mx_set_magic(arg_mailbox_type);
if (arg_resume_postponed)
sendflags |= SENDPOSTPONED;
/* no-curses for non-terminal session */
if (!isatty(STDIN_FILENO))
{
set_bit(options, OPTNOCURSES);
sendflags = SENDBATCH;
}
else
{
/*
* This must come before mutt_init() because curses needs to be started
* before calling the init_pair() function to set the color scheme.
*/
start_curses();
/* check whether terminal status is supported */
term_status = mutt_ts_capability();
}
/* Initialize crypto backends. */
crypt_init();
if (!is_mutt_init)
init(commands);
if (!bit_val(options, OPTNOCURSES))
{
SETCOLOR(MT_COLOR_NORMAL);
clear();
mutt_error = mutt_curses_error;
mutt_message = mutt_curses_message;
}
/* Create the Maildir directory if it doesn't exist */
if (!bit_val(options, OPTNOCURSES) && Maildir)
{
struct stat sb;
char fpath[_POSIX_PATH_MAX];
char msg[STRING];
strfcpy(fpath, Maildir, sizeof(fpath));
mutt_expand_path(fpath, sizeof(fpath));
#if USE_IMAP
/* we're not connected yet - skip mail folder creation */
if (!mx_is_imap(fpath))
#endif
if (stat(fpath, &sb) == -1 && errno == ENOENT)
{
snprintf(msg, sizeof(msg), ("%s does not exist. Create it?"), Maildir);
if (mutt_yesorno(msg, M_YES) == M_YES)
if (mkdir(fpath, 0700) == -1 && errno != EEXIST)
mutt_error( ("Can't create %s: %s."), Maildir, strerror(errno));
}
}
if (sendflags & SENDPOSTPONED)
{
if (!bit_val(options, OPTNOCURSES))
mutt_flushinp();
ci_send_message(SENDPOSTPONED, NULL, NULL, NULL, NULL);
mutt_endwin(NULL);
}
else if (arg_subject || msg || sendflags || arg_include || attach)
{
FILE *fin = NULL;
char buf[LONG_STRING];
char *tempfile = NULL, *infile = NULL;
char *bodytext = NULL;
int rv = 0;
if (!bit_val(options, OPTNOCURSES))
mutt_flushinp();
if (!msg)
msg = mutt_new_header();
if (!msg->env)
msg->env = mutt_new_envelope();
for(; addr_to; addr_to = addr_to->next)
{
if (url_check_scheme(addr_to->data) == U_MAILTO)
{
if (url_parse_mailto(msg->env, &bodytext, addr_to->data) < 0)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
fputs(("Failed to parse mailto: link\n"), stderr);
exit(RETURN_WRONG_ADDR);
}
}
else
msg->env->to = rfc822_parse_adrlist(msg->env->to, addr_to->data);
}
if (bit_val(options, OPTAUTOEDIT) && !msg->env->to && !msg->env->cc)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
fputs(("No recipients specified.\n"), stderr);
exit(RETURN_ERR_ARG);
}
if (arg_subject)
msg->env->subject = safe_strdup(arg_subject);
if (arg_include)
infile = arg_include;
if (infile || bodytext)
{
if (infile)
{
if (mutt_strcmp("-", infile) == 0)
fin = stdin;
else
{
char path[_POSIX_PATH_MAX];
strfcpy(path, infile, sizeof(path));
mutt_expand_path(path, sizeof(path));
if ((fin = fopen(path, "r")) == NULL)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
perror(path);
exit(RETURN_ERR_ARG);
}
}
}
mutt_mktemp(buf, sizeof(buf));
tempfile = safe_strdup(buf);
/* TODO: is the following if still needed? */
if (tempfile)
{
FILE *fout;
if ((fout = safe_fopen(tempfile, "w")) == NULL)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
perror(tempfile);
safe_fclose(&fin);
safe_free(&tempfile);
exit(RETURN_ERR_ARG);
}
if (fin)
mutt_copy_stream(fin, fout);
else if (bodytext)
fputs(bodytext, fout);
safe_fclose(&fout);
}
if (fin && fin != stdin)
safe_fclose(&fin);
}
safe_free(&bodytext);
if (attach)
{
struct list_t *t = attach;
struct body *a = NULL;
while(t)
{
if (a)
{
a->next = mutt_make_file_attach(t->data);
a = a->next;
}
else
msg->content = a = mutt_make_file_attach(t->data);
if (!a)
{
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
fprintf(stderr, ("%s: unable to attach file.\n"), t->data);
mutt_free_list(&attach);
exit(RETURN_ERR_ARG);
}
t = t->next;
}
mutt_free_list(&attach);
}
rv = ci_send_message(sendflags, msg, tempfile, NULL, NULL);
if (!bit_val(options, OPTNOCURSES))
mutt_endwin(NULL);
if (rv)
exit(RETURN_ERR_ARG);
}
else
{
if (!folder[0])
strfcpy(folder, NONULL(Spoolfile), sizeof(folder));
mutt_expand_path(folder, sizeof(folder));
mutt_str_replace(&CurrentFolder, folder);
mutt_str_replace(&LastFolder, folder);
mutt_folder_hook(folder);
if ((Context = mx_open_mailbox(folder, flags, NULL)) || !arg_mailbox)
{
mutt_index_menu();
if (Context)
safe_free(&Context);
}
#if USE_IMAP
imap_logout_all();
#endif
#if USE_SASL
mutt_sasl_done();
#endif
mutt_free_opts();
mutt_endwin(Errorbuf);
}
exit(RETURN_SUCCESS);
}
void mutt_exit(int code)
{
mutt_endwin(NULL);
exit(code);
}
int mutt_print_attachment (FILE *fp, BODY *a)
{
char newfile[_POSIX_PATH_MAX] = "";
char type[STRING];
pid_t thepid;
FILE *ifp, *fpout;
short unlink_newfile = 0;
snprintf (type, sizeof (type), "%s/%s", TYPE (a), a->subtype);
if (rfc1524_mailcap_lookup (a, type, NULL, M_PRINT))
{
char command[_POSIX_PATH_MAX+STRING];
rfc1524_entry *entry;
int piped = FALSE;
dprint (2, (debugfile, "Using mailcap...\n"));
entry = rfc1524_new_entry ();
rfc1524_mailcap_lookup (a, type, entry, M_PRINT);
if (rfc1524_expand_filename (entry->nametemplate, a->filename,
newfile, sizeof (newfile)))
{
if (!fp)
{
if (safe_symlink(a->filename, newfile) == -1)
{
if (mutt_yesorno (_("Can't match nametemplate, continue?"), M_YES) != M_YES)
{
rfc1524_free_entry (&entry);
return 0;
}
strfcpy (newfile, a->filename, sizeof (newfile));
}
else
unlink_newfile = 1;
}
}
/* in recv mode, save file to newfile first */
if (fp)
mutt_save_attachment (fp, a, newfile, 0, NULL);
strfcpy (command, entry->printcommand, sizeof (command));
piped = rfc1524_expand_command (a, newfile, type, command, sizeof (command));
mutt_endwin (NULL);
/* interactive program */
if (piped)
{
if ((ifp = fopen (newfile, "r")) == NULL)
{
mutt_perror ("fopen");
rfc1524_free_entry (&entry);
return (0);
}
if ((thepid = mutt_create_filter (command, &fpout, NULL, NULL)) < 0)
{
mutt_perror _("Can't create filter");
rfc1524_free_entry (&entry);
safe_fclose (&ifp);
return 0;
}
mutt_copy_stream (ifp, fpout);
safe_fclose (&fpout);
safe_fclose (&ifp);
if (mutt_wait_filter (thepid) || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
}
else
{
if (mutt_system (command) || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
}
if (fp)
mutt_unlink (newfile);
else if (unlink_newfile)
unlink(newfile);
rfc1524_free_entry (&entry);
return (1);
}
if (!ascii_strcasecmp ("text/plain", type) ||
!ascii_strcasecmp ("application/postscript", type))
{
return (mutt_pipe_attachment (fp, a, NONULL(PrintCmd), NULL));
}
else if (mutt_can_decode (a))
{
/* decode and print */
int rc = 0;
ifp = NULL;
fpout = NULL;
mutt_mktemp (newfile, sizeof (newfile));
if (mutt_decode_save_attachment (fp, a, newfile, M_PRINTING, 0) == 0)
{
dprint (2, (debugfile, "successfully decoded %s type attachment to %s\n",
type, newfile));
if ((ifp = fopen (newfile, "r")) == NULL)
{
mutt_perror ("fopen");
goto bail0;
}
dprint (2, (debugfile, "successfully opened %s read-only\n", newfile));
mutt_endwin (NULL);
if ((thepid = mutt_create_filter (NONULL(PrintCmd), &fpout, NULL, NULL)) < 0)
{
mutt_perror _("Can't create filter");
goto bail0;
}
dprint (2, (debugfile, "Filter created.\n"));
mutt_copy_stream (ifp, fpout);
safe_fclose (&fpout);
safe_fclose (&ifp);
if (mutt_wait_filter (thepid) != 0 || option (OPTWAITKEY))
mutt_any_key_to_continue (NULL);
rc = 1;
}
bail0:
safe_fclose (&ifp);
safe_fclose (&fpout);
mutt_unlink (newfile);
return rc;
}
else
{
mutt_error _("I don't know how to print that!");
return 0;
}
}
int mutt_protect (HEADER *msg, char *keylist)
{
BODY *pbody = NULL, *tmp_pbody = NULL;
BODY *tmp_smime_pbody = NULL;
BODY *tmp_pgp_pbody = NULL;
int flags = (WithCrypto & APPLICATION_PGP)? msg->security: 0;
int i;
if (!WithCrypto)
return -1;
if (!(msg->security & (ENCRYPT | SIGN)))
return 0;
if ((msg->security & SIGN) && !crypt_valid_passphrase (msg->security))
return (-1);
if ((WithCrypto & APPLICATION_PGP) && ((msg->security & PGPINLINE) == PGPINLINE))
{
if ((msg->content->type != TYPETEXT) ||
ascii_strcasecmp (msg->content->subtype, "plain"))
{
if ((i = query_quadoption (OPT_PGPMIMEAUTO,
_("Inline PGP can't be used with attachments. Revert to PGP/MIME?"))) != MUTT_YES)
{
mutt_error _("Mail not sent: inline PGP can't be used with attachments.");
return -1;
}
}
else
{
/* they really want to send it inline... go for it */
if (!isendwin ()) mutt_endwin _("Invoking PGP...");
pbody = crypt_pgp_traditional_encryptsign (msg->content, flags, keylist);
if (pbody)
{
msg->content = pbody;
return 0;
}
/* otherwise inline won't work...ask for revert */
if ((i = query_quadoption (OPT_PGPMIMEAUTO, _("Message can't be sent inline. Revert to using PGP/MIME?"))) != MUTT_YES)
{
mutt_error _("Mail not sent.");
return -1;
}
}
/* go ahead with PGP/MIME */
}
if (!isendwin ()) mutt_endwin (NULL);
if ((WithCrypto & APPLICATION_SMIME))
tmp_smime_pbody = msg->content;
if ((WithCrypto & APPLICATION_PGP))
tmp_pgp_pbody = msg->content;
if (option (OPTCRYPTUSEPKA) && (msg->security & SIGN))
{
/* Set sender (necessary for e.g. PKA). */
if ((WithCrypto & APPLICATION_SMIME)
&& (msg->security & APPLICATION_SMIME))
crypt_smime_set_sender (msg->env->from->mailbox);
else if ((WithCrypto & APPLICATION_PGP)
&& (msg->security & APPLICATION_PGP))
crypt_pgp_set_sender (msg->env->from->mailbox);
}
if (msg->security & SIGN)
{
if ((WithCrypto & APPLICATION_SMIME)
&& (msg->security & APPLICATION_SMIME))
{
if (!(tmp_pbody = crypt_smime_sign_message (msg->content)))
return -1;
pbody = tmp_smime_pbody = tmp_pbody;
}
if ((WithCrypto & APPLICATION_PGP)
&& (msg->security & APPLICATION_PGP)
&& (!(flags & ENCRYPT) || option (OPTPGPRETAINABLESIG)))
{
if (!(tmp_pbody = crypt_pgp_sign_message (msg->content)))
return -1;
flags &= ~SIGN;
pbody = tmp_pgp_pbody = tmp_pbody;
}
if (WithCrypto
&& (msg->security & APPLICATION_SMIME)
&& (msg->security & APPLICATION_PGP))
{
/* here comes the draft ;-) */
}
}
if (msg->security & ENCRYPT)
{
if ((WithCrypto & APPLICATION_SMIME)
&& (msg->security & APPLICATION_SMIME))
{
if (!(tmp_pbody = crypt_smime_build_smime_entity (tmp_smime_pbody,
keylist)))
{
/* signed ? free it! */
return (-1);
}
/* free tmp_body if messages was signed AND encrypted ... */
if (tmp_smime_pbody != msg->content && tmp_smime_pbody != tmp_pbody)
{
/* detatch and don't delete msg->content,
which tmp_smime_pbody->parts after signing. */
tmp_smime_pbody->parts = tmp_smime_pbody->parts->next;
msg->content->next = NULL;
mutt_free_body (&tmp_smime_pbody);
}
pbody = tmp_pbody;
}
if ((WithCrypto & APPLICATION_PGP)
&& (msg->security & APPLICATION_PGP))
{
if (!(pbody = crypt_pgp_encrypt_message (tmp_pgp_pbody, keylist,
flags & SIGN)))
{
/* did we perform a retainable signature? */
if (flags != msg->security)
{
/* remove the outer multipart layer */
tmp_pgp_pbody = mutt_remove_multipart (tmp_pgp_pbody);
/* get rid of the signature */
mutt_free_body (&tmp_pgp_pbody->next);
}
return (-1);
}
/* destroy temporary signature envelope when doing retainable
* signatures.
*/
if (flags != msg->security)
{
tmp_pgp_pbody = mutt_remove_multipart (tmp_pgp_pbody);
mutt_free_body (&tmp_pgp_pbody->next);
}
}
}
if(pbody)
msg->content = pbody;
return 0;
}
int mutt_display_message (HEADER *cur)
{
char tempfile[_POSIX_PATH_MAX], buf[LONG_STRING];
int rc = 0, builtin = 0;
int cmflags = M_CM_DECODE | M_CM_DISPLAY | M_CM_CHARCONV;
FILE *fpout = NULL;
FILE *fpfilterout = NULL;
pid_t filterpid = -1;
int res;
snprintf (buf, sizeof (buf), "%s/%s", TYPE (cur->content),
cur->content->subtype);
mutt_parse_mime_message (Context, cur);
mutt_message_hook (Context, cur, M_MESSAGEHOOK);
/* see if crypto is needed for this message. if so, we should exit curses */
if (WithCrypto && cur->security)
{
if (cur->security & ENCRYPT)
{
if (cur->security & APPLICATION_SMIME)
crypt_smime_getkeys (cur->env);
if(!crypt_valid_passphrase(cur->security))
return 0;
cmflags |= M_CM_VERIFY;
}
else if (cur->security & SIGN)
{
/* find out whether or not the verify signature */
if (query_quadoption (OPT_VERIFYSIG, _("Verify PGP signature?")) == M_YES)
{
cmflags |= M_CM_VERIFY;
}
}
}
if (cmflags & M_CM_VERIFY || cur->security & ENCRYPT)
{
if (cur->security & APPLICATION_PGP)
{
if (cur->env->from)
crypt_pgp_invoke_getkeys (cur->env->from);
crypt_invoke_message (APPLICATION_PGP);
}
if (cur->security & APPLICATION_SMIME)
crypt_invoke_message (APPLICATION_SMIME);
}
mutt_mktemp (tempfile, sizeof (tempfile));
if ((fpout = safe_fopen (tempfile, "w")) == NULL)
{
mutt_error _("Could not create temporary file!");
return (0);
}
if (DisplayFilter && *DisplayFilter)
{
fpfilterout = fpout;
fpout = NULL;
/* mutt_endwin (NULL); */
filterpid = mutt_create_filter_fd (DisplayFilter, &fpout, NULL, NULL,
-1, fileno(fpfilterout), -1);
if (filterpid < 0)
{
mutt_error (_("Cannot create display filter"));
safe_fclose (&fpfilterout);
unlink (tempfile);
return 0;
}
}
if (!Pager || mutt_strcmp (Pager, "builtin") == 0)
builtin = 1;
else
{
struct hdr_format_info hfi;
hfi.ctx = Context;
hfi.pager_progress = ExtPagerProgress;
hfi.hdr = cur;
mutt_make_string_info (buf, sizeof (buf), NONULL(PagerFmt), &hfi, M_FORMAT_MAKEPRINT);
fputs (buf, fpout);
fputs ("\n\n", fpout);
}
res = mutt_copy_message (fpout, Context, cur, cmflags,
(option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) | CH_DECODE | CH_FROM | CH_DISPLAY);
if ((safe_fclose (&fpout) != 0 && errno != EPIPE) || res < 0)
{
mutt_error (_("Could not copy message"));
if (fpfilterout != NULL)
{
mutt_wait_filter (filterpid);
safe_fclose (&fpfilterout);
}
mutt_unlink (tempfile);
return 0;
}
if (fpfilterout != NULL && mutt_wait_filter (filterpid) != 0)
mutt_any_key_to_continue (NULL);
safe_fclose (&fpfilterout); /* XXX - check result? */
if (WithCrypto)
{
/* update crypto information for this message */
cur->security &= ~(GOODSIGN|BADSIGN);
cur->security |= crypt_query (cur->content);
/* Remove color cache for this message, in case there
are color patterns for both ~g and ~V */
cur->pair = 0;
}
if (builtin)
{
pager_t info;
if (WithCrypto
&& (cur->security & APPLICATION_SMIME) && (cmflags & M_CM_VERIFY))
{
if (cur->security & GOODSIGN)
{
if (!crypt_smime_verify_sender(cur))
mutt_message ( _("S/MIME signature successfully verified."));
else
mutt_error ( _("S/MIME certificate owner does not match sender."));
}
else if (cur->security & PARTSIGN)
mutt_message (_("Warning: Part of this message has not been signed."));
else if (cur->security & SIGN || cur->security & BADSIGN)
mutt_error ( _("S/MIME signature could NOT be verified."));
}
if (WithCrypto
&& (cur->security & APPLICATION_PGP) && (cmflags & M_CM_VERIFY))
{
if (cur->security & GOODSIGN)
mutt_message (_("PGP signature successfully verified."));
else if (cur->security & PARTSIGN)
mutt_message (_("Warning: Part of this message has not been signed."));
else if (cur->security & SIGN)
mutt_message (_("PGP signature could NOT be verified."));
}
/* Invoke the builtin pager */
memset (&info, 0, sizeof (pager_t));
info.hdr = cur;
info.ctx = Context;
rc = mutt_pager (NULL, tempfile, M_PAGER_MESSAGE, &info);
}
else
{
int r;
mutt_endwin (NULL);
snprintf (buf, sizeof (buf), "%s %s", NONULL(Pager), tempfile);
if ((r = mutt_system (buf)) == -1)
mutt_error (_("Error running \"%s\"!"), buf);
unlink (tempfile);
if (!option (OPTNOCURSES))
keypad (stdscr, TRUE);
if (r != -1)
mutt_set_flag (Context, cur, M_READ, 1);
if (r != -1 && option (OPTPROMPTAFTER))
{
mutt_unget_event (mutt_any_key_to_continue _("Command: "), 0);
rc = km_dokey (MENU_PAGER);
}
else
rc = 0;
}
return rc;
}