NeoMutt  2019-12-07-60-g0cfa53
Teaching an old dog new tricks
DOXYGEN
postpone.c File Reference

Save/restore and GUI list postponed emails. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#include "mutt/mutt.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "context.h"
#include "format_flags.h"
#include "globals.h"
#include "handler.h"
#include "hdrline.h"
#include "keymap.h"
#include "mutt_logging.h"
#include "mutt_menu.h"
#include "mutt_thread.h"
#include "muttlib.h"
#include "mx.h"
#include "ncrypt/ncrypt.h"
#include "opcodes.h"
#include "options.h"
#include "protos.h"
#include "rfc3676.h"
#include "send.h"
#include "sendlib.h"
#include "sort.h"
#include "state.h"
#include "imap/imap.h"
+ Include dependency graph for postpone.c:

Go to the source code of this file.

Functions

int mutt_num_postponed (struct Mailbox *m, bool force)
 Return the number of postponed messages. More...
 
void mutt_update_num_postponed (void)
 Force the update of the number of postponed messages. More...
 
static void post_make_entry (char *buf, size_t buflen, struct Menu *menu, int line)
 Format a menu item for the email list - Implements Menu::menu_make_entry() More...
 
static struct Emailselect_msg (struct Context *ctx)
 Create a Menu to select a postponed message. More...
 
int mutt_get_postponed (struct Context *ctx, struct Email *hdr, struct Email **cur, struct Buffer *fcc)
 Recall a postponed message. More...
 
SecurityFlags mutt_parse_crypt_hdr (const char *p, bool set_empty_signas, SecurityFlags crypt_app)
 Parse a crypto header string. More...
 
int mutt_prepare_template (FILE *fp, struct Mailbox *m, struct Email *e_new, struct Email *e, bool resend)
 Prepare a message template. More...
 

Variables

static const struct Mapping PostponeHelp []
 
static short PostCount = 0
 
static bool UpdateNumPostponed = false
 

Detailed Description

Save/restore and GUI list postponed emails.

Authors
  • Michael R. Elkins
  • Thomas Roessler

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 postpone.c.

Function Documentation

◆ mutt_num_postponed()

int mutt_num_postponed ( struct Mailbox m,
bool  force 
)

Return the number of postponed messages.

Parameters
mcurrently selected mailbox
force
  • false Use a cached value if costly to get a fresh count (IMAP)
  • true Force check
Return values
numPostponed messages

Definition at line 86 of file postpone.c.

87 {
88  struct stat st;
89 
90  static time_t LastModify = 0;
91  static char *OldPostponed = NULL;
92 
94  {
95  UpdateNumPostponed = false;
96  force = true;
97  }
98 
99  if (mutt_str_strcmp(C_Postponed, OldPostponed) != 0)
100  {
101  FREE(&OldPostponed);
102  OldPostponed = mutt_str_strdup(C_Postponed);
103  LastModify = 0;
104  force = true;
105  }
106 
107  if (!C_Postponed)
108  return 0;
109 
110  // We currently are in the C_Postponed mailbox so just pick the current status
111  if (m && (mutt_str_strcmp(C_Postponed, m->realpath) == 0))
112  {
113  PostCount = m->msg_count - m->msg_deleted;
114  return PostCount;
115  }
116 
117 #ifdef USE_IMAP
118  /* LastModify is useless for IMAP */
119  if (imap_path_probe(C_Postponed, NULL) == MUTT_IMAP)
120  {
121  if (force)
122  {
123  short newpc;
124 
125  newpc = imap_path_status(C_Postponed, false);
126  if (newpc >= 0)
127  {
128  PostCount = newpc;
129  mutt_debug(LL_DEBUG3, "%d postponed IMAP messages found\n", PostCount);
130  }
131  else
132  mutt_debug(LL_DEBUG3, "using old IMAP postponed count\n");
133  }
134  return PostCount;
135  }
136 #endif
137 
138  if (stat(C_Postponed, &st) == -1)
139  {
140  PostCount = 0;
141  LastModify = 0;
142  return 0;
143  }
144 
145  if (S_ISDIR(st.st_mode))
146  {
147  /* if we have a maildir mailbox, we need to stat the "new" dir */
148  struct Buffer *buf = mutt_buffer_pool_get();
149 
150  mutt_buffer_printf(buf, "%s/new", C_Postponed);
151  if ((access(mutt_b2s(buf), F_OK) == 0) && (stat(mutt_b2s(buf), &st) == -1))
152  {
153  PostCount = 0;
154  LastModify = 0;
156  return 0;
157  }
159  }
160 
161  if (LastModify < st.st_mtime)
162  {
163 #ifdef USE_NNTP
164  int optnews = OptNews;
165 #endif
166  LastModify = st.st_mtime;
167 
168  if (access(C_Postponed, R_OK | F_OK) != 0)
169  return PostCount = 0;
170 #ifdef USE_NNTP
171  if (optnews)
172  OptNews = false;
173 #endif
174  struct Mailbox *m_post = mx_path_resolve(C_Postponed);
175  struct Context *ctx = mx_mbox_open(m_post, MUTT_NOSORT | MUTT_QUIET);
176  if (ctx)
177  {
178  PostCount = ctx->mailbox->msg_count;
179  }
180  else
181  {
182  mailbox_free(&m_post);
183  PostCount = 0;
184  }
185  mx_fastclose_mailbox(m_post);
186  ctx_free(&ctx);
187 #ifdef USE_NNTP
188  if (optnews)
189  OptNews = true;
190 #endif
191  }
192 
193  return PostCount;
194 }
The "current" mailbox.
Definition: context.h:36
int msg_count
Total number of messages.
Definition: mailbox.h:90
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
int imap_path_status(const char *path, bool queue)
Refresh the number of total and new messages.
Definition: imap.c:1310
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe()
Definition: imap.c:2474
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:95
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:83
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
struct Context * mx_mbox_open(struct Mailbox *m, OpenMailboxFlags flags)
Open a mailbox and parse it.
Definition: mx.c:253
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
struct Mailbox * mailbox
Definition: context.h:50
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:60
void mx_fastclose_mailbox(struct Mailbox *m)
free up memory associated with the Mailbox
Definition: mx.c:412
#define mutt_b2s(buf)
Definition: buffer.h:41
A mailbox.
Definition: mailbox.h:80
#define MUTT_NOSORT
Do not sort the mailbox after opening it.
Definition: mx.h:51
static short PostCount
Definition: postpone.c:75
#define MUTT_QUIET
Do not print any messages.
Definition: mx.h:54
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
#define FREE(x)
Definition: memory.h:40
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1603
static bool UpdateNumPostponed
Definition: postpone.c:76
void ctx_free(struct Context **ptr)
Free a Context.
Definition: context.c:49
#define mutt_debug(LEVEL,...)
Definition: logging.h:81
WHERE char * C_Postponed
Config: Folder to store postponed messages.
Definition: globals.h:134
&#39;IMAP&#39; Mailbox type
Definition: mailbox.h:52
WHERE bool OptNews
(pseudo) used to change reader mode
Definition: options.h:43
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:615
Log at debug level 3.
Definition: logging.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_update_num_postponed()

