NeoMutt  2022-04-29-249-gaae397
Teaching an old dog new tricks
Go to the documentation of this file.
29#include "config.h"
30#include <errno.h>
31#include <stdbool.h>
32#include <stdio.h>
33#include <unistd.h>
34#include "mutt/lib.h"
35#include "config/lib.h"
36#include "email/lib.h"
37#include "core/lib.h"
38#include "gui/lib.h"
39#include "mutt.h"
40#include "attach/lib.h"
41#include "index/lib.h"
42#include "menu/lib.h"
43#include "ncrypt/lib.h"
44#include "pager/lib.h"
45#include "question/lib.h"
46#include "copy.h"
47#include "format_flags.h"
48#include "hdrline.h"
49#include "hook.h"
50#include "keymap.h"
51#include "muttlib.h"
52#include "mx.h"
53#include "options.h"
54#include "protos.h"
56#include "autocrypt/lib.h"
59static const char *ExtPagerProgress = N_("all");
66static void process_protected_headers(struct Mailbox *m, struct Email *e)
68 struct Envelope *prot_headers = NULL;
69 regmatch_t pmatch[1];
71 const bool c_crypt_protected_headers_read = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_read");
73 const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
74 if (!c_crypt_protected_headers_read && !c_autocrypt)
75 return;
77 if (!c_crypt_protected_headers_read)
78 return;
81 /* Grab protected headers to update in the index */
82 if (e->security & SEC_SIGN)
83 {
84 /* Don't update on a bad signature.
85 *
86 * This is a simplification. It's possible the headers are in the
87 * encrypted part of a nested encrypt/signed. But properly handling that
88 * case would require more complexity in the decryption handlers, which
89 * I'm not sure is worth it. */
90 if (!(e->security & SEC_GOODSIGN))
91 return;
94 {
95 prot_headers = e->body->parts->mime_headers;
96 }
98 {
99 prot_headers = e->body->mime_headers;
100 }
101 }
102 if (!prot_headers && (e->security & SEC_ENCRYPT))
103 {
104 if (((WithCrypto & APPLICATION_PGP) != 0) &&
107 {
108 prot_headers = e->body->mime_headers;
109 }
111 {
112 prot_headers = e->body->mime_headers;
113 }
114 }
116 /* Update protected headers in the index and header cache. */
117 if (c_crypt_protected_headers_read && prot_headers && prot_headers->subject &&
118 !mutt_str_equal(e->env->subject, prot_headers->subject))
119 {
120 if (m->subj_hash && e->env->real_subj)
123 mutt_str_replace(&e->env->subject, prot_headers->subject);
124 FREE(&e->env->disp_subj);
125 const struct Regex *c_reply_regex = cs_subset_regex(NeoMutt->sub, "reply_regex");
126 if (mutt_regex_capture(c_reply_regex, e->env->subject, 1, pmatch))
127 {
128 e->env->real_subj = e->env->subject + pmatch[0].rm_eo;
129 if (e->env->real_subj[0] == '\0')
130 e->env->real_subj = NULL;
131 }
132 else
133 {
134 e->env->real_subj = e->env->subject;
135 }
137 if (m->subj_hash)
140 mx_save_hcache(m, e);
142 /* Also persist back to the message headers if this is set */
143 const bool c_crypt_protected_headers_save = cs_subset_bool(NeoMutt->sub, "crypt_protected_headers_save");
144 if (c_crypt_protected_headers_save)
145 {
147 e->changed = true;
148 m->changed = true;
149 }
150 }
153 if (c_autocrypt && (e->security & SEC_ENCRYPT) && prot_headers && prot_headers->autocrypt_gossip)
154 {
156 }
174static int email_to_file(struct Message *msg, struct Buffer *tempfile,
175 struct Mailbox *m, struct Email *e, const char *header,
176 int wrap_len, CopyMessageFlags *cmflags)
178 int rc = 0;
179 pid_t filterpid = -1;
184 char columns[16] = { 0 };
185 // win_pager might not be visible and have a size yet, so use win_index
186 snprintf(columns, sizeof(columns), "%d", wrap_len);
187 mutt_envlist_set("COLUMNS", columns, true);
189 /* see if crypto is needed for this message. if so, we should exit curses */
190 if ((WithCrypto != 0) && e->security)
191 {
192 if (e->security & SEC_ENCRYPT)
193 {
197 goto cleanup;
199 *cmflags |= MUTT_CM_VERIFY;
200 }
201 else if (e->security & SEC_SIGN)
202 {
203 /* find out whether or not the verify signature */
204 /* L10N: Used for the $crypt_verify_sig prompt */
205 const enum QuadOption c_crypt_verify_sig = cs_subset_quad(NeoMutt->sub, "crypt_verify_sig");
206 if (query_quadoption(c_crypt_verify_sig, _("Verify signature?")) == MUTT_YES)
207 {
208 *cmflags |= MUTT_CM_VERIFY;
209 }
210 }
211 }
213 if (*cmflags & MUTT_CM_VERIFY || e->security & SEC_ENCRYPT)
214 {
215 if (e->security & APPLICATION_PGP)
216 {
217 if (!TAILQ_EMPTY(&e->env->from))
221 }
225 }
227 FILE *fp_filter_out = NULL;
228 mutt_buffer_mktemp(tempfile);
229 FILE *fp_out = mutt_file_fopen(mutt_buffer_string(tempfile), "w");
230 if (!fp_out)
231 {
232 mutt_error(_("Could not create temporary file"));
233 goto cleanup;
234 }
236 const char *const c_display_filter = cs_subset_string(NeoMutt->sub, "display_filter");
237 if (c_display_filter)
238 {
239 fp_filter_out = fp_out;
240 fp_out = NULL;
241 filterpid = filter_create_fd(c_display_filter, &fp_out, NULL, NULL, -1,
242 fileno(fp_filter_out), -1);
243 if (filterpid < 0)
244 {
245 mutt_error(_("Can't create display filter"));
246 mutt_file_fclose(&fp_filter_out);
247 unlink(mutt_buffer_string(tempfile));
248 goto cleanup;
249 }
250 }
252 if (header)
253 {
254 fputs(header, fp_out);
255 fputs("\n\n", fp_out);
256 }
258 const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
259 CopyHeaderFlags chflags = (c_weed ? (CH_WEED | CH_REORDER) : CH_NO_FLAGS) |
261#ifdef USE_NOTMUCH
262 if (m->type == MUTT_NOTMUCH)
263 chflags |= CH_VIRTUAL;
265 rc = mutt_copy_message(fp_out, e, msg, *cmflags, chflags, wrap_len);
267 if (((mutt_file_fclose(&fp_out) != 0) && (errno != EPIPE)) || (rc < 0))
268 {
269 mutt_error(_("Could not copy message"));
270 if (fp_filter_out)
271 {
272 filter_wait(filterpid);
273 mutt_file_fclose(&fp_filter_out);
274 }
276 goto cleanup;
277 }
279 if (fp_filter_out && (filter_wait(filterpid) != 0))
282 mutt_file_fclose(&fp_filter_out); /* XXX - check result? */
284 if (WithCrypto)
285 {
286 /* update crypto information for this message */
288 e->security |= crypt_query(e->body);
290 /* Remove color cache for this message, in case there
291 * are color patterns for both ~g and ~V */
292 e->attr_color = NULL;
294 /* Process protected headers and autocrypt gossip headers */
296 }
299 mutt_envlist_unset("COLUMNS");
300 return rc;
311int external_pager(struct Mailbox *m, struct Email *e, const char *command)
313 struct Message *msg = mx_msg_open(m, e->msgno);
314 if (!msg)
315 return -1;
317 char buf[1024] = { 0 };
318 const char *const c_pager_format = cs_subset_string(NeoMutt->sub, "pager_format");
319 const int screen_width = RootWindow->state.cols;
320 mutt_make_string(buf, sizeof(buf), screen_width, NONULL(c_pager_format), m,
323 struct Buffer *tempfile = mutt_buffer_pool_get();
326 int rc = email_to_file(msg, tempfile, m, e, buf, screen_width, &cmflags);
327 if (rc < 0)
328 goto cleanup;
330 mutt_endwin();
332 struct Buffer *cmd = mutt_buffer_pool_get();
333 mutt_buffer_printf(cmd, "%s %s", command, mutt_buffer_string(tempfile));
334 int r = mutt_system(mutt_buffer_string(cmd));
335 if (r == -1)
336 mutt_error(_("Error running \"%s\""), mutt_buffer_string(cmd));
337 unlink(mutt_buffer_string(tempfile));
340 if (!OptNoCurses)
341 keypad(stdscr, true);
342 if (r != -1)
343 mutt_set_flag(m, e, MUTT_READ, true);
344 const bool c_prompt_after = cs_subset_bool(NeoMutt->sub, "prompt_after");
345 if ((r != -1) && c_prompt_after)
346 {
348 rc = km_dokey(MENU_PAGER);
349 }
350 else
351 rc = 0;
354 mx_msg_close(m, &msg);
355 mutt_buffer_pool_release(&tempfile);
356 return rc;
365static void notify_crypto(struct Email *e, struct Message *msg, CopyMessageFlags cmflags)
367 if ((WithCrypto != 0) && (e->security & APPLICATION_SMIME) && (cmflags & MUTT_CM_VERIFY))
368 {
369 if (e->security & SEC_GOODSIGN)
370 {
371 if (crypt_smime_verify_sender(e, msg) == 0)
372 mutt_message(_("S/MIME signature successfully verified"));
373 else
374 mutt_error(_("S/MIME certificate owner does not match sender"));
375 }
376 else if (e->security & SEC_PARTSIGN)
377 mutt_message(_("Warning: Part of this message has not been signed"));
378 else if (e->security & SEC_SIGN || e->security & SEC_BADSIGN)
379 mutt_error(_("S/MIME signature could NOT be verified"));
380 }
382 if ((WithCrypto != 0) && (e->security & APPLICATION_PGP) && (cmflags & MUTT_CM_VERIFY))
383 {
384 if (e->security & SEC_GOODSIGN)
385 mutt_message(_("PGP signature successfully verified"));
386 else if (e->security & SEC_PARTSIGN)
387 mutt_message(_("Warning: Part of this message has not been signed"));
388 else if (e->security & SEC_SIGN)
389 mutt_message(_("PGP signature could NOT be verified"));
390 }
399static void squash_index_panel(struct Mailbox *m, struct MuttWindow *win_index,
400 struct MuttWindow *win_pager)
402 const short c_pager_index_lines = cs_subset_number(NeoMutt->sub, "pager_index_lines");
404 const int index_space = MIN(c_pager_index_lines, m->vcount);
405 if (index_space > 0)
406 {
407 win_index->size = MUTT_WIN_SIZE_FIXED;
408 win_index->req_rows = index_space;
409 win_index->parent->size = MUTT_WIN_SIZE_MINIMISE;
410 }
411 window_set_visible(win_index->parent, (index_space > 0));
413 window_set_visible(win_pager->parent, true);
415 struct MuttWindow *dlg = dialog_find(win_index);
418 // Force the menu to reframe itself
419 struct Menu *menu = win_index->wdata;
420 menu_set_index(menu, menu_get_index(menu));
428static void expand_index_panel(struct MuttWindow *win_index, struct MuttWindow *win_pager)
430 win_index->size = MUTT_WIN_SIZE_MAXIMISE;
432 win_index->parent->size = MUTT_WIN_SIZE_MAXIMISE;
434 window_set_visible(win_index->parent, true);
436 window_set_visible(win_pager->parent, false);
438 struct MuttWindow *dlg = dialog_find(win_index);
449int mutt_display_message(struct MuttWindow *win_index, struct IndexSharedData *shared)
451 struct MuttWindow *dlg = dialog_find(win_index);
452 struct MuttWindow *win_pager = window_find_child(dlg, WT_CUSTOM);
453 struct MuttWindow *win_pbar = window_find_child(dlg, WT_STATUS_BAR);
454 struct Buffer *tempfile = mutt_buffer_pool_get();
455 struct Message *msg = NULL;
457 squash_index_panel(shared->mailbox, win_index, win_pager);
459 int rc = PAGER_LOOP_QUIT;
460 do
461 {
462 msg = mx_msg_open(shared->mailbox, shared->email->msgno);
463 if (!msg)
464 break;
468 mutt_buffer_reset(tempfile);
469 // win_pager might not be visible and have a size yet, so use win_index
470 rc = email_to_file(msg, tempfile, shared->mailbox, shared->email, NULL,
471 win_index->state.cols, &cmflags);
472 if (rc < 0)
473 break;
475 notify_crypto(shared->email, msg, cmflags);
477 /* Invoke the builtin pager */
478 struct PagerData pdata = { 0 };
479 struct PagerView pview = { &pdata };
481 pdata.fp = msg->fp;
482 pdata.fname = mutt_buffer_string(tempfile);
484 pview.mode = PAGER_MODE_EMAIL;
485 pview.banner = NULL;
486 pview.flags = MUTT_PAGER_MESSAGE |
487 (shared->email->body->nowrap ? MUTT_PAGER_NOWRAP : 0);
488 pview.win_index = win_index;
489 pview.win_pbar = win_pbar;
490 pview.win_pager = win_pager;
492 rc = mutt_pager(&pview);
493 mx_msg_close(shared->mailbox, &msg);
494 } while (rc == PAGER_LOOP_RELOAD);
498 mx_msg_close(shared->mailbox, &msg);
499 mutt_buffer_pool_release(&tempfile);
500 return rc;
GUI display the mailboxes in a side panel.
void mutt_parse_mime_message(struct Email *e, FILE *fp)
Parse a MIME email.
Definition: attachments.c:591
Autocrypt end-to-end encryption.
int mutt_autocrypt_process_gossip_header(struct Email *e, struct Envelope *prot_headers)
Parse an Autocrypt email gossip header.
Definition: autocrypt.c:413
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:168
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:85
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
const struct Regex * cs_subset_regex(const struct ConfigSubset *sub, const char *name)
Get a regex config item by name.
Definition: helpers.c:243
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
enum QuadOption cs_subset_quad(const struct ConfigSubset *sub, const char *name)
Get a quad-value config item by name.
Definition: helpers.c:218
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
Convenience wrapper for the config headers.
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:864
Duplicate the structure of an entire email.
#define CH_DECODE
Do RFC2047 header decoding.
Definition: copy.h:54
Do signature verification.
Definition: copy.h:47
#define CH_FROM
Retain the "From " message separator?
Definition: copy.h:56
Decode the message body into text/plain.
Definition: copy.h:38
#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
Perform character set conversions.
Definition: copy.h:42
#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
uint16_t CopyMessageFlags
Flags for mutt_copy_message(), e.g. MUTT_CM_NOHEADER.
Definition: copy.h:34
#define CH_VIRTUAL
Write virtual header lines too.
Definition: copy.h:73
#define CH_NO_FLAGS
No flags are set.
Definition: copy.h:51
Output is displayed to the user.
Definition: copy.h:39
Convenience wrapper for the core headers.
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:402
SecurityFlags mutt_is_application_smime(struct Body *b)
Does the message use S/MIME?
Definition: crypt.c:601
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:134
int mutt_is_valid_multipart_pgp_encrypted(struct Body *b)
Is this a valid multi-part encrypted message?
Definition: crypt.c:463
SecurityFlags mutt_is_malformed_multipart_pgp_encrypted(struct Body *b)
Check for malformed layout.
Definition: crypt.c:500
SecurityFlags crypt_query(struct Body *b)
Check out the type of encryption used.
Definition: crypt.c:675
void crypt_invoke_message(SecurityFlags type)
Display an informative message.
Definition: cryptglue.c:157
void crypt_smime_getkeys(struct Envelope *env)
Wrapper for CryptModuleSpecs::smime_getkeys()
Definition: cryptglue.c:455
void crypt_pgp_invoke_getkeys(struct Address *addr)
Wrapper for CryptModuleSpecs::pgp_invoke_getkeys()
Definition: cryptglue.c:274
int crypt_smime_verify_sender(struct Email *e, struct Message *msg)
Wrapper for CryptModuleSpecs::smime_verify_sender()
Definition: cryptglue.c:464
int mutt_any_key_to_continue(const char *s)
Prompt the user to 'press any key' and wait.
Definition: curs_lib.c:387
void mutt_endwin(void)
Shutdown curses.
Definition: curs_lib.c:354
void mutt_unget_ch(int ch)
Return a keystroke to the input buffer.
Definition: curs_lib.c:521
struct MuttWindow * dialog_find(struct MuttWindow *win)
Find the parent Dialog of a Window.
Definition: dialog.c:83
int mutt_pager(struct PagerView *pview)
Display an email, attachment, or help, in a window.
Definition: dlg_pager.c:223
Structs that make up an email.
Protected header update.
Definition: envelope.h:37
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
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:618
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:194
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
Flags to control mutt_expando_format()
No flags are set.
Definition: format_flags.h:30
#define mutt_error(...)
Definition: logging.h:87
#define mutt_message(...)
Definition: logging.h:86
Convenience wrapper for the gui headers.
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
void mutt_hash_delete(struct HashTable *table, const char *strkey, const void *data)
Remove an element from a Hash Table.
Definition: hash.c:427
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:1405
String processing routines to generate the mail index.
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:658
Parse and execute user-defined hooks.
message-hook: run before displaying a message
Definition: hook.h:45
GUI manage the main index (list of emails)
int km_dokey(enum MenuType mtype)
Determine what a keypress should do.
Definition: keymap.c:795
Manage keymappings.
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
#define FREE(x)
Definition: memory.h:43
#define MIN(a, b)
Definition: memory.h:31
GUI present the user with a selectable list.
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:154
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:168
Convenience wrapper for the library headers.
#define N_(a)
Definition: message.h:32
#define _(a)
Definition: message.h:28
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:614
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:807
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:326
Many unsorted constants and some structs.
Messages that have been read.
Definition: mutt.h:93
void mutt_window_reflow(struct MuttWindow *win)
Resize a Window and its children.
Definition: mutt_window.c:340
void window_set_visible(struct MuttWindow *win, bool visible)
Set a Window visible or hidden.
Definition: mutt_window.c:164
struct MuttWindow * window_find_child(struct MuttWindow *win, enum WindowType type)
Recursively find a child Window of a given type.
Definition: mutt_window.c:522
Window with a custom drawing function.
Definition: mutt_window.h:95
Status Bar containing extra info about the Index/Pager/etc.
Definition: mutt_window.h:102
Use as much space as possible.
Definition: mutt_window.h:52
Window has a fixed size.
Definition: mutt_window.h:47
Window size depends on its children.
Definition: mutt_window.h:49
Window wants as much space as possible.
Definition: mutt_window.h:48
Some miscellaneous functions.
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:74
int mx_msg_close(struct Mailbox *m, struct Message **msg)
Close a message.
Definition: mx.c:1193
struct Message * mx_msg_open(struct Mailbox *m, int msgno)
Return a stream pointer for a message.
Definition: mx.c:1147
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:1824
API for mailboxes.
API for encryption/signing of emails.
Email has a valid signature.
Definition: lib.h:80
Use PGP to encrypt/sign.
Definition: lib.h:90
Email has a bad signature.
Definition: lib.h:81
Use SMIME to encrypt/sign.
Definition: lib.h:91
Not all parts of the email is signed.
Definition: lib.h:82
Email is encrypted.
Definition: lib.h:78
#define WithCrypto
Definition: lib.h:116
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
Handling of global boolean variables.
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: options.h:53
GUI display a file/email/help in a viewport with paging.
Reload the Pager from scratch.
Definition: lib.h:151
Quit the Pager.
Definition: lib.h:150
Format for term width, ignore $wrap.
Definition: lib.h:71
Pager is invoked via 1st path. The mime part is selected automatically.
Definition: lib.h:135
Definition: lib.h:74
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:174
static void expand_index_panel(struct MuttWindow *win_index, struct MuttWindow *win_pager)
Restore the Index Panel.
Definition: message.c:428
static const char * ExtPagerProgress
Definition: message.c:59
static void process_protected_headers(struct Mailbox *m, struct Email *e)
Get the protected header and update the index.
Definition: message.c:66
int mutt_display_message(struct MuttWindow *win_index, struct IndexSharedData *shared)
Display a message in the pager.
Definition: message.c:449
int external_pager(struct Mailbox *m, struct Email *e, const char *command)
Display a message in an external program.
Definition: message.c:311
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:365
static void squash_index_panel(struct Mailbox *m, struct MuttWindow *win_index, struct MuttWindow *win_pager)
Shrink or hide the Index Panel.
Definition: message.c:399
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
Prototypes for many functions.
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:63
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:51
Possible values for a quad-option.
Definition: quad.h:36
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
Ask the user a question.
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: question.c:386
#define TAILQ_FIRST(head)
Definition: queue.h:723
#define TAILQ_EMPTY(head)
Definition: queue.h:721
struct MuttWindow * RootWindow
Parent of all Windows.
Definition: rootwin.c:104
#define NONULL(x)
Definition: string2.h:37
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:75
bool nowrap
Do not wrap the output in the pager.
Definition: body.h:88
String manipulation buffer.
Definition: buffer.h:34
The envelope/body of an email.
Definition: email.h:37
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
struct AttrColor * attr_color
Color-pair to use when displaying in the index.
Definition: email.h:112
bool changed
Email has been edited.
Definition: email.h:75
int msgno
Number displayed to the user.
Definition: email.h:111
The header of an Email.
Definition: envelope.h:57
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:92
struct AutocryptHeader * autocrypt_gossip
Autocrypt Gossip header.
Definition: envelope.h:90
char * subject
Email's subject.
Definition: envelope.h:70
char * real_subj
Offset of the real subject.
Definition: envelope.h:71
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:72
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
Data shared between Index, Pager and Sidebar.
Definition: shared_data.h:37
struct Email * email
Currently selected Email.
Definition: shared_data.h:42
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:41
A mailbox.
Definition: mailbox.h:79
int vcount
The number of virtual messages.
Definition: mailbox.h:99
bool changed
Mailbox has been modified.
Definition: mailbox.h:110
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct HashTable * subj_hash
Hash Table by subject.
Definition: mailbox.h:124
Definition: lib.h:69
A local copy of an email.
Definition: mxapi.h:43
FILE * fp
pointer to the message data
Definition: mxapi.h:44
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:127
void * wdata
Private data.
Definition: mutt_window.h:145
short req_rows
Number of rows required.
Definition: mutt_window.h:125
struct MuttWindow * parent
Parent Window.
Definition: mutt_window.h:135
enum MuttWindowSize size
Type of Window, e.g. MUTT_WIN_SIZE_FIXED.
Definition: mutt_window.h:131
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
Data to be displayed by PagerView.
Definition: lib.h:158
const char * fname
Name of the file to read.
Definition: lib.h:162
FILE * fp
Source stream.
Definition: lib.h:160
Paged view into some data.
Definition: lib.h:169
struct MuttWindow * win_index
Index Window.
Definition: lib.h:175
struct PagerData * pdata
Data that pager displays. NOTNULL.
Definition: lib.h:170
enum PagerMode mode
Pager mode.
Definition: lib.h:171
PagerFlags flags
Additional settings to tweak pager's function.
Definition: lib.h:172
const char * banner
Title to display in status bar.
Definition: lib.h:173
struct MuttWindow * win_pbar
Pager Bar Window.
Definition: lib.h:176
struct MuttWindow * win_pager
Pager Window.
Definition: lib.h:177
Cached regular expression.
Definition: regex3.h:89
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:60
Pager pager (email viewer)
Definition: type.h:54