/** * execute_command - Run a system command * @param m Mailbox to work with * @param command Command string to execute * @param progress Message to show the user * @retval 1 Success * @retval 0 Failure * * Run the supplied command, taking care of all the NeoMutt requirements, * such as locking files and blocking signals. */ static int execute_command(struct Mailbox *m, const char *command, const char *progress) { int rc = 1; char sys_cmd[STR_COMMAND]; if (!m || !command || !progress) return 0; if (!m->quiet) { mutt_message(progress, m->realpath); } mutt_sig_block(); endwin(); fflush(stdout); expand_command_str(m, command, sys_cmd, sizeof(sys_cmd)); if (mutt_system(sys_cmd) != 0) { rc = 0; mutt_any_key_to_continue(NULL); mutt_error(_("Error running \"%s\""), sys_cmd); } mutt_sig_unblock(); return rc; }
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; }
/* return 0 on success, -1 on failure */ int mutt_sync_compressed (CONTEXT * ctx) { char *cmd; int rc = 0; FILE *fp; COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo; if (!ctx->quiet) mutt_message (_("Compressing %s..."), ctx->realpath); cmd = get_compression_cmd (ci->close, ctx); if (cmd == NULL) return (-1); if ((fp = fopen (ctx->realpath, "a")) == NULL) { mutt_perror (ctx->realpath); mem_free (&cmd); return (-1); } mutt_block_signals (); if (mbox_lock_compressed (ctx, fp, 1, 1) == -1) { fclose (fp); mutt_unblock_signals (); mutt_error _("Unable to lock mailbox!"); store_size (ctx); mem_free (&cmd); return (-1); } debug_print (2, ("CompressCommand: '%s'\n", cmd)); endwin (); fflush (stdout); sprintf (echo_cmd, _("echo Compressing %s..."), ctx->realpath); mutt_system (echo_cmd); if (mutt_system (cmd)) { mutt_any_key_to_continue (NULL); mutt_error (_ ("%s: Error compressing mailbox! Original mailbox deleted, uncompressed one kept!\n"), ctx->path); rc = -1; } mbox_unlock_compressed (ctx, fp); mutt_unblock_signals (); fclose (fp); mem_free (&cmd); store_size (ctx); return (rc); }
/** * crypt_init - Initialise the crypto backends * * This calls CryptModuleSpecs::init() */ void crypt_init(void) { #ifdef CRYPT_BACKEND_CLASSIC_PGP if ( #ifdef CRYPT_BACKEND_GPGME (!C_CryptUseGpgme) #else 1 #endif ) crypto_module_register(&CryptModPgpClassic); #endif #ifdef CRYPT_BACKEND_CLASSIC_SMIME if ( #ifdef CRYPT_BACKEND_GPGME (!C_CryptUseGpgme) #else 1 #endif ) crypto_module_register(&CryptModSmimeClassic); #endif if (C_CryptUseGpgme) { #ifdef CRYPT_BACKEND_GPGME crypto_module_register(&CryptModPgpGpgme); crypto_module_register(&CryptModSmimeGpgme); #else mutt_message(_("\"crypt_use_gpgme\" set" " but not built with GPGME support")); if (mutt_any_key_to_continue(NULL) == -1) mutt_exit(1); #endif } #if defined(CRYPT_BACKEND_CLASSIC_PGP) || \ defined(CRYPT_BACKEND_CLASSIC_SMIME) || defined(CRYPT_BACKEND_GPGME) if (CRYPT_MOD_CALL_CHECK(PGP, init)) CRYPT_MOD_CALL(PGP, init)(); if (CRYPT_MOD_CALL_CHECK(SMIME, init)) CRYPT_MOD_CALL(SMIME, init)(); #endif }
/* 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); } } }
void crypt_init (void) { #ifdef CRYPT_BACKEND_CLASSIC_PGP if ( #ifdef CRYPT_BACKEND_GPGME (! option (OPTCRYPTUSEGPGME)) #else 1 #endif ) crypto_module_register (&crypt_mod_pgp_classic); #endif #ifdef CRYPT_BACKEND_CLASSIC_SMIME if ( #ifdef CRYPT_BACKEND_GPGME (! option (OPTCRYPTUSEGPGME)) #else 1 #endif ) crypto_module_register (&crypt_mod_smime_classic); #endif if (option (OPTCRYPTUSEGPGME)) { #ifdef CRYPT_BACKEND_GPGME crypto_module_register (&crypt_mod_pgp_gpgme); crypto_module_register (&crypt_mod_smime_gpgme); #else mutt_message (_("\"crypt_use_gpgme\" set" " but not built with GPGME support.")); if (mutt_any_key_to_continue (NULL) == -1) mutt_exit(1); #endif } #if defined CRYPT_BACKEND_CLASSIC_PGP || defined CRYPT_BACKEND_CLASSIC_SMIME || defined CRYPT_BACKEND_GPGME if (CRYPT_MOD_CALL_CHECK (PGP, init)) (CRYPT_MOD_CALL (PGP, init)) (); if (CRYPT_MOD_CALL_CHECK (SMIME, init)) (CRYPT_MOD_CALL (SMIME, init)) (); #endif }
int mutt_slow_close_compressed (CONTEXT * ctx) { FILE *fp; const char *append; char *cmd; COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo; debug_print (2, ("called on '%s'\n", ctx->path)); if (!(ctx->append && ((append = get_append_command (ctx->realpath, ctx)) || (append = ci->close)))) { /* if we can not or should not append, * we only have to remove the compressed info, because sync was already * called */ mutt_fast_close_compressed (ctx); return (0); } if (ctx->fp) fclose (ctx->fp); ctx->fp = NULL; if (!ctx->quiet) { if (append == ci->close) mutt_message (_("Compressing %s..."), ctx->realpath); else mutt_message (_("Compressed-appending to %s..."), ctx->realpath); } cmd = get_compression_cmd (append, ctx); if (cmd == NULL) return (-1); if ((fp = fopen (ctx->realpath, "a")) == NULL) { mutt_perror (ctx->realpath); mem_free (&cmd); return (-1); } mutt_block_signals (); if (mbox_lock_compressed (ctx, fp, 1, 1) == -1) { fclose (fp); mutt_unblock_signals (); mutt_error _("Unable to lock mailbox!"); mem_free (&cmd); return (-1); } debug_print (2, ("CompressCmd: '%s'\n", cmd)); endwin (); fflush (stdout); if (append == ci->close) sprintf (echo_cmd, _("echo Compressing %s..."), ctx->realpath); else sprintf (echo_cmd, _("echo Compressed-appending to %s..."), ctx->realpath); mutt_system (echo_cmd); if (mutt_system (cmd)) { mutt_any_key_to_continue (NULL); mutt_error (_ (" %s: Error compressing mailbox! Uncompressed one kept!\n"), ctx->path); mem_free (&cmd); mbox_unlock_compressed (ctx, fp); mutt_unblock_signals (); fclose (fp); return (-1); } mbox_unlock_compressed (ctx, fp); mutt_unblock_signals (); fclose (fp); remove_file (ctx); restore_path (ctx); mem_free (&cmd); mem_free (&ctx->compressinfo); return (0); }
int mutt_open_read_compressed (CONTEXT * ctx) { char *cmd; FILE *fp; int rc; COMPRESS_INFO *ci = set_compress_info (ctx); if (!ci->open) { ctx->magic = 0; mem_free (ctx->compressinfo); return (-1); } if (!ci->close || access (ctx->path, W_OK) != 0) ctx->readonly = 1; set_path (ctx); store_size (ctx); if (!ctx->quiet) mutt_message (_("Decompressing %s..."), ctx->realpath); cmd = get_compression_cmd (ci->open, ctx); if (cmd == NULL) return (-1); debug_print (2, ("DecompressCmd: '%s'\n", cmd)); if ((fp = fopen (ctx->realpath, "r")) == NULL) { mutt_perror (ctx->realpath); mem_free (&cmd); return (-1); } mutt_block_signals (); if (mbox_lock_compressed (ctx, fp, 0, 1) == -1) { fclose (fp); mutt_unblock_signals (); mutt_error _("Unable to lock mailbox!"); mem_free (&cmd); return (-1); } endwin (); fflush (stdout); sprintf (echo_cmd, _("echo Decompressing %s..."), ctx->realpath); mutt_system (echo_cmd); rc = mutt_system (cmd); mbox_unlock_compressed (ctx, fp); mutt_unblock_signals (); fclose (fp); if (rc) { mutt_any_key_to_continue (NULL); ctx->magic = 0; mem_free (ctx->compressinfo); mutt_error (_("Error executing: %s : unable to open the mailbox!\n"), cmd); } mem_free (&cmd); if (rc) return (-1); if (mutt_check_mailbox_compressed (ctx)) return (-1); ctx->magic = mx_get_magic (ctx->path); return (0); }
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; } }
/* 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; }
/** * comp_mbox_close - Implements MxOps::mbox_close() * * If the mailbox has been changed then re-compress the tmp file. * Then delete the tmp file. */ static int comp_mbox_close(struct Mailbox *m) { if (!m || !m->compress_info) return -1; struct CompressInfo *ci = m->compress_info; const struct MxOps *ops = ci->child_ops; if (!ops) { free_compress_info(m); return -1; } ops->mbox_close(m); /* sync has already been called, so we only need to delete some files */ if (m->append) { const char *append = NULL; const char *msg = NULL; /* The file exists and we can append */ if ((access(m->realpath, F_OK) == 0) && ci->cmd_append) { append = ci->cmd_append; msg = _("Compressed-appending to %s..."); } else { append = ci->cmd_close; msg = _("Compressing %s..."); } int rc = execute_command(m, append, msg); if (rc == 0) { mutt_any_key_to_continue(NULL); mutt_error(_("Error. Preserving temporary file: %s"), m->path); } else remove(m->path); unlock_realpath(m); } else { /* If the file was removed, remove the compressed folder too */ if ((access(m->path, F_OK) != 0) && !C_SaveEmpty) { remove(m->realpath); } else { remove(m->path); } } free_compress_info(m); 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; }
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; }