void mutt_update_num_postponed ( void  )

Force the update of the number of postponed messages.

Definition at line 199 of file postpone.c.

200 {
201  UpdateNumPostponed = true;
202 }
static bool UpdateNumPostponed
Definition: postpone.c:76
+ Here is the caller graph for this function:

◆ post_make_entry()

static void post_make_entry ( char *  buf,
size_t  buflen,
struct Menu menu,
int  line 
)
static

Format a menu item for the email list - Implements Menu::menu_make_entry()

Definition at line 207 of file postpone.c.

208 {
209  struct Context *ctx = menu->data;
210 
211  mutt_make_string_flags(buf, buflen, menu->win_index->state.cols,
212  NONULL(C_IndexFormat), ctx, ctx->mailbox,
214 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:98
The "current" mailbox.
Definition: context.h:36
#define NONULL(x)
Definition: string2.h:37
#define MUTT_FORMAT_ARROWCURSOR
Reserve space for arrow_cursor.
Definition: format_flags.h:35
struct Mailbox * mailbox
Definition: context.h:50
void mutt_make_string_flags(char *buf, size_t buflen, int cols, const char *s, struct Context *ctx, struct Mailbox *m, struct Email *e, MuttFormatFlags flags)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1505
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:56
const char * line
Definition: common.c:36
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:91
WHERE char * C_IndexFormat
Config: printf-like format string for the index menu (emails)
Definition: globals.h:112
void * data
Extra data for the current menu.
Definition: mutt_menu.h:86
struct MuttWindow * win_index
Definition: mutt_menu.h:95
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ select_msg()

static struct Email* select_msg ( struct Context ctx)
static

Create a Menu to select a postponed message.

Parameters
ctxContext
Return values
ptrEmail

Definition at line 221 of file postpone.c.

222 {
223  int r = -1;
224  bool done = false;
225  char helpstr[1024];
226 
227  struct MuttWindow *dlg =
230  dlg->type = WT_DIALOG;
231  struct MuttWindow *index =
234  index->type = WT_INDEX;
235  struct MuttWindow *ibar = mutt_window_new(
237  ibar->type = WT_INDEX_BAR;
238 
239  if (C_StatusOnTop)
240  {
241  mutt_window_add_child(dlg, ibar);
242  mutt_window_add_child(dlg, index);
243  }
244  else
245  {
246  mutt_window_add_child(dlg, index);
247  mutt_window_add_child(dlg, ibar);
248  }
249 
250  dialog_push(dlg);
251 
252  struct Menu *menu = mutt_menu_new(MENU_POSTPONE);
253 
254  menu->pagelen = index->state.rows;
255  menu->win_index = index;
256  menu->win_ibar = ibar;
257 
259  menu->max = ctx->mailbox->msg_count;
260  menu->title = _("Postponed Messages");
261  menu->data = ctx;
262  menu->help = mutt_compile_help(helpstr, sizeof(helpstr), MENU_POSTPONE, PostponeHelp);
264 
265  /* The postponed mailbox is setup to have sorting disabled, but the global
266  * C_Sort variable may indicate something different. Sorting has to be
267  * disabled while the postpone menu is being displayed. */
268  const short orig_sort = C_Sort;
269  C_Sort = SORT_ORDER;
270 
271  while (!done)
272  {
273  const int op = mutt_menu_loop(menu);
274  switch (op)
275  {
276  case OP_DELETE:
277  case OP_UNDELETE:
278  /* should deleted draft messages be saved in the trash folder? */
279  mutt_set_flag(ctx->mailbox, ctx->mailbox->emails[menu->current],
280  MUTT_DELETE, (op == OP_DELETE));
282  if (C_Resolve && (menu->current < menu->max - 1))
283  {
284  menu->oldcurrent = menu->current;
285  menu->current++;
286  if (menu->current >= menu->top + menu->pagelen)
287  {
288  menu->top = menu->current;
289  menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
290  }
291  else
292  menu->redraw |= REDRAW_MOTION_RESYNC;
293  }
294  else
295  menu->redraw |= REDRAW_CURRENT;
296  break;
297 
298  case OP_GENERIC_SELECT_ENTRY:
299  r = menu->current;
300  done = true;
301  break;
302 
303  case OP_EXIT:
304  done = true;
305  break;
306  }
307  }
308 
309  C_Sort = orig_sort;
310  mutt_menu_pop_current(menu);
311  mutt_menu_free(&menu);
312  dialog_pop();
313  mutt_window_free(&dlg);
314 
315  return (r > -1) ? ctx->mailbox->emails[r] : NULL;
316 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:98
static const struct Mapping PostponeHelp[]
Definition: postpone.c:67
WHERE bool C_StatusOnTop
Config: Display the status bar at the top.
Definition: globals.h:255
int msg_count
Total number of messages.
Definition: mailbox.h:90
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:70
GUI selectable list of items.
Definition: mutt_menu.h:82
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:95
Dialog (nested Windows) displayed to the user.
Definition: mutt_window.h:68
Window uses all available vertical space.
Definition: mutt_window.h:33
int oldcurrent
For driver use only.
Definition: mutt_menu.h:109
void dialog_pop(void)
Hide a Window from the user.
Definition: mutt_window.c:623
void dialog_push(struct MuttWindow *dlg)
Display a Window to the user.
Definition: mutt_window.c:603
#define _(a)
Definition: message.h:28
A division of the screen.
Definition: mutt_window.h:86
void(* menu_make_entry)(char *buf, size_t buflen, struct Menu *menu, int line)
Format a item for a menu.
Definition: mutt_menu.h:120
static void post_make_entry(char *buf, size_t buflen, struct Menu *menu, int line)
Format a menu item for the email list - Implements Menu::menu_make_entry()
Definition: postpone.c:207
An Index Window containing a selection list.
Definition: mutt_window.h:72
void mutt_window_free(struct MuttWindow **ptr)
Free a Window and its children.
Definition: mutt_window.c:75
struct Mailbox * mailbox
Definition: context.h:50
struct MuttWindow * win_ibar
Definition: mutt_menu.h:96
Sort by the order the messages appear in the mailbox.
Definition: sort2.h:55
WHERE short C_Sort
Config: Sort method for the index.
Definition: sort.h:58
Window has a fixed size.
Definition: mutt_window.h:42
#define REDRAW_MOTION_RESYNC
Redraw any changing the menu selection.
Definition: mutt_menu.h:44
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:91
#define REDRAW_STATUS
Redraw the status bar.
Definition: mutt_menu.h:46
struct MuttWindow * mutt_window_new(enum MuttWindowOrientation orient, enum MuttWindowSize size, int rows, int cols)
Create a new Window.
Definition: mutt_window.c:57
Messages to be deleted.
Definition: mutt.h:102
#define MUTT_WIN_SIZE_UNLIMITED
Use as much space as possible.
Definition: mutt_window.h:47
short rows
Number of rows, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:55
int top
Entry that is the top of the current page.
Definition: mutt_menu.h:108
WHERE bool C_Resolve
Config: Move to the next email whenever a command modifies an email.
Definition: globals.h:246
static short PostCount
Definition: postpone.c:75
int pagelen
Number of entries per screen.
Definition: mutt_menu.h:92
int max
Number of entries in the menu.
Definition: mutt_menu.h:88
void mutt_window_add_child(struct MuttWindow *parent, struct MuttWindow *child)
Add a child to Window.
Definition: mutt_window.c:471
MuttRedrawFlags redraw
When to redraw the screen.
Definition: mutt_menu.h:89
char * title
Title of this menu.
Definition: mutt_menu.h:84
#define REDRAW_INDEX
Redraw the index.
Definition: mutt_menu.h:42
void * data
Extra data for the current menu.
Definition: mutt_menu.h:86
int current
Current entry.
Definition: mutt_menu.h:87
struct MuttWindow * win_index
Definition: mutt_menu.h:95
char * mutt_compile_help(char *buf, size_t buflen, enum MenuType menu, const struct Mapping *items)
Create the text for the help menu.
Definition: help.c:115
Window wants as much space as possible.
Definition: mutt_window.h:43
Index Bar containing status info about the Index.
Definition: mutt_window.h:73
enum WindowType type
Window type, e.g. WT_SIDEBAR.
Definition: mutt_window.h:101
char * help
Quickref for the current menu.
Definition: mutt_menu.h:85
Select a postponed email.
Definition: keymap.h:79
#define REDRAW_CURRENT
Redraw the current line of the menu.
Definition: mutt_menu.h:45
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_get_postponed()

int mutt_get_postponed ( struct Context ctx,
struct Email hdr,
struct Email **  cur,
struct Buffer fcc 
)

Recall a postponed message.

Parameters
[in]ctxContext info, used when recalling a message to which we reply
[in]hdrenvelope/attachment info for recalled message
[out]curif message was a reply, 'cur' is set to the message which 'hdr' is in reply to
[in]fccfcc for the recalled message
Return values
-1Error/no messages
0Normal exit
SEND_REPLYRecalled message is a reply

Definition at line 328 of file postpone.c.

330 {
331  if (!C_Postponed)
332  return -1;
333 
334  struct Email *e = NULL;
335  int rc = SEND_POSTPONED;
336  const char *p = NULL;
337  struct Context *ctx_post = NULL;
338 
339  struct Mailbox *m = mx_path_resolve(C_Postponed);
340  if (ctx && (ctx->mailbox == m))
341  ctx_post = ctx;
342  else
343  ctx_post = mx_mbox_open(m, MUTT_NOSORT);
344 
345  if (!ctx_post)
346  {
347  PostCount = 0;
348  mutt_error(_("No postponed messages"));
349  mailbox_free(&m);
350  return -1;
351  }
352 
353  if (ctx_post->mailbox->msg_count == 0)
354  {
355  PostCount = 0;
356  if (ctx_post == ctx)
357  ctx_post = NULL;
358  else
359  mx_mbox_close(&ctx_post);
360  mutt_error(_("No postponed messages"));
361  return -1;
362  }
363 
364  if (ctx_post->mailbox->msg_count == 1)
365  {
366  /* only one message, so just use that one. */
367  e = ctx_post->mailbox->emails[0];
368  }
369  else if (!(e = select_msg(ctx_post)))
370  {
371  if (ctx_post == ctx)
372  ctx_post = NULL;
373  else
374  mx_mbox_close(&ctx_post);
375  return -1;
376  }
377 
378  if (mutt_prepare_template(NULL, ctx_post->mailbox, hdr, e, false) < 0)
379  {
380  if (ctx_post != ctx)
381  {
382  mx_fastclose_mailbox(ctx_post->mailbox);
383  FREE(&ctx_post);
384  }
385  return -1;
386  }
387 
388  /* finished with this message, so delete it. */
389  mutt_set_flag(ctx_post->mailbox, e, MUTT_DELETE, true);
390  mutt_set_flag(ctx_post->mailbox, e, MUTT_PURGE, true);
391 
392  /* update the count for the status display */
393  PostCount = ctx_post->mailbox->msg_count - ctx_post->mailbox->msg_deleted;
394 
395  /* avoid the "purge deleted messages" prompt */
396  int opt_delete = C_Delete;
397  C_Delete = MUTT_YES;
398  if (ctx_post == ctx)
399  ctx_post = NULL;
400  else
401  mx_mbox_close(&ctx_post);
402  C_Delete = opt_delete;
403 
404  struct ListNode *np = NULL, *tmp = NULL;
405  STAILQ_FOREACH_SAFE(np, &hdr->env->userhdrs, entries, tmp)
406  {
407  size_t plen = mutt_str_startswith(np->data, "X-Mutt-References:", CASE_IGNORE);
408  if (plen)
409  {
410  /* if a mailbox is currently open, look to see if the original message
411  * the user attempted to reply to is in this mailbox */
412  p = mutt_str_skip_email_wsp(np->data + plen);
413  if (!ctx->mailbox->id_hash)
415  *cur = mutt_hash_find(ctx->mailbox->id_hash, p);
416 
417  if (*cur)
418  rc |= SEND_REPLY;
419  }
420  else if ((plen = mutt_str_startswith(np->data, "X-Mutt-Fcc:", CASE_IGNORE)))
421  {
422  p = mutt_str_skip_email_wsp(np->data + plen);
423  mutt_buffer_strcpy(fcc, p);
425 
426  /* note that x-mutt-fcc was present. we do this because we want to add a
427  * default fcc if the header was missing, but preserve the request of the
428  * user to not make a copy if the header field is present, but empty.
429  * see http://dev.mutt.org/trac/ticket/3653 */
430  rc |= SEND_POSTPONED_FCC;
431  }
432  else if (((WithCrypto & APPLICATION_PGP) != 0) &&
433  /* this is generated by old neomutt versions */
434  (mutt_str_startswith(np->data, "Pgp:", CASE_MATCH) ||
435  /* this is the new way */
436  mutt_str_startswith(np->data, "X-Mutt-PGP:", CASE_MATCH)))
437  {
438  hdr->security = mutt_parse_crypt_hdr(strchr(np->data, ':') + 1, true, APPLICATION_PGP);
439  hdr->security |= APPLICATION_PGP;
440  }
441  else if (((WithCrypto & APPLICATION_SMIME) != 0) &&
442  mutt_str_startswith(np->data, "X-Mutt-SMIME:", CASE_MATCH))
443  {
444  hdr->security = mutt_parse_crypt_hdr(strchr(np->data, ':') + 1, true, APPLICATION_SMIME);
445  hdr->security |= APPLICATION_SMIME;
446  }
447 #ifdef MIXMASTER
448  else if (mutt_str_startswith(np->data, "X-Mutt-Mix:", CASE_MATCH))
449  {
450  mutt_list_free(&hdr->chain);
451 
452  char *t = strtok(np->data + 11, " \t\n");
453  while (t)
454  {
455  mutt_list_insert_tail(&hdr->chain, mutt_str_strdup(t));
456  t = strtok(NULL, " \t\n");
457  }
458  }
459 #endif
460  else
461  {
462  // skip header removal
463  continue;
464  }
465 
466  // remove the header
467  STAILQ_REMOVE(&hdr->env->userhdrs, np, ListNode, entries);
468  FREE(&np->data);
469  FREE(&np);
470  }
471 
474 
475  return rc;
476 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:98
The "current" mailbox.
Definition: context.h:36
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:399
int msg_count
Total number of messages.
Definition: mailbox.h:90
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:70
#define SEND_POSTPONED_FCC
Used by mutt_get_postponed() to signal that the x-mutt-fcc header field was present.
Definition: send.h:97
The envelope/body of an email.
Definition: email.h:37
static struct Email * select_msg(struct Context *ctx)
Create a Menu to select a postponed message.
Definition: postpone.c:221
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:95
int mx_mbox_close(struct Context **ptr)
Save changes and close mailbox.
Definition: mx.c:583
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
static size_t plen
Length of cached packet.
Definition: pgppacket.c:39
void * mutt_hash_find(const struct Hash *table, const char *strkey)
Find the HashElem data in a Hash table element using a key.
Definition: hash.c:378
WHERE unsigned char C_Delete
Config: Really delete messages, when the mailbox is closed.
Definition: globals.h:180
struct ListHead userhdrs
user defined headers
Definition: envelope.h:83
#define _(a)
Definition: message.h:28
struct Context * mx_mbox_open(struct Mailbox *m, OpenMailboxFlags flags)
Open a mailbox and parse it.
Definition: mx.c:253
Messages to be purged (bypass trash)
Definition: mutt.h:104
Match case when comparing strings.
Definition: string2.h:67
#define SEND_POSTPONED
Recall a postponed email.
Definition: send.h:92
void mutt_buffer_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using &#39;~&#39; or &#39;=&#39;.
Definition: muttlib.c:703
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
struct Mailbox * mailbox
Definition: context.h:50
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:60
struct Envelope * env
Envelope information.
Definition: email.h:89
void mx_fastclose_mailbox(struct Mailbox *m)
free up memory associated with the Mailbox
Definition: mx.c:412
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:359
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:65
WHERE bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: globals.h:269
Messages to be deleted.
Definition: mutt.h:102
A mailbox.
Definition: mailbox.h:80
#define MUTT_NOSORT
Do not sort the mailbox after opening it.
Definition: mx.h:51
static short PostCount
Definition: postpone.c:75
Ignore case when comparing strings.
Definition: string2.h:68
char * mutt_str_skip_email_wsp(const char *s)
Skip over whitespace as defined by RFC5322.
Definition: string.c:776
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
#define SEND_REPLY
Reply to sender.
Definition: send.h:88
struct Hash * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Definition: mutt_thread.c:1456
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:312
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
size_t mutt_str_startswith(const char *str, const char *prefix, enum CaseSensitivity cs)
Check whether a string starts with a prefix.
Definition: string.c:168
SecurityFlags mutt_parse_crypt_hdr(const char *p, bool set_empty_signas, SecurityFlags crypt_app)
Parse a crypto header string.
Definition: postpone.c:485
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
Definition: crypt.c:1028
char * data
String.
Definition: list.h:35
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
#define mutt_error(...)
Definition: logging.h:84
#define FREE(x)
Definition: memory.h:40
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1603
WHERE char * C_Postponed
Config: Folder to store postponed messages.
Definition: globals.h:134
A List node for strings.
Definition: list.h:33
#define WithCrypto
Definition: ncrypt.h:160
int mutt_prepare_template(FILE *fp, struct Mailbox *m, struct Email *e_new, struct Email *e, bool resend)
Prepare a message template.
Definition: postpone.c:632
struct Hash * id_hash
Hash table by msg id.
Definition: mailbox.h:126
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_parse_crypt_hdr()

SecurityFlags mutt_parse_crypt_hdr ( const char *  p,
bool  set_empty_signas,
SecurityFlags  crypt_app 
)

Parse a crypto header string.

Parameters
pHeader string to parse
set_empty_signasAllow an empty "Sign as"
crypt_appApp, e.g. APPLICATION_PGP
Return values
numSecurityFlags, see SecurityFlags

Definition at line 485 of file postpone.c.

486 {
487  char smime_cryptalg[1024] = { 0 };
488  char sign_as[1024] = { 0 };
489  char *q = NULL;
490  SecurityFlags flags = SEC_NO_FLAGS;
491 
492  if (!WithCrypto)
493  return SEC_NO_FLAGS;
494 
496  for (; p[0] != '\0'; p++)
497  {
498  switch (p[0])
499  {
500  case 'c':
501  case 'C':
502  q = smime_cryptalg;
503 
504  if (p[1] == '<')
505  {
506  for (p += 2; (p[0] != '\0') && (p[0] != '>') &&
507  (q < (smime_cryptalg + sizeof(smime_cryptalg) - 1));
508  *q++ = *p++)
509  {
510  }
511 
512  if (p[0] != '>')
513  {
514  mutt_error(_("Illegal S/MIME header"));
515  return SEC_NO_FLAGS;
516  }
517  }
518 
519  *q = '\0';
520  break;
521 
522  case 'e':
523  case 'E':
524  flags |= SEC_ENCRYPT;
525  break;
526 
527  case 'i':
528  case 'I':
529  flags |= SEC_INLINE;
530  break;
531 
532  /* This used to be the micalg parameter.
533  *
534  * It's no longer needed, so we just skip the parameter in order
535  * to be able to recall old messages. */
536  case 'm':
537  case 'M':
538  if (p[1] == '<')
539  {
540  for (p += 2; (p[0] != '\0') && (p[0] != '>'); p++)
541  ;
542  if (p[0] != '>')
543  {
544  mutt_error(_("Illegal crypto header"));
545  return SEC_NO_FLAGS;
546  }
547  }
548 
549  break;
550 
551  case 'o':
552  case 'O':
553  flags |= SEC_OPPENCRYPT;
554  break;
555 
556  case 'a':
557  case 'A':
558 #ifdef USE_AUTOCRYPT
559  flags |= SEC_AUTOCRYPT;
560 #endif
561  break;
562 
563  case 'z':
564  case 'Z':
565 #ifdef USE_AUTOCRYPT
566  flags |= SEC_AUTOCRYPT_OVERRIDE;
567 #endif
568  break;
569 
570  case 's':
571  case 'S':
572  flags |= SEC_SIGN;
573  q = sign_as;
574 
575  if (p[1] == '<')
576  {
577  for (p += 2;
578  (p[0] != '\0') && (*p != '>') && (q < (sign_as + sizeof(sign_as) - 1));
579  *q++ = *p++)
580  {
581  }
582 
583  if (p[0] != '>')
584  {
585  mutt_error(_("Illegal crypto header"));
586  return SEC_NO_FLAGS;
587  }
588  }
589 
590  q[0] = '\0';
591  break;
592 
593  default:
594  mutt_error(_("Illegal crypto header"));
595  return SEC_NO_FLAGS;
596  }
597  }
598 
599  /* the cryptalg field must not be empty */
600  if (((WithCrypto & APPLICATION_SMIME) != 0) && *smime_cryptalg)
601  mutt_str_replace(&C_SmimeEncryptWith, smime_cryptalg);
602 
603  /* Set {Smime,Pgp}SignAs, if desired. */
604 
605  if (((WithCrypto & APPLICATION_PGP) != 0) && (crypt_app == APPLICATION_PGP) &&
606  (flags & SEC_SIGN) && (set_empty_signas || *sign_as))
607  {
608  mutt_str_replace(&C_PgpSignAs, sign_as);
609  }
610 
611  if (((WithCrypto & APPLICATION_SMIME) != 0) && (crypt_app == APPLICATION_SMIME) &&
612  (flags & SEC_SIGN) && (set_empty_signas || *sign_as))
613  {
614  mutt_str_replace(&C_SmimeSignAs, sign_as);
615  }
616 
617  return flags;
618 }
#define SEC_AUTOCRYPT
Message will be, or was Autocrypt encrypt+signed.
Definition: ncrypt.h:131
#define SEC_AUTOCRYPT_OVERRIDE
Indicates manual set/unset of encryption.
Definition: ncrypt.h:132
#define SEC_NO_FLAGS
No flags are set.
Definition: ncrypt.h:121
#define _(a)
Definition: message.h:28
#define SEC_INLINE
Email has an inline signature.
Definition: ncrypt.h:129
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:123
WHERE char * C_SmimeEncryptWith
Config: Algorithm for encryption.
Definition: globals.h:165
char * mutt_str_skip_email_wsp(const char *s)
Skip over whitespace as defined by RFC5322.
Definition: string.c:776
void mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:453
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: ncrypt.h:130
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
#define mutt_error(...)
Definition: logging.h:84
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: ncrypt.h:120
WHERE char * C_PgpSignAs
Config: Use this alternative key for signing messages.
Definition: globals.h:160
WHERE char * C_SmimeSignAs
Config: Use this alternative key for signing messages.
Definition: globals.h:164
#define WithCrypto
Definition: ncrypt.h:160
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_prepare_template()

int mutt_prepare_template ( FILE *  fp,
struct Mailbox m,
struct Email e_new,
struct Email e,
bool  resend 
)

Prepare a message template.

Parameters
fpIf not NULL, file containing the template
mIf fp is NULL, the Mailbox containing the header with the template
e_newThe template is read into this Header
eEmail to recall/resend
resendSet if resending (as opposed to recalling a postponed msg) Resent messages enable header weeding, and also discard any existing Message-ID and Mail-Followup-To
Return values
0Success
-1Error

Definition at line 632 of file postpone.c.

634 {
635  struct Message *msg = NULL;
636  struct Body *b = NULL;
637  FILE *fp_body = NULL;
638  int rc = -1;
639  struct State s = { 0 };
640  SecurityFlags sec_type;
641  struct Envelope *protected_headers = NULL;
642 
643  if (!fp && !(msg = mx_msg_open(m, e->msgno)))
644  return -1;
645 
646  if (!fp)
647  fp = msg->fp;
648 
649  fp_body = fp;
650 
651  /* parse the message header and MIME structure */
652 
653  fseeko(fp, e->offset, SEEK_SET);
654  e_new->offset = e->offset;
655  /* enable header weeding for resent messages */
656  e_new->env = mutt_rfc822_read_header(fp, e_new, true, resend);
657  e_new->content->length = e->content->length;
658  mutt_parse_part(fp, e_new->content);
659 
660  /* If resending a message, don't keep message_id or mail_followup_to.
661  * Otherwise, we are resuming a postponed message, and want to keep those
662  * headers if they exist. */
663  if (resend)
664  {
665  FREE(&e_new->env->message_id);
666  FREE(&e_new->env->mail_followup_to);
667  }
668 
669  /* decrypt pgp/mime encoded messages */
670 
671  if (((WithCrypto & APPLICATION_PGP) != 0) &&
672  (sec_type = mutt_is_multipart_encrypted(e_new->content)))
673  {
674  e_new->security |= sec_type;
675  if (!crypt_valid_passphrase(sec_type))
676  goto bail;
677 
678  mutt_message(_("Decrypting message..."));
679  if ((crypt_pgp_decrypt_mime(fp, &fp_body, e_new->content, &b) == -1) || !b)
680  {
681  goto bail;
682  }
683 
684  mutt_body_free(&e_new->content);
685  e_new->content = b;
686 
687  if (b->mime_headers)
688  {
689  protected_headers = b->mime_headers;
690  b->mime_headers = NULL;
691  }
692 
694  }
695 
696  /* remove a potential multipart/signed layer - useful when
697  * resending messages */
698  if ((WithCrypto != 0) && mutt_is_multipart_signed(e_new->content))
699  {
700  e_new->security |= SEC_SIGN;
701  if (((WithCrypto & APPLICATION_PGP) != 0) &&
703  mutt_param_get(&e_new->content->parameter, "protocol"),
704  "application/pgp-signature") == 0))
705  {
706  e_new->security |= APPLICATION_PGP;
707  }
708  else if (WithCrypto & APPLICATION_SMIME)
709  e_new->security |= APPLICATION_SMIME;
710 
711  /* destroy the signature */
712  mutt_body_free(&e_new->content->parts->next);
713  e_new->content = mutt_remove_multipart(e_new->content);
714 
715  if (e_new->content->mime_headers)
716  {
717  mutt_env_free(&protected_headers);
718  protected_headers = e_new->content->mime_headers;
719  e_new->content->mime_headers = NULL;
720  }
721  }
722 
723  /* We don't need no primary multipart.
724  * Note: We _do_ preserve messages!
725  *
726  * XXX - we don't handle multipart/alternative in any
727  * smart way when sending messages. However, one may
728  * consider this a feature. */
729  if (e_new->content->type == TYPE_MULTIPART)
730  e_new->content = mutt_remove_multipart(e_new->content);
731 
732  s.fp_in = fp_body;
733 
734  struct Buffer *file = mutt_buffer_pool_get();
735 
736  /* create temporary files for all attachments */
737  for (b = e_new->content; b; b = b->next)
738  {
739  /* what follows is roughly a receive-mode variant of
740  * mutt_get_tmp_attachment () from muttlib.c */
741 
742  mutt_buffer_reset(file);
743  if (b->filename)
744  {
745  mutt_buffer_strcpy(file, b->filename);
747  }
748  else
749  {
750  /* avoid Content-Disposition: header with temporary filename */
751  b->use_disp = false;
752  }
753 
754  /* set up state flags */
755 
756  s.flags = 0;
757 
758  if (b->type == TYPE_TEXT)
759  {
760  if (mutt_str_strcasecmp("yes",
761  mutt_param_get(&b->parameter, "x-mutt-noconv")) == 0)
762  {
763  b->noconv = true;
764  }
765  else
766  {
767  s.flags |= MUTT_CHARCONV;
768  b->noconv = false;
769  }
770 
771  mutt_param_delete(&b->parameter, "x-mutt-noconv");
772  }
773 
774  mutt_adv_mktemp(file);
775  s.fp_out = mutt_file_fopen(mutt_b2s(file), "w");
776  if (!s.fp_out)
777  goto bail;
778 
779  if (((WithCrypto & APPLICATION_PGP) != 0) &&
780  ((sec_type = mutt_is_application_pgp(b)) & (SEC_ENCRYPT | SEC_SIGN)))
781  {
782  if (sec_type & SEC_ENCRYPT)
783  {
784  if (!crypt_valid_passphrase(APPLICATION_PGP))
785  goto bail;
786  mutt_message(_("Decrypting message..."));
787  }
788 
789  if (mutt_body_handler(b, &s) < 0)
790  {
791  mutt_error(_("Decryption failed"));
792  goto bail;
793  }
794 
795  if ((b == e_new->content) && !protected_headers)
796  {
797  protected_headers = b->mime_headers;
798  b->mime_headers = NULL;
799  }
800 
801  e_new->security |= sec_type;
802  b->type = TYPE_TEXT;
803  mutt_str_replace(&b->subtype, "plain");
804  mutt_param_delete(&b->parameter, "x-action");
805  }
806  else if (((WithCrypto & APPLICATION_SMIME) != 0) &&
807  ((sec_type = mutt_is_application_smime(b)) & (SEC_ENCRYPT | SEC_SIGN)))
808  {
809  if (sec_type & SEC_ENCRYPT)
810  {
811  if (!crypt_valid_passphrase(APPLICATION_SMIME))
812  goto bail;
813  crypt_smime_getkeys(e_new->env);
814  mutt_message(_("Decrypting message..."));
815  }
816 
817  if (mutt_body_handler(b, &s) < 0)
818  {
819  mutt_error(_("Decryption failed"));
820  goto bail;
821  }
822 
823  e_new->security |= sec_type;
824  b->type = TYPE_TEXT;
825  mutt_str_replace(&b->subtype, "plain");
826  }
827  else
828  mutt_decode_attachment(b, &s);
829 
830  if (mutt_file_fclose(&s.fp_out) != 0)
831  goto bail;
832 
833  mutt_str_replace(&b->filename, mutt_b2s(file));
834  b->unlink = true;
835 
837 
838  mutt_body_free(&b->parts);
839  if (b->email)
840  b->email->content = NULL; /* avoid dangling pointer */
841  }
842 
843  if (C_CryptProtectedHeadersRead && protected_headers && protected_headers->subject &&
844  (mutt_str_strcmp(e_new->env->subject, protected_headers->subject) != 0))
845  {
846  mutt_str_replace(&e_new->env->subject, protected_headers->subject);
847  }
848  mutt_env_free(&protected_headers);
849 
850  /* Fix encryption flags. */
851 
852  /* No inline if multipart. */
853  if ((WithCrypto != 0) && (e_new->security & SEC_INLINE) && e_new->content->next)
854  e_new->security &= ~SEC_INLINE;
855 
856  /* Do we even support multiple mechanisms? */
857  e_new->security &= WithCrypto | ~(APPLICATION_PGP | APPLICATION_SMIME);
858 
859  /* Theoretically, both could be set. Take the one the user wants to set by default. */
860  if ((e_new->security & APPLICATION_PGP) && (e_new->security & APPLICATION_SMIME))
861  {
862  if (C_SmimeIsDefault)
863  e_new->security &= ~APPLICATION_PGP;
864  else
865  e_new->security &= ~APPLICATION_SMIME;
866  }
867 
869 
870  rc = 0;
871 
872 bail:
873 
874  /* that's it. */
876  if (fp_body != fp)
877  mutt_file_fclose(&fp_body);
878  if (msg)
879  mx_msg_close(m, &msg);
880 
881  if (rc == -1)
882  {
883  mutt_env_free(&e_new->env);
884  mutt_body_free(&e_new->content);
885  }
886 
887  return rc;
888 }
void mutt_decode_attachment(struct Body *b, struct State *s)
Decode an email&#39;s attachment.
Definition: handler.c:1795
void mutt_stamp_attachment(struct Body *a)
Timestamp an Attachment.
Definition: sendlib.c:1448
char * filename
when sending a message, this is the file to which this structure refers
Definition: body.h:46
struct Envelope * mime_headers
Memory hole protected headers.
Definition: body.h:63
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:79
struct Body * mutt_remove_multipart(struct Body *b)
Extract the multipart body if it exists.
Definition: sendlib.c:1772
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
struct AddressList mail_followup_to
Email&#39;s &#39;mail-followup-to&#39;.
Definition: envelope.h:63
#define MUTT_CHARCONV
Do character set conversions.
Definition: state.h:36
#define mutt_message(...)
Definition: logging.h:83
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Body * content
List of MIME parts.
Definition: email.h:90
bool noconv
Don&#39;t do character set conversion.
Definition: body.h:73
String manipulation buffer.
Definition: buffer.h:33
#define _(a)
Definition: message.h:28
struct Body * next
next attachment in the list
Definition: body.h:53
FILE * fp_out
File to write to.
Definition: state.h:47
#define SEC_INLINE
Email has an inline signature.
Definition: ncrypt.h:129
#define SEC_ENCRYPT
Email is encrypted.
Definition: ncrypt.h:122
FILE * fp_in
File to read from.
Definition: state.h:46
The body of an email.
Definition: body.h:34
WHERE bool C_SmimeIsDefault
Config: Use SMIME rather than PGP by default.
Definition: globals.h:273
StateFlags flags
Flags, e.g. MUTT_DISPLAY.
Definition: state.h:49
int mx_msg_close(struct Mailbox *m, struct Message **msg)
Close a message.
Definition: mx.c:1140
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:145
char * message_id
Message ID.
Definition: envelope.h:69
SecurityFlags mutt_is_multipart_encrypted(struct Body *b)
Does the message have encrypted parts?
Definition: crypt.c:451
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
struct Envelope * env
Envelope information.
Definition: email.h:89
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:410
void mutt_rfc3676_space_unstuff(struct Email *e)
Remove RFC3676 space stuffing.
Definition: rfc3676.c:485
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:113
char * subtype
content-type subtype
Definition: body.h:37
void mutt_param_delete(struct ParameterList *pl, const char *attribute)
Delete a matching Parameter.
Definition: parameter.c:142
#define mutt_b2s(buf)
Definition: buffer.h:41
SecurityFlags mutt_is_application_pgp(struct Body *m)
Does the message use PGP?
Definition: crypt.c:557
#define SEC_SIGN
Email is signed.
Definition: ncrypt.h:123
A local copy of an email.
Definition: mx.h:81
LOFF_T length
length (in bytes) of attachment
Definition: body.h:45
Type: &#39;text/*&#39;.
Definition: mime.h:38
void mutt_env_free(struct Envelope **ptr)
Free an Envelope.
Definition: envelope.c:96
void crypt_smime_getkeys(struct Envelope *env)
Wrapper for CryptModuleSpecs::smime_getkeys()
Definition: cryptglue.c:451
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
SecurityFlags mutt_is_application_smime(struct Body *m)
Does the message use S/MIME?
Definition: crypt.c:616
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/ncrypt.h pgplib.h, smime.h
Definition: email.h:39
WHERE bool C_CryptProtectedHeadersRead
Config: Display protected headers (Memory Hole) in the pager.
Definition: globals.h:270
void mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:453
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:312
unsigned int type
content-type primary type
Definition: body.h:65
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:83
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: ncrypt.h:134
void mutt_parse_part(FILE *fp, struct Body *b)
Parse a MIME part.
Definition: parse.c:1406
int crypt_pgp_decrypt_mime(FILE *fp_in, FILE **fp_out, struct Body *b, struct Body **cur)
Wrapper for CryptModuleSpecs::decrypt_mime()
Definition: cryptglue.c:203
char * subject
Email&#39;s subject.
Definition: envelope.h:66
Type: &#39;multipart/*&#39;.
Definition: mime.h:37
bool use_disp
Content-Disposition uses filename= ?
Definition: body.h:68
char * mutt_str_strdup(const char *str)
Copy a string, safely.
Definition: string.c:380
#define mutt_error(...)
Definition: logging.h:84
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:69
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:628
FILE * fp
pointer to the message data
Definition: mx.h:83
void mutt_adv_mktemp(struct Buffer *buf)
Create a temporary file.
Definition: muttlib.c:95
#define FREE(x)
Definition: memory.h:40
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
Keep track when processing files.
Definition: state.h:44
int mutt_body_handler(struct Body *b, struct State *s)
Handler for the Body of an email.
Definition: handler.c:1551
char * d_filename
filename to be used for the content-disposition header.
Definition: body.h:47
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: ncrypt.h:120
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:585
struct Envelope * mutt_rfc822_read_header(FILE *fp, struct Email *e, bool user_hdrs, bool weed)
parses an RFC822 header
Definition: parse.c:1136
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
struct Email * email
header information for message/rfc822
Definition: body.h:55
#define WithCrypto
Definition: ncrypt.h:160
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:615
struct Message * mx_msg_open(struct Mailbox *m, int msgno)
return a stream pointer for a message
Definition: mx.c:1092
The header of an Email.
Definition: envelope.h:54
int msgno
Number displayed to the user.
Definition: email.h:86
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: ncrypt.h:135
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ PostponeHelp

const struct Mapping PostponeHelp[]
static
Initial value:
= {
{ N_("Exit"), OP_EXIT },
{ N_("Del"), OP_DELETE },
{ N_("Undel"), OP_UNDELETE },
{ N_("Help"), OP_HELP },
{ NULL, 0 },
}
#define N_(a)
Definition: message.h:32

Definition at line 67 of file postpone.c.

◆ PostCount

short PostCount = 0
static

Definition at line 75 of file postpone.c.

◆ UpdateNumPostponed

bool UpdateNumPostponed = false
static

Definition at line 76 of file postpone.c.