message.c File Reference

Process a message for display in the pager. More...

#include "config.h"
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "attach/lib.h"
#include "index/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "pager/lib.h"
#include "question/lib.h"
#include "copy.h"
#include "format_flags.h"
#include "globals.h"
#include "hdrline.h"
#include "hook.h"
#include "keymap.h"
#include "mview.h"
#include "mx.h"
#include "protos.h"
#include "autocrypt/lib.h"

Include dependency graph for message.c:

Go to the source code of this file.

Functions
static void	process_protected_headers (struct Mailbox *m, struct Email *e)
	Get the protected header and update the index. More...
static int	email_to_file (struct Message *msg, struct Buffer *tempfile, struct Mailbox *m, struct Email *e, const char *header, int wrap_len, CopyMessageFlags *cmflags)
	Decrypt, decode and weed an Email into a file. More...
int	external_pager (struct MailboxView *mv, struct Email *e, const char *command)
	Display a message in an external program. More...
static void	notify_crypto (struct Email *e, struct Message *msg, CopyMessageFlags cmflags)
	Notify the user about the crypto status of the Email. More...
static void	squash_index_panel (struct Mailbox *m, struct MuttWindow *win_index, struct MuttWindow *win_pager)
	Shrink or hide the Index Panel. More...
static void	expand_index_panel (struct MuttWindow *win_index, struct MuttWindow *win_pager)
	Restore the Index Panel. More...
int	mutt_display_message (struct MuttWindow *win_index, struct IndexSharedData *shared)
	Display a message in the pager. More...

Variables
static const char *	ExtPagerProgress = N_("all")
	Status bar message when entire message is visible in the Pager. More...

Detailed Description

Process a message for display in the pager.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file message.c.

Function Documentation

process_protected_headers()

static void process_protected_headers ( struct Mailbox *  m, struct Email *  e  )

static

Get the protected header and update the index.

Parameters

m	Mailbox
e	Email to update

Definition at line 67 of file message.c.

{
  struct Envelope *prot_headers = NULL;
  regmatch_t pmatch[1];
 
  const bool c_crypt_protected_headers_read = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_read");
#ifdef USE_AUTOCRYPT
  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
  if (!c_crypt_protected_headers_read && !c_autocrypt)
    return;
#else
  if (!c_crypt_protected_headers_read)
    return;
#endif
 
  /* Grab protected headers to update in the index */
  if (e->security & SEC_SIGN)
  {
    /* Don't update on a bad signature.
     *
     * This is a simplification.  It's possible the headers are in the
     * encrypted part of a nested encrypt/signed.  But properly handling that
     * case would require more complexity in the decryption handlers, which
     * I'm not sure is worth it. */
    if (!(e->security & SEC_GOODSIGN))
      return;
 
    if (mutt_is_multipart_signed(e->body) && e->body->parts)
    {
      prot_headers = e->body->parts->mime_headers;
    }
    else if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(e->body))
    {
      prot_headers = e->body->mime_headers;
    }
  }
  if (!prot_headers && (e->security & SEC_ENCRYPT))
  {
    if (((WithCrypto & APPLICATION_PGP) != 0) &&
        (mutt_is_valid_multipart_pgp_encrypted(e->body) ||
         mutt_is_malformed_multipart_pgp_encrypted(e->body)))
    {
      prot_headers = e->body->mime_headers;
    }
    else if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(e->body))
    {
      prot_headers = e->body->mime_headers;
    }
  }
 
  /* Update protected headers in the index and header cache. */
  if (c_crypt_protected_headers_read && prot_headers && prot_headers->subject &&
      !mutt_str_equal(e->env->subject, prot_headers->subject))
  {
    if (m->subj_hash && e->env->real_subj)
      mutt_hash_delete(m->subj_hash, e->env->real_subj, e);
 
    mutt_str_replace(&e->env->subject, prot_headers->subject);
    FREE(&e->env->disp_subj);
    const struct Regex *c_reply_regex = cs_subset_regex(NeoMutt->sub, "reply_regex");
    if (mutt_regex_capture(c_reply_regex, e->env->subject, 1, pmatch))
    {
      e->env->real_subj = e->env->subject + pmatch[0].rm_eo;
      if (e->env->real_subj[0] == '\0')
        e->env->real_subj = NULL;
    }
    else
    {
      e->env->real_subj = e->env->subject;
    }
 
    if (m->subj_hash)
      mutt_hash_insert(m->subj_hash, e->env->real_subj, e);
 
    mx_save_hcache(m, e);
 
    /* Also persist back to the message headers if this is set */
    const bool c_crypt_protected_headers_save = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_save");
    if (c_crypt_protected_headers_save)
    {
      e->env->changed |= MUTT_ENV_CHANGED_SUBJECT;
      e->changed = true;
      m->changed = true;
    }
  }
 
