static int include_reply (CONTEXT *ctx, HEADER *cur, FILE *out)
{
int cmflags = M_CM_PREFIX | M_CM_DECODE | M_CM_CHARCONV | M_CM_REPLYING;
int chflags = CH_DECODE;
if (WithCrypto && (cur->security & ENCRYPT))
{
/* make sure we have the user's passphrase before proceeding... */
crypt_valid_passphrase (cur->security);
}
mutt_parse_mime_message (ctx, cur);
mutt_message_hook (ctx, cur, M_MESSAGEHOOK);
mutt_make_attribution (ctx, cur, out);
if (!option (OPTHEADER))
cmflags |= M_CM_NOHEADER;
if (option (OPTWEED))
{
chflags |= CH_WEED | CH_REORDER;
cmflags |= M_CM_WEED;
}
mutt_copy_message (out, ctx, cur, cmflags, chflags);
mutt_make_post_indent (ctx, cur, out);
return 0;
}
static int include_forward (CONTEXT *ctx, HEADER *cur, FILE *out)
{
int chflags = CH_DECODE, cmflags = 0;
mutt_parse_mime_message (ctx, cur);
mutt_message_hook (ctx, cur, M_MESSAGEHOOK);
if (WithCrypto && (cur->security & ENCRYPT) && option (OPTFORWDECODE))
{
/* make sure we have the user's passphrase before proceeding... */
crypt_valid_passphrase (cur->security);
}
mutt_forward_intro (out, cur);
if (option (OPTFORWDECODE))
{
cmflags |= M_CM_DECODE | M_CM_CHARCONV;
if (option (OPTWEED))
{
chflags |= CH_WEED | CH_REORDER;
cmflags |= M_CM_WEED;
}
}
if (option (OPTFORWQUOTE))
cmflags |= M_CM_PREFIX;
/* wrapping headers for forwarding is considered a display
* rather than send action */
chflags |= CH_DISPLAY;
mutt_copy_message (out, ctx, cur, cmflags, chflags);
mutt_forward_trailer (out);
return 0;
}
static void pipe_msg (HEADER *h, FILE *fp, int decode, int print)
{
int cmflags = 0;
int chflags = CH_FROM;
pipe_set_flags (decode, print, &cmflags, &chflags);
if (WithCrypto && decode && h->security & ENCRYPT) {
if(!crypt_valid_passphrase(h->security))
return;
endwin ();
}
if (decode)
mutt_parse_mime_message (Context, h);
mutt_copy_message (fp, Context, h, cmflags, chflags);
}
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;
}
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;
}