NeoMutt  2020-08-21-74-g346364
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/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "ncrypt/lib.h"
#include "pattern/lib.h"
#include "send/lib.h"
#include "context.h"
#include "format_flags.h"
#include "handler.h"
#include "hdrline.h"
#include "keymap.h"
#include "mutt_globals.h"
#include "mutt_logging.h"
#include "mutt_menu.h"
#include "mutt_thread.h"
#include "muttlib.h"
#include "mx.h"
#include "opcodes.h"
#include "options.h"
#include "protos.h"
#include "rfc3676.h"
#include "sort.h"
#include "state.h"
#include "imap/lib.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::make_entry() More...
 
static struct Emaildlg_select_postponed_email (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 []
 Help Bar for the Postponed email selection dialog. More...
 
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 89 of file postpone.c.

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

203 {
204  UpdateNumPostponed = true;
205 }
static bool UpdateNumPostponed
Definition: postpone.c:79
+ 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::make_entry()

Definition at line 210 of file postpone.c.

211 {
212  struct Context *ctx = menu->mdata;
213 
214  mutt_make_string_flags(buf, buflen, menu->win_index->state.cols,
216  ctx->mailbox->emails[line], MUTT_FORMAT_ARROWCURSOR);
217 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
The "current" mailbox.
Definition: context.h:38
#define NONULL(x)
Definition: string2.h:37
void mutt_make_string_flags(char *buf, size_t buflen, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1403
int msg_in_pager
Message currently shown in the pager.
Definition: context.h:44
#define MUTT_FORMAT_ARROWCURSOR
Reserve space for arrow_cursor.
Definition: format_flags.h:35
struct Mailbox * mailbox
Definition: context.h:50
WHERE char * C_IndexFormat
Config: printf-like format string for the index menu (emails)
Definition: mutt_globals.h:92
short cols
Number of columns, can be MUTT_WIN_SIZE_UNLIMITED.
Definition: mutt_window.h:57
struct WindowState state
Current state of the Window.
Definition: mutt_window.h:120
void * mdata
Extra data for the current menu.
Definition: mutt_menu.h:55
struct MuttWindow * win_index
Definition: mutt_menu.h:63
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dlg_select_postponed_email()

static struct Email* dlg_select_postponed_email ( struct Context ctx)
static

Create a Menu to select a postponed message.

Parameters
ctxContext
Return values
ptrEmail

Definition at line 224 of file postpone.c.

225 {
226  int r = -1;
227  bool done = false;
228 
229  struct Menu *menu = mutt_menu_new(MENU_POSTPONE);
231  dlg->help_data = PostponeHelp;
232  dlg->help_menu = MENU_POSTPONE;
233 
234  menu->make_entry = post_make_entry;
235  menu->max = ctx->mailbox->msg_count;
236  menu->title = _("Postponed Messages");
237  menu->mdata = ctx;
238  menu->custom_search = true;
240 
241  /* The postponed mailbox is setup to have sorting disabled, but the global
242  * C_Sort variable may indicate something different. Sorting has to be
243  * disabled while the postpone menu is being displayed. */
244  const short orig_sort = C_Sort;
245  C_Sort = SORT_ORDER;
246 
247  while (!done)
248  {
249  const int op = mutt_menu_loop(menu);
250  switch (op)
251  {
252  case OP_DELETE:
253  case OP_UNDELETE:
254  /* should deleted draft messages be saved in the trash folder? */
255  mutt_set_flag(ctx->mailbox, ctx->mailbox->emails[menu->current],
256  MUTT_DELETE, (op == OP_DELETE));
258  if (C_Resolve && (menu->current < menu->max - 1))
259  {
260  menu->oldcurrent = menu->current;
261  menu->current++;
262  if (menu->current >= menu->top + menu->pagelen)
263  {
264  menu->top = menu->current;
265  menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
266  }
267  else
268  menu->redraw |= REDRAW_MOTION_RESYNC;
269  }
270  else
271  menu->redraw |= REDRAW_CURRENT;
272  break;
273 
274  // All search operations must exist to show the menu
275  case OP_SEARCH_REVERSE:
276  case OP_SEARCH_NEXT:
277  case OP_SEARCH_OPPOSITE:
278  case OP_SEARCH:
279  menu->current = mutt_search_command(ctx->mailbox, menu->current, op);
280  if (menu->current == -1)
281  menu->current = menu->oldcurrent;
282  else
283  menu->redraw = REDRAW_MOTION;
284  break;
285 
286  case OP_GENERIC_SELECT_ENTRY:
287  r = menu->current;
288  done = true;
289  break;
290 
291  case OP_EXIT:
292  done = true;
293  break;
294  }
295  }
296 
297  C_Sort = orig_sort;
298  mutt_menu_pop_current(menu);
299  mutt_menu_free(&menu);
301 
302  return (r > -1) ? ctx->mailbox->emails[r] : NULL;
303 }
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
static const struct Mapping PostponeHelp[]
Help Bar for the Postponed email selection dialog.
Definition: postpone.c:68
int msg_count
Total number of messages.
Definition: mailbox.h:91
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:67
GUI selectable list of items.
Definition: mutt_menu.h:52
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:96
int help_menu
Menu for key bindings, e.g. MENU_PAGER.
Definition: mutt_window.h:134
int oldcurrent
For driver use only.
Definition: mutt_menu.h:76
#define _(a)
Definition: message.h:28
A division of the screen.
Definition: mutt_window.h:115
struct MuttWindow * dialog_create_simple_index(struct Menu *menu, enum WindowType type)
Create a simple index Dialog.
Definition: dialog.c:165
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::make_entry()
Definition: postpone.c:210
int mutt_search_command(struct Mailbox *mailbox, int cur, int op)
Perform a search.
Definition: pattern.c:377
struct Mailbox * mailbox
Definition: context.h:50
Sort by the order the messages appear in the mailbox.
Definition: sort2.h:51
const char * title
Title of this menu.
Definition: mutt_menu.h:54
WHERE short C_Sort
Config: Sort method for the index.
Definition: sort.h:60
#define REDRAW_MOTION
Redraw after moving the menu list.
Definition: mutt_menu.h:41
#define REDRAW_MOTION_RESYNC
Redraw any changing the menu selection.
Definition: mutt_menu.h:42
void * mdata
Extra data for the current menu.
Definition: mutt_menu.h:55
#define REDRAW_STATUS
Redraw the status bar.
Definition: mutt_menu.h:44
Messages to be deleted.
Definition: mutt.h:98
int top
Entry that is the top of the current page.
Definition: mutt_menu.h:75
const struct Mapping * help_data
Data for the Help Bar.
Definition: mutt_window.h:135
void dialog_destroy_simple_index(struct MuttWindow **ptr)
Destroy a simple index Dialog.
Definition: dialog.c:209
static short PostCount
Definition: postpone.c:78
bool custom_search
The menu implements its own non-Menusearch()-compatible search, trickle OP_SEARCH*.
Definition: mutt_menu.h:79
int pagelen
Number of entries per screen.
Definition: mutt_menu.h:60
int max
Number of entries in the menu.
Definition: mutt_menu.h:57
MuttRedrawFlags redraw
When to redraw the screen.
Definition: mutt_menu.h:58
#define REDRAW_INDEX
Redraw the index.
Definition: mutt_menu.h:40
Postpone Dialog, dlg_select_postponed_email()
Definition: mutt_window.h:86
int current
Current entry.
Definition: mutt_menu.h:56
void(* make_entry)(char *buf, size_t buflen, struct Menu *menu, int line)
Format a item for a menu.
Definition: mutt_menu.h:88
Select a postponed email.
Definition: keymap.h:82
#define REDRAW_CURRENT
Redraw the current line of the menu.
Definition: mutt_menu.h:43
WHERE bool C_Resolve
Config: Move to the next email whenever a command modifies an email.
Definition: mutt_globals.h:154
+ 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 315 of file postpone.c.

317 {
318  if (!C_Postponed)
319  return -1;
320 
321  struct Email *e = NULL;
322  int rc = SEND_POSTPONED;
323  int rc_close;
324  const char *p = NULL;
325  struct Context *ctx_post = NULL;
326 
327  struct Mailbox *m = mx_path_resolve(C_Postponed);
328  if (ctx && (ctx->mailbox == m))
329  ctx_post = ctx;
330  else
331  ctx_post = mx_mbox_open(m, MUTT_NOSORT);
332 
333  if (!ctx_post)
334  {
335  PostCount = 0;
336  mutt_error(_("No postponed messages"));
337  mailbox_free(&m);
338  return -1;
339  }
340 
341  /* TODO:
342  * mx_mbox_open() for IMAP leaves IMAP_REOPEN_ALLOW set. For the
343  * index this is papered-over because it calls mx_check_mailbox()
344  * every event loop(which resets that flag).
345  *
346  * For a stable-branch fix, I'm doing the same here, to prevent
347  * context changes from occuring behind the scenes and causing
348  * segvs, but probably the flag needs to be reset after downloading
349  * headers in imap_open_mailbox().
350  */
351  mx_mbox_check(ctx_post->mailbox);
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_fastclose_mailbox(ctx_post->mailbox);
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 = dlg_select_postponed_email(ctx_post)))
370  {
371  if (ctx_post == ctx)
372  ctx_post = NULL;
373  else
374  {
375  /* messages might have been marked for deletion.
376  * try once more on reopen before giving up. */
377  rc_close = mx_mbox_close(&ctx_post);
378  if (rc_close > 0)
379  rc_close = mx_mbox_close(&ctx_post);
380  if (rc_close != 0)
381  mx_fastclose_mailbox(ctx_post->mailbox);
382  }
383  return -1;
384  }
385 
386  if (mutt_prepare_template(NULL, ctx_post->mailbox, hdr, e, false) < 0)
387  {
388  if (ctx_post != ctx)
389  {
390  mx_fastclose_mailbox(ctx_post->mailbox);
391  FREE(&ctx_post);
392  }
393  return -1;
394  }
395 
396  /* finished with this message, so delete it. */
397  mutt_set_flag(ctx_post->mailbox, e, MUTT_DELETE, true);
398  mutt_set_flag(ctx_post->mailbox, e, MUTT_PURGE, true);
399 
400  /* update the count for the status display */
401  PostCount = ctx_post->mailbox->msg_count - ctx_post->mailbox->msg_deleted;
402 
403  /* avoid the "purge deleted messages" prompt */
404  int opt_delete = C_Delete;
405  C_Delete = MUTT_YES;
406  if (ctx_post == ctx)
407  ctx_post = NULL;
408  else
409  {
410  rc_close = mx_mbox_close(&ctx_post);
411  if (rc_close > 0)
412  rc_close = mx_mbox_close(&ctx_post);
413  if (rc_close != 0)
414  mx_fastclose_mailbox(ctx_post->mailbox);
415  }
416  C_Delete = opt_delete;
417 
418  struct ListNode *np = NULL, *tmp = NULL;
419  STAILQ_FOREACH_SAFE(np, &hdr->env->userhdrs, entries, tmp)
420  {
421  size_t plen = mutt_istr_startswith(np->data, "X-Mutt-References:");
422  if (plen)
423  {
424  /* if a mailbox is currently open, look to see if the original message
425  * the user attempted to reply to is in this mailbox */
426  p = mutt_str_skip_email_wsp(np->data + plen);
427  if (!ctx->mailbox->id_hash)
429  *cur = mutt_hash_find(ctx->mailbox->id_hash, p);
430 
431  if (*cur)
432  rc |= SEND_REPLY;
433  }
434  else if ((plen = mutt_istr_startswith(np->data, "X-Mutt-Fcc:")))
435  {
436  p = mutt_str_skip_email_wsp(np->data + plen);
437  mutt_buffer_strcpy(fcc, p);
439 
440  /* note that x-mutt-fcc was present. we do this because we want to add a
441  * default fcc if the header was missing, but preserve the request of the
442  * user to not make a copy if the header field is present, but empty.
443  * see http://dev.mutt.org/trac/ticket/3653 */
444  rc |= SEND_POSTPONED_FCC;
445  }
446  else if (((WithCrypto & APPLICATION_PGP) != 0) &&
447  /* this is generated by old neomutt versions */
448  (mutt_str_startswith(np->data, "Pgp:") ||
449  /* this is the new way */
450  mutt_str_startswith(np->data, "X-Mutt-PGP:")))
451  {
452  hdr->security = mutt_parse_crypt_hdr(strchr(np->data, ':') + 1, true, APPLICATION_PGP);
453  hdr->security |= APPLICATION_PGP;
454  }
455  else if (((WithCrypto & APPLICATION_SMIME) != 0) &&
456  mutt_str_startswith(np->data, "X-Mutt-SMIME:"))
457  {
458  hdr->security = mutt_parse_crypt_hdr(strchr(np->data, ':') + 1, true, APPLICATION_SMIME);
459  hdr->security |= APPLICATION_SMIME;
460  }
461 #ifdef MIXMASTER
462  else if (mutt_str_startswith(np->data, "X-Mutt-Mix:"))
463  {
464  mutt_list_free(&hdr->chain);
465 
466  char *t = strtok(np->data + 11, " \t\n");
467  while (t)
468  {
470  t = strtok(NULL, " \t\n");
471  }
472  }
473 #endif
474  else
475  {
476  // skip header removal
477  continue;
478  }
479 
480  // remove the header
481  STAILQ_REMOVE(&hdr->env->userhdrs, np, ListNode, entries);
482  FREE(&np->data);
483  FREE(&np);
484  }
485 
488 
489  return rc;
490 }
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:354
struct Email ** emails
Array of Emails.
Definition: mailbox.h:99
The "current" mailbox.
Definition: context.h:38
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:399
int msg_count
Total number of messages.
Definition: mailbox.h:91
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:67
#define WithCrypto
Definition: lib.h:123
#define SEND_POSTPONED_FCC
Used by mutt_get_postponed() to signal that the x-mutt-fcc header field was present.
Definition: send.h:49
The envelope/body of an email.
Definition: email.h:37
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:96
int mx_mbox_close(struct Context **ptr)
Save changes and close mailbox.
Definition: mx.c:630
static size_t plen
Length of cached packet.
Definition: pgppacket.c:39
struct HashTable * mutt_make_id_hash(struct Mailbox *m)
Create a Hash Table for message-ids.
Definition: mutt_thread.c:1521
static struct Email * dlg_select_postponed_email(struct Context *ctx)
Create a Menu to select a postponed message.
Definition: postpone.c:224
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:370
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:303
Messages to be purged (bypass trash)
Definition: mutt.h:100
#define SEND_POSTPONED
Recall a postponed email.
Definition: send.h:45
void mutt_buffer_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using &#39;~&#39; or &#39;=&#39;.
Definition: muttlib.c:598
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:122
struct Mailbox * mailbox
Definition: context.h:50
struct HashTable * id_hash
Hash Table by msg id.
Definition: mailbox.h:127
bool C_CryptOpportunisticEncrypt
Config: Enable encryption when the recipient&#39;s key is available.
Definition: config.c:56
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:60
struct Envelope * env
Envelope information.
Definition: email.h:90
void mx_fastclose_mailbox(struct Mailbox *m)
free up memory associated with the Mailbox
Definition: mx.c:445
#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:64
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
struct ListHead chain
Mixmaster chain.
Definition: email.h:102
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:160
Messages to be deleted.
Definition: mutt.h:98
A mailbox.
Definition: mailbox.h:81
#define MUTT_NOSORT
Do not sort the mailbox after opening it.
Definition: mx.h:52
static short PostCount
Definition: postpone.c:78
char * mutt_str_skip_email_wsp(const char *s)
Skip over whitespace as defined by RFC5322.
Definition: string.c:743
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition: string.c:172
int mx_mbox_check(struct Mailbox *m)
Check for new mail - Wrapper for MxOps::mbox_check()
Definition: mx.c:1139
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
#define SEND_REPLY
Reply to sender.
Definition: send.h:41
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:312
SecurityFlags mutt_parse_crypt_hdr(const char *p, bool set_empty_signas, SecurityFlags crypt_app)
Parse a crypto header string.
Definition: postpone.c:499
void crypt_opportunistic_encrypt(struct Email *e)
Can all recipients be determined.
Definition: crypt.c:1021
char * data
String.
Definition: list.h:36
WHERE unsigned char C_Delete
Config: Really delete messages, when the mailbox is closed.
Definition: mutt_globals.h:125
#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:1696
A List node for strings.
Definition: list.h:34
WHERE char * C_Postponed
Config: Folder to store postponed messages.
Definition: mutt_globals.h:101
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:655
User answered &#39;Yes&#39;, or assume &#39;Yes&#39;.
Definition: quad.h:40
+ 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 499 of file postpone.c.

500 {
501  char smime_cryptalg[1024] = { 0 };
502  char sign_as[1024] = { 0 };
503  char *q = NULL;
504  SecurityFlags flags = SEC_NO_FLAGS;
505 
506  if (!WithCrypto)
507  return SEC_NO_FLAGS;
508 
510  for (; p[0] != '\0'; p++)
511  {
512  switch (p[0])
513  {
514  case 'c':
515  case 'C':
516  q = smime_cryptalg;
517 
518  if (p[1] == '<')
519  {
520  for (p += 2; (p[0] != '\0') && (p[0] != '>') &&
521  (q < (smime_cryptalg + sizeof(smime_cryptalg) - 1));
522  *q++ = *p++)
523  {
524  }
525 
526  if (p[0] != '>')
527  {
528  mutt_error(_("Illegal S/MIME header"));
529  return SEC_NO_FLAGS;
530  }
531  }
532 
533  *q = '\0';
534  break;
535 
536  case 'e':
537  case 'E':
538  flags |= SEC_ENCRYPT;
539  break;
540 
541  case 'i':
542  case 'I':
543  flags |= SEC_INLINE;
544  break;
545 
546  /* This used to be the micalg parameter.
547  *
548  * It's no longer needed, so we just skip the parameter in order
549  * to be able to recall old messages. */
550  case 'm':
551  case 'M':
552  if (p[1] != '<')
553  break;
554 
555  for (p += 2; (p[0] != '\0') && (p[0] != '>'); p++)
556  ; // do nothing
557 
558  if (p[0] != '>')
559  {
560  mutt_error(_("Illegal crypto header"));
561  return SEC_NO_FLAGS;
562  }
563  break;
564 
565  case 'o':
566  case 'O':
567  flags |= SEC_OPPENCRYPT;
568  break;
569 
570  case 'a':
571  case 'A':
572 #ifdef USE_AUTOCRYPT
573  flags |= SEC_AUTOCRYPT;
574 #endif
575  break;
576 
577  case 'z':
578  case 'Z':
579 #ifdef USE_AUTOCRYPT
580  flags |= SEC_AUTOCRYPT_OVERRIDE;
581 #endif
582  break;
583 
584  case 's':
585  case 'S':
586  flags |= SEC_SIGN;
587  q = sign_as;
588 
589  if (p[1] == '<')
590  {
591  for (p += 2;
592  (p[0] != '\0') && (*p != '>') && (q < (sign_as + sizeof(sign_as) - 1));
593  *q++ = *p++)
594  {
595  }
596 
597  if (p[0] != '>')
598  {
599  mutt_error(_("Illegal crypto header"));
600  return SEC_NO_FLAGS;
601  }
602  }
603 
604  q[0] = '\0';
605  break;
606 
607  default:
608  mutt_error(_("Illegal crypto header"));
609  return SEC_NO_FLAGS;
610  }
611  }
612 
613  /* the cryptalg field must not be empty */
614  if (((WithCrypto & APPLICATION_SMIME) != 0) && *smime_cryptalg)
615  {
616  struct Buffer errmsg = mutt_buffer_make(0);
617  int rc = cs_subset_str_string_set(NeoMutt->sub, "smime_encrypt_with",
618  smime_cryptalg, &errmsg);
619 
620  if ((CSR_RESULT(rc) != CSR_SUCCESS) && !mutt_buffer_is_empty(&errmsg))
621  mutt_error("%s", mutt_b2s(&errmsg));
622 
623  mutt_buffer_dealloc(&errmsg);
624  }
625 
626  /* Set {Smime,Pgp}SignAs, if desired. */
627 
628  if (((WithCrypto & APPLICATION_PGP) != 0) && (crypt_app == APPLICATION_PGP) &&
629  (flags & SEC_SIGN) && (set_empty_signas || *sign_as))
630  {
631  mutt_str_replace(&C_PgpSignAs, sign_as);
632  }
633 
634  if (((WithCrypto & APPLICATION_SMIME) != 0) && (crypt_app == APPLICATION_SMIME) &&
635  (flags & SEC_SIGN) && (set_empty_signas || *sign_as))
636  {
637  mutt_str_replace(&C_SmimeSignAs, sign_as);
638  }
639 
640  return flags;
641 }
#define CSR_SUCCESS
Action completed successfully.
Definition: set.h:35
#define WithCrypto
Definition: lib.h:123
#define SEC_NO_FLAGS
No flags are set.
Definition: lib.h:84
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
#define _(a)
Definition: message.h:28
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:94
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:83
Container for Accounts, Notifications.
Definition: neomutt.h:36
#define CSR_RESULT(x)
Definition: set.h:52
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:92
int cs_subset_str_string_set(const struct ConfigSubset *sub, const char *name, const char *value, struct Buffer *err)
Set a config item by string.
Definition: subset.c:395
char * C_PgpSignAs
Config: Use this alternative key for signing messages.
Definition: config.c:67
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
#define mutt_b2s(buf)
Definition: buffer.h:41
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
#define SEC_AUTOCRYPT_OVERRIDE
(Autocrypt) Indicates manual set/unset of encryption
Definition: lib.h:95
char * mutt_str_skip_email_wsp(const char *s)
Skip over whitespace as defined by RFC5322.
Definition: string.c:743
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:93
char * C_SmimeSignAs
Config: Use this alternative key for signing messages.
Definition: config.c:70
#define SEC_SIGN
Email is signed.
Definition: lib.h:86
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:446
#define mutt_error(...)
Definition: logging.h:84
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
+ 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 655 of file postpone.c.

657 {
658  struct Message *msg = NULL;
659  struct Body *b = NULL;
660  FILE *fp_body = NULL;
661  int rc = -1;
662  struct State s = { 0 };
663  SecurityFlags sec_type;
664  struct Envelope *protected_headers = NULL;
665 
666  if (!fp && !(msg = mx_msg_open(m, e->msgno)))
667  return -1;
668 
669  if (!fp)
670  fp = msg->fp;
671 
672  fp_body = fp;
673 
674  /* parse the message header and MIME structure */
675 
676  fseeko(fp, e->offset, SEEK_SET);
677  e_new->offset = e->offset;
678  /* enable header weeding for resent messages */
679  e_new->env = mutt_rfc822_read_header(fp, e_new, true, resend);
680  e_new->body->length = e->body->length;
681  mutt_parse_part(fp, e_new->body);
682 
683  /* If resending a message, don't keep message_id or mail_followup_to.
684  * Otherwise, we are resuming a postponed message, and want to keep those
685  * headers if they exist. */
686  if (resend)
687  {
688  FREE(&e_new->env->message_id);
689  FREE(&e_new->env->mail_followup_to);
690  }
691 
692  /* decrypt pgp/mime encoded messages */
693 
694  if (((WithCrypto & APPLICATION_PGP) != 0) &&
695  (sec_type = mutt_is_multipart_encrypted(e_new->body)))
696  {
697  e_new->security |= sec_type;
698  if (!crypt_valid_passphrase(sec_type))
699  goto bail;
700 
701  mutt_message(_("Decrypting message..."));
702  if ((crypt_pgp_decrypt_mime(fp, &fp_body, e_new->body, &b) == -1) || !b)
703  {
704  goto bail;
705  }
706 
707  mutt_body_free(&e_new->body);
708  e_new->body = b;
709 
710  if (b->mime_headers)
711  {
712  protected_headers = b->mime_headers;
713  b->mime_headers = NULL;
714  }
715 
717  }
718 
719  /* remove a potential multipart/signed layer - useful when
720  * resending messages */
721  if ((WithCrypto != 0) && mutt_is_multipart_signed(e_new->body))
722  {
723  e_new->security |= SEC_SIGN;
724  if (((WithCrypto & APPLICATION_PGP) != 0) &&
725  mutt_istr_equal(mutt_param_get(&e_new->body->parameter, "protocol"),
726  "application/pgp-signature"))
727  {
728  e_new->security |= APPLICATION_PGP;
729  }
730  else if (WithCrypto & APPLICATION_SMIME)
731  e_new->security |= APPLICATION_SMIME;
732 
733  /* destroy the signature */
734  mutt_body_free(&e_new->body->parts->next);
735  e_new->body = mutt_remove_multipart(e_new->body);
736 
737  if (e_new->body->mime_headers)
738  {
739  mutt_env_free(&protected_headers);
740  protected_headers = e_new->body->mime_headers;
741  e_new->body->mime_headers = NULL;
742  }
743  }
744 
745  /* We don't need no primary multipart.
746  * Note: We _do_ preserve messages!
747  *
748  * XXX - we don't handle multipart/alternative in any
749  * smart way when sending messages. However, one may
750  * consider this a feature. */
751  if (e_new->body->type == TYPE_MULTIPART)
752  e_new->body = mutt_remove_multipart(e_new->body);
753 
754  s.fp_in = fp_body;
755 
756  struct Buffer *file = mutt_buffer_pool_get();
757 
758  /* create temporary files for all attachments */
759  for (b = e_new->body; b; b = b->next)
760  {
761  /* what follows is roughly a receive-mode variant of
762  * mutt_get_tmp_attachment () from muttlib.c */
763 
764  mutt_buffer_reset(file);
765  if (b->filename)
766  {
767  mutt_buffer_strcpy(file, b->filename);
769  }
770  else
771  {
772  /* avoid Content-Disposition: header with temporary filename */
773  b->use_disp = false;
774  }
775 
776  /* set up state flags */
777 
778  s.flags = 0;
779 
780  if (b->type == TYPE_TEXT)
781  {
782  if (mutt_istr_equal("yes",
783  mutt_param_get(&b->parameter, "x-mutt-noconv")))
784  {
785  b->noconv = true;
786  }
787  else
788  {
789  s.flags |= MUTT_CHARCONV;
790  b->noconv = false;
791  }
792 
793  mutt_param_delete(&b->parameter, "x-mutt-noconv");
794  }
795 
796  mutt_adv_mktemp(file);
797  s.fp_out = mutt_file_fopen(mutt_b2s(file), "w");
798  if (!s.fp_out)
799  goto bail;
800 
801  if (((WithCrypto & APPLICATION_PGP) != 0) &&
802  ((sec_type = mutt_is_application_pgp(b)) & (SEC_ENCRYPT | SEC_SIGN)))
803  {
804  if (sec_type & SEC_ENCRYPT)
805  {
806  if (!crypt_valid_passphrase(APPLICATION_PGP))
807  goto bail;
808  mutt_message(_("Decrypting message..."));
809  }
810 
811  if (mutt_body_handler(b, &s) < 0)
812  {
813  mutt_error(_("Decryption failed"));
814  goto bail;
815  }
816 
817  if ((b == e_new->body) && !protected_headers)
818  {
819  protected_headers = b->mime_headers;
820  b->mime_headers = NULL;
821  }
822 
823  e_new->security |= sec_type;
824  b->type = TYPE_TEXT;
825  mutt_str_replace(&b->subtype, "plain");
826  mutt_param_delete(&b->parameter, "x-action");
827  }
828  else if (((WithCrypto & APPLICATION_SMIME) != 0) &&
829  ((sec_type = mutt_is_application_smime(b)) & (SEC_ENCRYPT | SEC_SIGN)))
830  {
831  if (sec_type & SEC_ENCRYPT)
832  {
833  if (!crypt_valid_passphrase(APPLICATION_SMIME))
834  goto bail;
835  crypt_smime_getkeys(e_new->env);
836  mutt_message(_("Decrypting message..."));
837  }
838 
839  if (mutt_body_handler(b, &s) < 0)
840  {
841  mutt_error(_("Decryption failed"));
842  goto bail;
843  }
844 
845  e_new->security |= sec_type;
846  b->type = TYPE_TEXT;
847  mutt_str_replace(&b->subtype, "plain");
848  }
849  else
850  mutt_decode_attachment(b, &s);
851 
852  if (mutt_file_fclose(&s.fp_out) != 0)
853  goto bail;
854 
855  mutt_str_replace(&b->filename, mutt_b2s(file));
856  b->unlink = true;
857 
859 
860  mutt_body_free(&b->parts);
861  if (b->email)
862  b->email->body = NULL; /* avoid dangling pointer */
863  }
864 
865  if (C_CryptProtectedHeadersRead && protected_headers && protected_headers->subject &&
866  !mutt_str_equal(e_new->env->subject, protected_headers->subject))
867  {
868  mutt_str_replace(&e_new->env->subject, protected_headers->subject);
869  }
870  mutt_env_free(&protected_headers);
871 
872  /* Fix encryption flags. */
873 
874  /* No inline if multipart. */
875  if ((WithCrypto != 0) && (e_new->security & SEC_INLINE) && e_new->body->next)
876  e_new->security &= ~SEC_INLINE;
877 
878  /* Do we even support multiple mechanisms? */
879  e_new->security &= WithCrypto | ~(APPLICATION_PGP | APPLICATION_SMIME);
880 
881  /* Theoretically, both could be set. Take the one the user wants to set by default. */
882  if ((e_new->security & APPLICATION_PGP) && (e_new->security & APPLICATION_SMIME))
883  {
884  if (C_SmimeIsDefault)
885  e_new->security &= ~APPLICATION_PGP;
886  else
887  e_new->security &= ~APPLICATION_SMIME;
888  }
889 
891 
892  rc = 0;
893 
894 bail:
895 
896  /* that's it. */
898  if (fp_body != fp)
899  mutt_file_fclose(&fp_body);
900  if (msg)
901  mx_msg_close(m, &msg);
902 
903  if (rc == -1)
904  {
905  mutt_env_free(&e_new->env);
906  mutt_body_free(&e_new->body);
907  }
908 
909  return rc;
910 }
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:871
void mutt_decode_attachment(struct Body *b, struct State *s)
Decode an email&#39;s attachment.
Definition: handler.c:1843
void mutt_stamp_attachment(struct Body *a)
Timestamp an Attachment.
Definition: sendlib.c:891
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
#define WithCrypto
Definition: lib.h:123
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
struct Body * body
List of MIME parts.
Definition: email.h:91
#define MUTT_CHARCONV
Do character set conversions.
Definition: state.h:36
#define mutt_message(...)
Definition: logging.h:83
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
bool noconv
Don&#39;t do character set conversion.
Definition: body.h:73
String manipulation buffer.
Definition: buffer.h:33
bool C_CryptProtectedHeadersRead
Config: Display protected headers (Memory Hole) in the pager.
Definition: config.c:58
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:370
#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
uint16_t SecurityFlags
Flags, e.g. SEC_ENCRYPT.
Definition: lib.h:83
FILE * fp_in
File to read from.
Definition: state.h:46
The body of an email.
Definition: body.h:34
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:92
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:1206
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:134
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:447
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
struct Envelope * env
Envelope information.
Definition: email.h:90
SecurityFlags mutt_is_multipart_signed(struct Body *b)
Is a message signed?
Definition: crypt.c:407
void mutt_rfc3676_space_unstuff(struct Email *e)
Remove RFC3676 space stuffing.
Definition: rfc3676.c:492
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:113
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
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
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:98
bool C_SmimeIsDefault
Config: Use SMIME rather than PGP by default.
Definition: config.c:61
SecurityFlags mutt_is_application_pgp(struct Body *m)
Does the message use PGP?
Definition: crypt.c:552
struct Body * mutt_remove_multipart(struct Body *b)
Extract the multipart body if it exists.
Definition: multipart.c:126
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
A local copy of an email.
Definition: mx.h:82
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:455
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:54
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
SecurityFlags mutt_is_application_smime(struct Body *m)
Does the message use S/MIME?
Definition: crypt.c:610
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
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, ContentType
Definition: body.h:65
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:84
#define SEC_SIGN
Email is signed.
Definition: lib.h:86
void mutt_parse_part(FILE *fp, struct Body *b)
Parse a MIME part.
Definition: parse.c:1657
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:207
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_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:446
#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
FILE * fp
pointer to the message data
Definition: mx.h:84
void mutt_adv_mktemp(struct Buffer *buf)
Create a temporary file.
Definition: muttlib.c:90
#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:1593
char * d_filename
filename to be used for the content-disposition header.
Definition: body.h:47
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588
struct Envelope * mutt_rfc822_read_header(FILE *fp, struct Email *e, bool user_hdrs, bool weed)
parses an RFC822 header
Definition: parse.c:1111
struct ParameterList parameter
parameters of the content-type
Definition: body.h:39
struct Email * email
header information for message/rfc822
Definition: body.h:55
struct Message * mx_msg_open(struct Mailbox *m, int msgno)
return a stream pointer for a message
Definition: mx.c:1158
The header of an Email.
Definition: envelope.h:54
int msgno
Number displayed to the user.
Definition: email.h:87
+ 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

Help Bar for the Postponed email selection dialog.

Definition at line 68 of file postpone.c.

◆ PostCount

short PostCount = 0
static

Definition at line 78 of file postpone.c.

◆ UpdateNumPostponed

bool UpdateNumPostponed = false
static

Definition at line 79 of file postpone.c.