NeoMutt  2021-10-29-43-g6b8931
Teaching an old dog new tricks
DOXYGEN
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 "menu/lib.h"
#include "ncrypt/lib.h"
#include "pager/lib.h"
#include "question/lib.h"
#include "context.h"
#include "copy.h"
#include "format_flags.h"
#include "hdrline.h"
#include "hook.h"
#include "keymap.h"
#include "mutt_globals.h"
#include "muttlib.h"
#include "mx.h"
#include "options.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 Mailbox *m, 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...
 
int mutt_display_message (struct MuttWindow *win_index, struct MuttWindow *win_pager, struct MuttWindow *win_pbar, struct Mailbox *m, struct Email *e)
 Display a message in the pager. More...
 

Variables

static const char * ExtPagerProgress = N_("all")
 

Detailed Description

Process a message for display in the pager.

Authors
  • Richard Russon

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
mMailbox
eEmail to update

Definition at line 67 of file message.c.

68 {
69  struct Envelope *prot_headers = NULL;
70  regmatch_t pmatch[1];
71 
72  const bool c_crypt_protected_headers_read =
73  cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_read");
74 #ifdef USE_AUTOCRYPT
75  const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
76  if (!c_crypt_protected_headers_read && !c_autocrypt)
77  return;
78 #else
79  if (!c_crypt_protected_headers_read)
80  return;
81 #endif
82 
83  /* Grab protected headers to update in the index */
84  if (e->security & SEC_SIGN)
85  {
86  /* Don't update on a bad signature.
87  *
88  * This is a simplification. It's possible the headers are in the
89  * encrypted part of a nested encrypt/signed. But properly handling that
90  * case would require more complexity in the decryption handlers, which
91  * I'm not sure is worth it. */
92  if (!(e->security & SEC_GOODSIGN))
93  return;
94 
95  if (mutt_is_multipart_signed(e->body) && e->body->parts)
96  {
97  prot_headers = e->body->parts->mime_headers;
98  }
100  {
101  prot_headers = e->body->mime_headers;
102  }
103  }
104  if (!prot_headers && (e->security & SEC_ENCRYPT))
105  {
106  if (((WithCrypto & APPLICATION_PGP) != 0) &&
109  {
110  prot_headers = e->body->mime_headers;
111  }
112  else if (((WithCrypto & APPLICATION_SMIME) != 0) && mutt_is_application_smime(e->body))
113  {
114  prot_headers = e->body->mime_headers;
115  }
116  }
117 
118  /* Update protected headers in the index and header cache. */
119  if (c_crypt_protected_headers_read && prot_headers && prot_headers->subject &&
120  !mutt_str_equal(e->env->subject, prot_headers->subject))
121  {
122  if (m->subj_hash && e->env->real_subj)
124 
125  mutt_str_replace(&e->env->subject, prot_headers->subject);
126  FREE(&e->env->disp_subj);
127  const struct Regex *c_reply_regex =
128  cs_subset_regex(NeoMutt->sub, "reply_regex");
129  if (mutt_regex_capture(c_reply_regex, e->env->subject, 1, pmatch))
130  {
131  e->env->real_subj = e->env->subject + pmatch[0].rm_eo;
132  if (e->env->real_subj[0] == '\0')
133  e->env->real_subj = NULL;
134  }
135  else
136  {
137  e->env->real_subj = e->env->subject;
138  }
139 
140  if (m->subj_hash)
142 
143  mx_save_hcache(m, e);
144 
145  /* Also persist back to the message headers if this is set */
146  const bool c_crypt_protected_headers_save =
147  cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_save");
148  if (c_crypt_protected_headers_save)
149  {
151  e->changed = true;
152  m->changed = true;
153  }
154  }
155 
156 #ifdef USE_AUTOCRYPT
157  if (c_autocrypt && (e->security & SEC_ENCRYPT) && prot_headers && prot_headers->autocrypt_gossip)
158  {
159  mutt_autocrypt_process_gossip_header(e, prot_headers);
160  }
161 #endif
162 }
int mutt_autocrypt_process_gossip_header(struct Email *e, struct Envelope *prot_headers)
Parse an Autocrypt email gossip header.
Definition: autocrypt.c:416
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:414
SecurityFlags mutt_is_application_smime(struct Body *b)
Does the message use S/MIME?
Definition: crypt.c:617
int mutt_is_valid_multipart_pgp_encrypted(struct Body *b)
Is this a valid multi-part encrypted message?
Definition: crypt.c:478
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted(struct Body *b)
Check for malformed layout.
Definition: crypt.c:515
#define MUTT_ENV_CHANGED_SUBJECT
Protected header update.
Definition: envelope.h:35
void mutt_hash_delete(struct HashTable *table, const char *strkey, const void *data)
Remove an element from a Hash Table.
Definition: hash.c:427
struct HashElem * mutt_hash_insert(struct HashTable *table, const char *strkey, void *data)
Add a new element to the Hash Table (with string keys)
Definition: hash.c:335
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
const struct Regex * cs_subset_regex(const struct ConfigSubset *sub, const char *name)
Get a regex config item by name.
Definition: helpers.c:243
#define FREE(x)
Definition: memory.h:40
bool mutt_regex_capture(const struct Regex *regex, const char *str, size_t nmatch, regmatch_t matches[])
Match a regex against a string, with provided options.
Definition: regex.c:610
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:715
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:257
int mx_save_hcache(struct Mailbox *m, struct Email *e)
Save message to the header cache - Wrapper for MxOps::msg_save_hcache()
Definition: mx.c:1820
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:77
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:87
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:88
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:75
#define WithCrypto
Definition: lib.h:113
#define SEC_SIGN
Email is signed.
Definition: lib.h:76
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:71
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:74
struct Envelope * env
Envelope information.
Definition: email.h:66
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:41
struct Body * body
List of MIME parts.
Definition: email.h:67
bool changed
Email has been edited.
Definition: email.h:75
The header of an Email.
Definition: envelope.h:55
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:90
struct AutocryptHeader * autocrypt_gossip
Autocrypt Gossip header.
Definition: envelope.h:88
char * subject
Email's subject.
Definition: envelope.h:68
char * real_subj
Offset of the real subject.
Definition: envelope.h:69
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:70
bool changed
Mailbox has been modified.
Definition: mailbox.h:114
struct HashTable * subj_hash
Hash Table by subject.
Definition: mailbox.h:128
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
Cached regular expression.
Definition: regex3.h:90
+ 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
msgRaw Email
tempfileTemporary filename for result
mMailbox
eEmail to display
headerHeader to prefix output (OPTIONAL)
wrap_lenWidth to wrap lines
cmflagsMessage flags, e.g. MUTT_CM_DECODE
Return values
0Success
-1Error
Note
Flags may be added to cmflags

Definition at line 178 of file message.c.

181 {
182  int rc = 0;
183  pid_t filterpid = -1;
184 
185  mutt_parse_mime_message(e, msg->fp);
187 
188  char columns[16];
189  // win_pager might not be visible and have a size yet, so use win_index
190  snprintf(columns, sizeof(columns), "%d", wrap_len);
191  mutt_envlist_set("COLUMNS", columns, true);
192 
193  /* see if crypto is needed for this message. if so, we should exit curses */
194  if ((WithCrypto != 0) && e->security)
195  {
196  if (e->security & SEC_ENCRYPT)
197  {
198  if (e->security & APPLICATION_SMIME)
201  goto cleanup;
202 
203  *cmflags |= MUTT_CM_VERIFY;
204  }
205  else if (e->security & SEC_SIGN)
206  {
207  /* find out whether or not the verify signature */
208  /* L10N: Used for the $crypt_verify_sig prompt */
209  const enum QuadOption c_crypt_verify_sig =
210  cs_subset_quad(NeoMutt->sub, "crypt_verify_sig");
211  if (query_quadoption(c_crypt_verify_sig, _("Verify signature?")) == MUTT_YES)
212  {
213  *cmflags |= MUTT_CM_VERIFY;
214  }
215  }
216  }
217 
218  if (*cmflags & MUTT_CM_VERIFY || e->security & SEC_ENCRYPT)
219  {
220  if (e->security & APPLICATION_PGP)
221  {
222  if (!TAILQ_EMPTY(&e->env->from))
224 
226  }
227 
228  if (e->security & APPLICATION_SMIME)
230  }
231 
232  FILE *fp_filter_out = NULL;
233  mutt_buffer_mktemp(tempfile);
234  FILE *fp_out = mutt_file_fopen(mutt_buffer_string(tempfile), "w");
235  if (!fp_out)
236  {
237  mutt_error(_("Could not create temporary file"));
238  goto cleanup;
239  }
240 
241  const char *const c_display_filter =
242  cs_subset_string(NeoMutt->sub, "display_filter");
243  if (c_display_filter)
244  {
245  fp_filter_out = fp_out;
246  fp_out = NULL;
247  filterpid = filter_create_fd(c_display_filter, &fp_out, NULL, NULL, -1,
248  fileno(fp_filter_out), -1);
249  if (filterpid < 0)
250  {
251  mutt_error(_("Can't create display filter"));
252  mutt_file_fclose(&fp_filter_out);
253  unlink(mutt_buffer_string(tempfile));
254  goto cleanup;
255  }
256  }
257 
258  if (header)
259  {
260  fputs(header, fp_out);
261  fputs("\n\n", fp_out);
262  }
263 
264  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
265  CopyHeaderFlags chflags = (c_weed ? (CH_WEED | CH_REORDER) : CH_NO_FLAGS) |
267 #ifdef USE_NOTMUCH
268  if (m->type == MUTT_NOTMUCH)
269  chflags |= CH_VIRTUAL;
270 #endif
271  int res = mutt_copy_message(fp_out, e, msg, *cmflags, chflags, wrap_len);
272 
273  if (((mutt_file_fclose(&fp_out) != 0) && (errno != EPIPE)) || (res < 0))
274  {
275  mutt_error(_("Could not copy message"));
276  if (fp_filter_out)
277  {
278  filter_wait(filterpid);
279  mutt_file_fclose(&fp_filter_out);
280  }
282  goto cleanup;
283  }
284 
285  if (fp_filter_out && (filter_wait(filterpid) != 0))
287 
288  mutt_file_fclose(&fp_filter_out); /* XXX - check result? */
289 
290  if (WithCrypto)
291  {
292  /* update crypto information for this message */
293  e->security &= ~(SEC_GOODSIGN | SEC_BADSIGN);
294  e->security |= crypt_query(e->body);
295 
296  /* Remove color cache for this message, in case there
297  * are color patterns for both ~g and ~V */
298  e->pair = 0;
299 
300  /* Process protected headers and autocrypt gossip headers */
302  }
303 
304 cleanup:
305  mutt_envlist_unset("COLUMNS");
306  return rc;
307 }
void mutt_parse_mime_message(struct Email *e, FILE *fp)
Parse a MIME email.
Definition: attachments.c:593
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
int mutt_copy_message(FILE *fp_out, struct Email *e, struct Message *msg, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
Definition: copy.c:881
#define CH_DECODE
Do RFC2047 header decoding.
Definition: copy.h:54
#define MUTT_CM_VERIFY
Do signature verification.
Definition: copy.h:47
#define CH_FROM
Retain the "From " message separator?
Definition: copy.h:56
#define CH_WEED
Weed the headers?
Definition: copy.h:53
#define CH_REORDER
Re-order output of headers (specified by 'hdr_order')
Definition: copy.h:59
#define CH_DISPLAY
Display result to user.
Definition: copy.h:70
uint32_t CopyHeaderFlags
Flags for mutt_copy_header(), e.g. CH_UPDATE.
Definition: copy.h:50
#define CH_VIRTUAL
Write virtual header lines too.
Definition: copy.h:73
#define CH_NO_FLAGS
No flags are set.
Definition: copy.h:51
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:135
SecurityFlags crypt_query(struct Body *b)
Check out the type of encryption used.
Definition: crypt.c:692
void crypt_invoke_message(SecurityFlags type)
Display an informative message.
Definition: cryptglue.c:158
void crypt_smime_getkeys(struct Envelope *env)
Wrapper for CryptModuleSpecs::smime_getkeys()
Definition: cryptglue.c:456
void crypt_pgp_invoke_getkeys(struct Address *addr)
Wrapper for CryptModuleSpecs::pgp_invoke_getkeys()
Definition: cryptglue.c:275
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:455
bool mutt_envlist_unset(const char *name)
Unset an environment variable.
Definition: envlist.c:132
bool mutt_envlist_set(const char *name, const char *value, bool overwrite)
Set an environment variable.
Definition: envlist.c:85
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:593
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:195
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition: filter.c:217
pid_t filter_create_fd(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, int fdin, int fdout, int fderr)
Run a command on a pipe (optionally connect stdin/stdout)
Definition: filter.c:61
#define mutt_error(...)
Definition: logging.h:87
enum QuadOption cs_subset_quad(const struct ConfigSubset *sub, const char *name)
Get a quad-value config item by name.
Definition: helpers.c:218
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:597
#define MUTT_MESSAGE_HOOK
message-hook: run before displaying a message
Definition: hook.h:45
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:54
#define _(a)
Definition: message.h:28
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:74
#define SEC_BADSIGN
Email has a bad signature.
Definition: lib.h:78
static void process_protected_headers(struct Mailbox *m, struct Email *e)
Get the protected header and update the index.
Definition: message.c:67
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: question.c:349
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_EMPTY(head)
Definition: queue.h:721
int pair
Color-pair to use when displaying in the index.
Definition: email.h:112
struct AddressList from
Email's 'From' list.
Definition: envelope.h:57
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
FILE * fp
pointer to the message data
Definition: mxapi.h:43
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ external_pager()

int external_pager ( struct Mailbox m,
struct Email e,
const char *  command 
)

Display a message in an external program.

Parameters
mMailbox
eEmail to display
commandExternal command to run
Return values
0Success
-1Error

Definition at line 317 of file message.c.

318 {
319  struct Message *msg = mx_msg_open(m, e->msgno);
320  if (!msg)
321  return -1;
322 
323  char buf[1024] = { 0 };
324  const char *const c_pager_format =
325  cs_subset_string(NeoMutt->sub, "pager_format");
326  const int screen_width = RootWindow->state.cols;
327  mutt_make_string(buf, sizeof(buf), screen_width, NONULL(c_pager_format), m,
328  Context ? Context->msg_in_pager : -1, e,
330 
331  struct Buffer *tempfile = mutt_buffer_pool_get();
332 
334  int rc = email_to_file(msg, tempfile, m, e, buf, screen_width, &cmflags);
335  if (rc < 0)
336  goto cleanup;
337 
338  mutt_endwin();
339 
340  struct Buffer *cmd = mutt_buffer_pool_get();
341  mutt_buffer_printf(cmd, "%s %s", command, mutt_buffer_string(tempfile));
342  int r = mutt_system(mutt_buffer_string(cmd));
343  if (r == -1)
344  mutt_error(_("Error running \"%s\""), mutt_buffer_string(cmd));
345  unlink(mutt_buffer_string(tempfile));
347 
348  if (!OptNoCurses)
349  keypad(stdscr, true);
350  if (r != -1)
351  mutt_set_flag(m, e, MUTT_READ, true);
352  const bool c_prompt_after = cs_subset_bool(NeoMutt->sub, "prompt_after");
353  if ((r != -1) && c_prompt_after)
354  {
355  mutt_unget_event(mutt_any_key_to_continue(_("Command: ")), 0);
356  rc = km_dokey(MENU_PAGER);
357  }
358  else
359  rc = 0;
360 
361 cleanup:
362  mx_msg_close(m, &msg);
363  mutt_buffer_pool_release(&tempfile);
364  return rc;
365 }
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
#define MUTT_CM_DECODE
Decode the message body into text/plain.
Definition: copy.h:38
#define MUTT_CM_CHARCONV
Perform character set conversions.
Definition: copy.h:42
uint16_t CopyMessageFlags
Flags for mutt_copy_message(), e.g. MUTT_CM_NOHEADER.
Definition: copy.h:32
#define MUTT_CM_DISPLAY
Output is displayed to the user.
Definition: copy.h:39
void mutt_unget_event(int ch, int op)
Return a keystroke to the input buffer.
Definition: curs_lib.c:588
void mutt_endwin(void)
Shutdown curses.
Definition: curs_lib.c:422
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
void mutt_make_string(char *buf, size_t buflen, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1410
int km_dokey(enum MenuType mtype)
Determine what a keypress should do.
Definition: keymap.c:627
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:92
int mx_msg_close(struct Mailbox *m, struct Message **msg)
Close a message.
Definition: mx.c:1191
struct Message * mx_msg_open(struct Mailbox *m, int msgno)
Return a stream pointer for a message.
Definition: mx.c:1145
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: options.h:53
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.
Definition: message.c:178
static const char * ExtPagerProgress
Definition: message.c:60
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:66
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:51
struct MuttWindow * RootWindow
Parent of all Windows.
Definition: rootwin.c:103
#define NONULL(x)
Definition: string2.h:37
String manipulation buffer.
Definition: buffer.h:34
The "current" mailbox.
Definition: context.h:38
int msg_in_pager
Message currently shown in the pager.
Definition: context.h:43
int msgno
Number displayed to the user.
Definition: email.h:111
A local copy of an email.
Definition: mxapi.h:42
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:54
+ 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
eEmail to display
msgRaw Email
cmflagsMessage flags, e.g. MUTT_CM_DECODE

Definition at line 373 of file message.c.

374 {
375  if ((WithCrypto != 0) && (e->security & APPLICATION_SMIME) && (cmflags & MUTT_CM_VERIFY))
376  {
377  if (e->security & SEC_GOODSIGN)
378  {
379  if (crypt_smime_verify_sender(e, msg) == 0)
380  mutt_message(_("S/MIME signature successfully verified"));
381  else
382  mutt_error(_("S/MIME certificate owner does not match sender"));
383  }
384  else if (e->security & SEC_PARTSIGN)
385  mutt_message(_("Warning: Part of this message has not been signed"));
386  else if (e->security & SEC_SIGN || e->security & SEC_BADSIGN)
387  mutt_error(_("S/MIME signature could NOT be verified"));
388  }
389 
390  if ((WithCrypto != 0) && (e->security & APPLICATION_PGP) && (cmflags & MUTT_CM_VERIFY))
391  {
392  if (e->security & SEC_GOODSIGN)
393  mutt_message(_("PGP signature successfully verified"));
394  else if (e->security & SEC_PARTSIGN)
395  mutt_message(_("Warning: Part of this message has not been signed"));
396  else if (e->security & SEC_SIGN)
397  mutt_message(_("PGP signature could NOT be verified"));
398  }
399 }
int crypt_smime_verify_sender(struct Email *e, struct Message *msg)
Wrapper for CryptModuleSpecs::smime_verify_sender()
Definition: cryptglue.c:465
#define mutt_message(...)
Definition: logging.h:86
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: lib.h:79
+ 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 MuttWindow win_pager,
struct MuttWindow win_pbar,
struct Mailbox m,
struct Email e 
)

Display a message in the pager.

Parameters
win_indexIndex Window
win_pagerPager Window
win_pbarPager Bar Window
mMailbox
eEmail to display
Return values
0Success
-1Error

Definition at line 411 of file message.c.

413 {
414  struct Message *msg = mx_msg_open(m, e->msgno);
415  if (!msg)
416  return -1;
417 
418  struct Buffer *tempfile = mutt_buffer_pool_get();
419 
421 
422  // win_pager might not be visible and have a size yet, so use win_index
423  int rc = email_to_file(msg, tempfile, m, e, NULL, win_index->state.cols, &cmflags);
424  if (rc < 0)
425  goto cleanup;
426 
427  notify_crypto(e, msg, cmflags);
428 
429  /* Invoke the builtin pager */
430  struct PagerData pdata = { 0 };
431  struct PagerView pview = { &pdata };
432 
433  pdata.fp = msg->fp;
434  pdata.fname = mutt_buffer_string(tempfile);
435 
436  pview.mode = PAGER_MODE_EMAIL;
437  pview.banner = NULL;
438  pview.flags = MUTT_PAGER_MESSAGE | (e->body->nowrap ? MUTT_PAGER_NOWRAP : 0);
439  pview.win_index = win_index;
440  pview.win_pbar = win_pbar;
441  pview.win_pager = win_pager;
442  rc = mutt_pager(&pview);
443 
444 cleanup:
445  mx_msg_close(m, &msg);
446  mutt_buffer_pool_release(&tempfile);
447  return rc;
448 }
int mutt_pager(struct PagerView *pview)
Display an email, attachment, or help, in a window.
Definition: dlg_pager.c:465
#define MUTT_PAGER_NOWRAP
Format for term width, ignore $wrap.
Definition: lib.h:72
@ PAGER_MODE_EMAIL
Pager is invoked via 1st path. The mime part is selected automatically.
Definition: lib.h:136
#define MUTT_PAGER_MESSAGE
Definition: lib.h:75
static void notify_crypto(struct Email *e, struct Message *msg, CopyMessageFlags cmflags)
Notify the user about the crypto status of the Email.
Definition: message.c:373
bool nowrap
Do not wrap the output in the pager.
Definition: body.h:88
Data to be displayed by PagerView.
Definition: lib.h:149
const char * fname
Name of the file to read.
Definition: lib.h:153
FILE * fp
Source stream.
Definition: lib.h:151
Paged view into some data.
Definition: lib.h:160
struct MuttWindow * win_index
Index Window.
Definition: lib.h:166
struct PagerData * pdata
Data that pager displays. NOTNULL.
Definition: lib.h:161
enum PagerMode mode
Pager mode.
Definition: lib.h:162
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:163
const char * banner
Title to display in status bar.
Definition: lib.h:164
struct MuttWindow * win_pbar
Pager Bar Window.
Definition: lib.h:167
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:168
+ 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

Definition at line 60 of file message.c.