#ifdef USE_AUTOCRYPT
  if (c_autocrypt && (e->security & SEC_ENCRYPT) && prot_headers && prot_headers->autocrypt_gossip)
  {
    mutt_autocrypt_process_gossip_header(e, prot_headers);
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

email_to_file()

static int email_to_file ( struct Message *  msg, struct Buffer *  tempfile, struct Mailbox *  m, struct Email *  e, const char *  header, int  wrap_len, CopyMessageFlags *  cmflags  )

static

Decrypt, decode and weed an Email into a file.

Parameters

msg	Raw Email
tempfile	Temporary filename for result
m	Mailbox
e	Email to display
header	Header to prefix output (OPTIONAL)
wrap_len	Width to wrap lines
cmflags	Message flags, e.g. MUTT_CM_DECODE

Return values

0	Success
-1	Error

Note

Flags may be added to cmflags

Definition at line 175 of file message.c.

{
  int rc = 0;
  pid_t filterpid = -1;
 
  mutt_parse_mime_message(e, msg->fp);
  mutt_message_hook(m, e, MUTT_MESSAGE_HOOK);
 
  char columns[16] = { 0 };
  // win_pager might not be visible and have a size yet, so use win_index
  snprintf(columns, sizeof(columns), "%d", wrap_len);
  envlist_set(&EnvList, "COLUMNS", columns, true);
 
  /* see if crypto is needed for this message.  if so, we should exit curses */
  if ((WithCrypto != 0) && e->security)
  {
    if (e->security & SEC_ENCRYPT)
    {
      if (e->security & APPLICATION_SMIME)
        crypt_smime_getkeys(e->env);
      if (!crypt_valid_passphrase(e->security))
        goto cleanup;
 
      *cmflags |= MUTT_CM_VERIFY;
    }
    else if (e->security & SEC_SIGN)
    {
      /* find out whether or not the verify signature */
      /* L10N: Used for the $crypt_verify_sig prompt */
      const enum QuadOption c_crypt_verify_sig = cs_subset_quad(NeoMutt->sub, "crypt_verify_sig");
      if (query_quadoption(c_crypt_verify_sig, _("Verify signature?")) == MUTT_YES)
      {
        *cmflags |= MUTT_CM_VERIFY;
      }
    }
  }
 
  if (*cmflags & MUTT_CM_VERIFY || e->security & SEC_ENCRYPT)
  {
    if (e->security & APPLICATION_PGP)
    {
      if (!TAILQ_EMPTY(&e->env->from))
        crypt_pgp_invoke_getkeys(TAILQ_FIRST(&e->env->from));
 
      crypt_invoke_message(APPLICATION_PGP);
    }
 
    if (e->security & APPLICATION_SMIME)
      crypt_invoke_message(APPLICATION_SMIME);
  }
 
  FILE *fp_filter_out = NULL;
  buf_mktemp(tempfile);
  FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_out)
  {
    mutt_error(_("Could not create temporary file"));
    goto cleanup;
  }
 
  const char *const c_display_filter = cs_subset_string(NeoMutt->sub, "display_filter");
  if (c_display_filter)
  {
    fp_filter_out = fp_out;
    fp_out = NULL;
    filterpid = filter_create_fd(c_display_filter, &fp_out, NULL, NULL, -1,
                                 fileno(fp_filter_out), -1);
    if (filterpid < 0)
    {
      mutt_error(_("Can't create display filter"));
      mutt_file_fclose(&fp_filter_out);
      unlink(buf_string(tempfile));
      goto cleanup;
    }
  }
 
  if (header)
  {
    fputs(header, fp_out);
    fputs("\n\n", fp_out);
  }
 
  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
  CopyHeaderFlags chflags = (c_weed ? (CH_WEED | CH_REORDER) : CH_NO_FLAGS) |
                            CH_DECODE | CH_FROM | CH_DISPLAY;
#ifdef USE_NOTMUCH
  if (m->type == MUTT_NOTMUCH)
    chflags |= CH_VIRTUAL;
#endif
  rc = mutt_copy_message(fp_out, e, msg, *cmflags, chflags, wrap_len);
 
  if (((mutt_file_fclose(&fp_out) != 0) && (errno != EPIPE)) || (rc < 0))
  {
    mutt_error(_("Could not copy message"));
    if (fp_filter_out)
    {
      filter_wait(filterpid);
      mutt_file_fclose(&fp_filter_out);
    }
    mutt_file_unlink(buf_string(tempfile));
    goto cleanup;
  }
 
  if (fp_filter_out && (filter_wait(filterpid) != 0))
    mutt_any_key_to_continue(NULL);
 
  mutt_file_fclose(&fp_filter_out); /* XXX - check result? */
 
  if (WithCrypto)
  {
    /* update crypto information for this message */
    e->security &= ~(SEC_GOODSIGN | SEC_BADSIGN);
    e->security |= crypt_query(e->body);
 
    /* Remove color cache for this message, in case there
     * are color patterns for both ~g and ~V */
    e->attr_color = NULL;
 
    /* Process protected headers and autocrypt gossip headers */
    process_protected_headers(m, e);
  }
 
cleanup:
  envlist_unset(&EnvList, "COLUMNS");
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

external_pager()

int external_pager	(	struct MailboxView *	mv,
		struct Email *	e,
		const char *	command
	)

Display a message in an external program.

Parameters

mv	Mailbox view
e	Email to display
command	External command to run

Return values

0	Success
-1	Error

Definition at line 312 of file message.c.

{
  if (!mv || !mv->mailbox)
    return -1;
 
  struct Mailbox *m = mv->mailbox;
  struct Message *msg = mx_msg_open(m, e);
  if (!msg)
    return -1;
 
  char buf[1024] = { 0 };
  const char *const c_pager_format = cs_subset_string(NeoMutt->sub, "pager_format");
  const int screen_width = RootWindow->state.cols;
  mutt_make_string(buf, sizeof(buf), screen_width, NONULL(c_pager_format), m,
                   -1, e, MUTT_FORMAT_NO_FLAGS, _(ExtPagerProgress));
 
  struct Buffer *tempfile = buf_pool_get();
 
  CopyMessageFlags cmflags = MUTT_CM_DECODE | MUTT_CM_DISPLAY | MUTT_CM_CHARCONV;
  int rc = email_to_file(msg, tempfile, m, e, buf, screen_width, &cmflags);
  if (rc < 0)
    goto cleanup;
 
  mutt_endwin();
 
  struct Buffer *cmd = buf_pool_get();
  buf_printf(cmd, "%s %s", command, buf_string(tempfile));
  int r = mutt_system(buf_string(cmd));
  if (r == -1)
    mutt_error(_("Error running \"%s\""), buf_string(cmd));
  unlink(buf_string(tempfile));
  buf_pool_release(&cmd);
 
  if (!OptNoCurses)
    keypad(stdscr, true);
  if (r != -1)
    mutt_set_flag(m, e, MUTT_READ, true, true);
  const bool c_prompt_after = cs_subset_bool(NeoMutt->sub, "prompt_after");
  if ((r != -1) && c_prompt_after)
  {
    mutt_unget_ch(mutt_any_key_to_continue(_("Command: ")));
    rc = km_dokey(MENU_PAGER);
  }
  else
  {
    rc = 0;
  }
 
cleanup:
  mx_msg_close(m, &msg);
  buf_pool_release(&tempfile);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

notify_crypto()

static void notify_crypto ( struct Email *  e, struct Message *  msg, CopyMessageFlags  cmflags  )

static

Notify the user about the crypto status of the Email.

Parameters

e	Email to display
msg	Raw Email
cmflags	Message flags, e.g. MUTT_CM_DECODE

Definition at line 372 of file message.c.

{
  if ((WithCrypto != 0) && (e->security & APPLICATION_SMIME) && (cmflags & MUTT_CM_VERIFY))
  {
    if (e->security & SEC_GOODSIGN)
    {
      if (crypt_smime_verify_sender(e, msg) == 0)
        mutt_message(_("S/MIME signature successfully verified"));
      else
        mutt_error(_("S/MIME certificate owner does not match sender"));
    }
    else if (e->security & SEC_PARTSIGN)
    {
      mutt_message(_("Warning: Part of this message has not been signed"));
    }
    else if (e->security & SEC_SIGN || e->security & SEC_BADSIGN)
    {
      mutt_error(_("S/MIME signature could NOT be verified"));
    }
  }
 
  if ((WithCrypto != 0) && (e->security & APPLICATION_PGP) && (cmflags & MUTT_CM_VERIFY))
  {
    if (e->security & SEC_GOODSIGN)
      mutt_message(_("PGP signature successfully verified"));
    else if (e->security & SEC_PARTSIGN)
      mutt_message(_("Warning: Part of this message has not been signed"));
    else if (e->security & SEC_SIGN)
      mutt_message(_("PGP signature could NOT be verified"));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

squash_index_panel()

static void squash_index_panel ( struct Mailbox *  m, struct MuttWindow *  win_index, struct MuttWindow *  win_pager  )

static

Shrink or hide the Index Panel.

Parameters

m	Mailbox
win_index	Index Window
win_pager	Pager Window

Definition at line 410 of file message.c.

{
  const short c_pager_index_lines = cs_subset_number(NeoMutt->sub, "pager_index_lines");
  if (c_pager_index_lines > 0)
  {
    win_index->size = MUTT_WIN_SIZE_FIXED;
    win_index->req_rows = c_pager_index_lines;
    win_index->parent->size = MUTT_WIN_SIZE_MINIMISE;
  }
  window_set_visible(win_index->parent, (c_pager_index_lines > 0));
 
  window_set_visible(win_pager->parent, true);
 
  struct MuttWindow *dlg = dialog_find(win_index);
  mutt_window_reflow(dlg);
 
  // Force the menu to reframe itself
  struct Menu *menu = win_index->wdata;
  menu_set_index(menu, menu_get_index(menu));
}

Here is the call graph for this function:

Here is the caller graph for this function:

expand_index_panel()

static void expand_index_panel ( struct MuttWindow *  win_index, struct MuttWindow *  win_pager  )

static

Restore the Index Panel.

Parameters

win_index	Index Window
win_pager	Pager Window

Definition at line 437 of file message.c.

{
  win_index->size = MUTT_WIN_SIZE_MAXIMISE;
  win_index->req_rows = MUTT_WIN_SIZE_UNLIMITED;
  win_index->parent->size = MUTT_WIN_SIZE_MAXIMISE;
  win_index->parent->req_rows = MUTT_WIN_SIZE_UNLIMITED;
  window_set_visible(win_index->parent, true);
 
  window_set_visible(win_pager->parent, false);
 
  struct MuttWindow *dlg = dialog_find(win_index);
  mutt_window_reflow(dlg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_display_message()

int mutt_display_message	(	struct MuttWindow *	win_index,
		struct IndexSharedData *	shared
	)

Display a message in the pager.

Parameters

win_index	Index Window
shared	Shared Index data

Return values

0	Success
-1	Error

Definition at line 458 of file message.c.

{
  struct MuttWindow *dlg = dialog_find(win_index);
  struct MuttWindow *win_pager = window_find_child(dlg, WT_CUSTOM);
  struct MuttWindow *win_pbar = window_find_child(dlg, WT_STATUS_BAR);
  struct Buffer *tempfile = buf_pool_get();
  struct Message *msg = NULL;
 
  squash_index_panel(shared->mailbox, win_index, win_pager);
 
  int rc = PAGER_LOOP_QUIT;
  do
  {
    msg = mx_msg_open(shared->mailbox, shared->email);
    if (!msg)
      break;
 
    CopyMessageFlags cmflags = MUTT_CM_DECODE | MUTT_CM_DISPLAY | MUTT_CM_CHARCONV;
 
    buf_reset(tempfile);
    // win_pager might not be visible and have a size yet, so use win_index
    rc = email_to_file(msg, tempfile, shared->mailbox, shared->email, NULL,
                       win_index->state.cols, &cmflags);
    if (rc < 0)
      break;
 
    notify_crypto(shared->email, msg, cmflags);
 
    /* Invoke the builtin pager */
    struct PagerData pdata = { 0 };
    struct PagerView pview = { &pdata };
 
    pdata.fp = msg->fp;
    pdata.fname = buf_string(tempfile);
 
    pview.mode = PAGER_MODE_EMAIL;
    pview.banner = NULL;
    pview.flags = MUTT_PAGER_MESSAGE |
                  (shared->email->body->nowrap ? MUTT_PAGER_NOWRAP : 0);
    pview.win_index = win_index;
    pview.win_pbar = win_pbar;
    pview.win_pager = win_pager;
 
    rc = mutt_pager(&pview);
    mx_msg_close(shared->mailbox, &msg);
  } while (rc == PAGER_LOOP_RELOAD);
 
  expand_index_panel(win_index, win_pager);
 
  mx_msg_close(shared->mailbox, &msg);
  buf_pool_release(&tempfile);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ExtPagerProgress

const char* ExtPagerProgress = N_("all")

static

Status bar message when entire message is visible in the Pager.

Definition at line 60 of file message.c.