NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
Attachment Function API

Prototype for an Attachment Function. More...

+ Collaboration diagram for Attachment Function API:

Functions

static int op_attachment_collapse (struct AttachPrivateData *priv, int op)
 toggle display of subparts - Implements attach_function_t -
 
static int op_attachment_delete (struct AttachPrivateData *priv, int op)
 delete the current entry - Implements attach_function_t -
 
static int op_attachment_edit_type (struct AttachPrivateData *priv, int op)
 edit attachment content type - Implements attach_function_t -
 
static int op_attachment_pipe (struct AttachPrivateData *priv, int op)
 pipe message/attachment to a shell command - Implements attach_function_t -
 
static int op_attachment_print (struct AttachPrivateData *priv, int op)
 print the current entry - Implements attach_function_t -
 
static int op_attachment_save (struct AttachPrivateData *priv, int op)
 save message/attachment to a mailbox/file - Implements attach_function_t -
 
static int op_attachment_undelete (struct AttachPrivateData *priv, int op)
 undelete the current entry - Implements attach_function_t -
 
static int op_attachment_view (struct AttachPrivateData *priv, int op)
 view attachment using mailcap entry if necessary - Implements attach_function_t -
 
static int op_attachment_view_mailcap (struct AttachPrivateData *priv, int op)
 force viewing of attachment using mailcap - Implements attach_function_t -
 
static int op_attachment_view_pager (struct AttachPrivateData *priv, int op)
 view attachment in pager using copiousoutput mailcap - Implements attach_function_t -
 
static int op_attachment_view_text (struct AttachPrivateData *priv, int op)
 view attachment as text - Implements attach_function_t -
 
static int op_bounce_message (struct AttachPrivateData *priv, int op)
 remail a message to another user - Implements attach_function_t -
 
static int op_check_traditional (struct AttachPrivateData *priv, int op)
 check for classic PGP - Implements attach_function_t -
 
static int op_compose_to_sender (struct AttachPrivateData *priv, int op)
 compose new message to the current message sender - Implements attach_function_t -
 
static int op_exit (struct AttachPrivateData *priv, int op)
 exit this menu - Implements attach_function_t -
 
static int op_extract_keys (struct AttachPrivateData *priv, int op)
 extract supported public keys - Implements attach_function_t -
 
static int op_forget_passphrase (struct AttachPrivateData *priv, int op)
 wipe passphrases from memory - Implements attach_function_t -
 
static int op_forward_message (struct AttachPrivateData *priv, int op)
 forward a message with comments - Implements attach_function_t -
 
static int op_list_subscribe (struct AttachPrivateData *priv, int op)
 subscribe to a mailing list - Implements attach_function_t -
 
static int op_list_unsubscribe (struct AttachPrivateData *priv, int op)
 unsubscribe from a mailing list - Implements attach_function_t -
 
static int op_reply (struct AttachPrivateData *priv, int op)
 reply to a message - Implements attach_function_t -
 
static int op_resend (struct AttachPrivateData *priv, int op)
 use the current message as a template for a new one - Implements attach_function_t -
 
static int op_followup (struct AttachPrivateData *priv, int op)
 followup to newsgroup - Implements attach_function_t -
 
static int op_forward_to_group (struct AttachPrivateData *priv, int op)
 forward to newsgroup - Implements attach_function_t -
 

Detailed Description

Prototype for an Attachment Function.

Parameters
privPrivate Attach data
opOperation to perform, e.g. OP_ATTACHMENT_COLLAPSE
Return values
enumFunctionRetval

Function Documentation

◆ op_attachment_collapse()

static int op_attachment_collapse ( struct AttachPrivateData priv,
int  op 
)
static

toggle display of subparts - Implements attach_function_t -

Definition at line 253 of file functions.c.

254{
255 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
256 if (!cur_att->body->parts)
257 {
258 mutt_error(_("There are no subparts to show"));
259 return FR_NO_ACTION;
260 }
261 attach_collapse(priv->actx, priv->menu);
262 mutt_update_recvattach_menu(priv->actx, priv->menu, false);
263 return FR_SUCCESS;
264}
static void attach_collapse(struct AttachCtx *actx, struct Menu *menu)
Close the tree of the current attachment.
Definition: functions.c:133
@ FR_SUCCESS
Valid function - successfully performed.
Definition: dispatcher.h:39
@ FR_NO_ACTION
Valid function - no action performed.
Definition: dispatcher.h:37
#define mutt_error(...)
Definition: logging2.h:92
#define _(a)
Definition: message.h:28
void mutt_update_recvattach_menu(struct AttachCtx *actx, struct Menu *menu, bool init)
Update the Attachment Menu.
Definition: recvattach.c:1214
struct AttachPtr * current_attachment(struct AttachCtx *actx, struct Menu *menu)
Get the current attachment.
Definition: recvattach.c:77
struct Menu * menu
Current Menu.
Definition: private_data.h:37
struct AttachCtx * actx
List of all Attachments.
Definition: private_data.h:38
An email to which things will be attached.
Definition: attach.h:37
struct Body * body
Attachment.
Definition: attach.h:38
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
+ Here is the call graph for this function:

◆ op_attachment_delete()

static int op_attachment_delete ( struct AttachPrivateData priv,
int  op 
)
static

delete the current entry - Implements attach_function_t -

Definition at line 269 of file functions.c.

270{
271 if (check_readonly(priv->mailbox))
272 return FR_ERROR;
273
274 if (priv->mailbox->type == MUTT_POP)
275 {
277 mutt_error(_("Can't delete attachment from POP server"));
278 return FR_ERROR;
279 }
280
281 if (priv->mailbox->type == MUTT_NNTP)
282 {
284 mutt_error(_("Can't delete attachment from news server"));
285 return FR_ERROR;
286 }
287
288 if ((WithCrypto != 0) && (priv->actx->email->security & SEC_ENCRYPT))
289 {
290 mutt_message(_("Deletion of attachments from encrypted messages is unsupported"));
291 return FR_ERROR;
292 }
293 if ((WithCrypto != 0) && (priv->actx->email->security & (SEC_SIGN | SEC_PARTSIGN)))
294 {
295 mutt_message(_("Deletion of attachments from signed messages may invalidate the signature"));
296 }
297
298 if (priv->menu->tag_prefix)
299 {
300 for (int i = 0; i < priv->menu->max; i++)
301 {
302 if (priv->actx->idx[i]->body->tagged)
303 {
304 if (priv->actx->idx[i]->parent_type == TYPE_MULTIPART)
305 {
306 priv->actx->idx[i]->body->deleted = true;
308 }
309 else
310 {
311 mutt_message(_("Only deletion of multipart attachments is supported"));
312 }
313 }
314 }
315 }
316 else
317 {
318 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
319 if (cur_att->parent_type == TYPE_MULTIPART)
320 {
321 cur_att->body->deleted = true;
322 const bool c_resolve = cs_subset_bool(NeoMutt->sub, "resolve");
323 const int index = menu_get_index(priv->menu) + 1;
324 if (c_resolve && (index < priv->menu->max))
325 {
326 menu_set_index(priv->menu, index);
327 }
328 else
329 {
331 }
332 }
333 else
334 {
335 mutt_message(_("Only deletion of multipart attachments is supported"));
336 }
337 }
338
339 return FR_SUCCESS;
340}
static bool check_readonly(struct Mailbox *m)
Check if the Mailbox is readonly.
Definition: functions.c:185
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
@ MUTT_POP
'POP3' Mailbox type
Definition: mailbox.h:52
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: get.c:58
@ FR_ERROR
Valid function - error occurred.
Definition: dispatcher.h:38
#define mutt_message(...)
Definition: logging2.h:91
#define MENU_REDRAW_INDEX
Redraw the index.
Definition: lib.h:56
void menu_queue_redraw(struct Menu *menu, MenuRedrawFlags redraw)
Queue a request for a redraw.
Definition: menu.c:184
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:160
#define MENU_REDRAW_CURRENT
Redraw the current line of the menu.
Definition: lib.h:58
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:174
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: lib.h:82
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78
#define WithCrypto
Definition: lib.h:116
#define SEC_SIGN
Email is signed.
Definition: lib.h:79
struct Email * email
Used by recvattach for updating.
Definition: attach.h:66
struct AttachPtr ** idx
Array of attachments.
Definition: attach.h:69
struct Mailbox * mailbox
Current Mailbox.
Definition: private_data.h:40
int parent_type
Type of parent attachment, e.g. TYPE_MULTIPART.
Definition: attach.h:40
bool deleted
Attachment marked for deletion.
Definition: body.h:87
bool tagged
This attachment is tagged.
Definition: body.h:89
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:43
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
bool tag_prefix
User has pressed <tag-prefix>
Definition: lib.h:85
int max
Number of entries in the menu.
Definition: lib.h:81
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ Here is the call graph for this function:

◆ op_attachment_edit_type()

static int op_attachment_edit_type ( struct AttachPrivateData priv,
int  op 
)
static

edit attachment content type - Implements attach_function_t -

Definition at line 345 of file functions.c.

346{
347 recvattach_edit_content_type(priv->actx, priv->menu, priv->actx->email);
349 return FR_SUCCESS;
350}
void recvattach_edit_content_type(struct AttachCtx *actx, struct Menu *menu, struct Email *e)
Edit the content type of an attachment.
Definition: recvattach.c:932
+ Here is the call graph for this function:

◆ op_attachment_pipe()

static int op_attachment_pipe ( struct AttachPrivateData priv,
int  op 
)
static

pipe message/attachment to a shell command - Implements attach_function_t -

Definition at line 355 of file functions.c.

356{
357 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
358 mutt_pipe_attachment_list(priv->actx, cur_att->fp, priv->menu->tag_prefix,
359 cur_att->body, false);
360 return FR_SUCCESS;
361}
void mutt_pipe_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag, struct Body *b, bool filter)
Pipe a list of attachments to a command.
Definition: recvattach.c:725
FILE * fp
Used in the recvattach menu.
Definition: attach.h:39
+ Here is the call graph for this function:

◆ op_attachment_print()

static int op_attachment_print ( struct AttachPrivateData priv,
int  op 
)
static

print the current entry - Implements attach_function_t -

Definition at line 366 of file functions.c.

367{
368 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
369 mutt_print_attachment_list(priv->actx, cur_att->fp, priv->menu->tag_prefix,
370 cur_att->body);
371 return FR_SUCCESS;
372}
void mutt_print_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag, struct Body *b)
Print a list of Attachments.
Definition: recvattach.c:888
+ Here is the call graph for this function:

◆ op_attachment_save()

static int op_attachment_save ( struct AttachPrivateData priv,
int  op 
)
static

save message/attachment to a mailbox/file - Implements attach_function_t -

Definition at line 377 of file functions.c.

378{
379 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
380 mutt_save_attachment_list(priv->actx, cur_att->fp, priv->menu->tag_prefix,
381 cur_att->body, priv->actx->email, priv->menu);
382
383 const bool c_resolve = cs_subset_bool(NeoMutt->sub, "resolve");
384 const int index = menu_get_index(priv->menu) + 1;
385 if (!priv->menu->tag_prefix && c_resolve && (index < priv->menu->max))
386 menu_set_index(priv->menu, index);
387 return FR_SUCCESS;
388}
void mutt_save_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag, struct Body *b, struct Email *e, struct Menu *menu)
Save a list of attachments.
Definition: recvattach.c:433
+ Here is the call graph for this function:

◆ op_attachment_undelete()

static int op_attachment_undelete ( struct AttachPrivateData priv,
int  op 
)
static

undelete the current entry - Implements attach_function_t -

Definition at line 393 of file functions.c.

394{
395 if (check_readonly(priv->mailbox))
396 return FR_ERROR;
397
398 if (priv->menu->tag_prefix)
399 {
400 for (int i = 0; i < priv->menu->max; i++)
401 {
402 if (priv->actx->idx[i]->body->tagged)
403 {
404 priv->actx->idx[i]->body->deleted = false;
406 }
407 }
408 }
409 else
410 {
411 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
412 cur_att->body->deleted = false;
413 const bool c_resolve = cs_subset_bool(NeoMutt->sub, "resolve");
414 const int index = menu_get_index(priv->menu) + 1;
415 if (c_resolve && (index < priv->menu->max))
416 {
417 menu_set_index(priv->menu, index);
418 }
419 else
420 {
422 }
423 }
424
425 return FR_SUCCESS;
426}
+ Here is the call graph for this function:

◆ op_attachment_view()

static int op_attachment_view ( struct AttachPrivateData priv,
int  op 
)
static

view attachment using mailcap entry if necessary - Implements attach_function_t -

Definition at line 431 of file functions.c.

432{
433 priv->op = mutt_attach_display_loop(priv->sub, priv->menu, op,
434 priv->actx->email, priv->actx, true);
436
437 return FR_CONTINUE;
438}
@ FR_CONTINUE
Remain in the Dialog.
Definition: dispatcher.h:34
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:59
int mutt_attach_display_loop(struct ConfigSubset *sub, struct Menu *menu, int op, struct Email *e, struct AttachCtx *actx, bool recv)
Event loop for the Attachment menu.
Definition: recvattach.c:962
int op
Op returned from the Pager, e.g. OP_NEXT_ENTRY.
Definition: private_data.h:41
struct ConfigSubset * sub
Config subset.
Definition: private_data.h:39
+ Here is the call graph for this function:

◆ op_attachment_view_mailcap()

static int op_attachment_view_mailcap ( struct AttachPrivateData priv,
int  op 
)
static

force viewing of attachment using mailcap - Implements attach_function_t -

Definition at line 443 of file functions.c.

444{
445 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
446 mutt_view_attachment(cur_att->fp, cur_att->body, MUTT_VA_MAILCAP,
447 priv->actx->email, priv->actx, priv->menu->win);
449 return FR_SUCCESS;
450}
int mutt_view_attachment(FILE *fp, struct Body *b, enum ViewAttachMode mode, struct Email *e, struct AttachCtx *actx, struct MuttWindow *win)
View an attachment.
Definition: mutt_attach.c:419
@ MUTT_VA_MAILCAP
Force viewing using mailcap entry.
Definition: mutt_attach.h:45
struct MuttWindow * win
Window holding the Menu.
Definition: lib.h:86
+ Here is the call graph for this function:

◆ op_attachment_view_pager()

static int op_attachment_view_pager ( struct AttachPrivateData priv,
int  op 
)
static

view attachment in pager using copiousoutput mailcap - Implements attach_function_t -

Definition at line 455 of file functions.c.

456{
457 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
458 mutt_view_attachment(cur_att->fp, cur_att->body, MUTT_VA_PAGER,
459 priv->actx->email, priv->actx, priv->menu->win);
461 return FR_SUCCESS;
462}
@ MUTT_VA_PAGER
View attachment in pager using copiousoutput mailcap.
Definition: mutt_attach.h:47
+ Here is the call graph for this function:

◆ op_attachment_view_text()

static int op_attachment_view_text ( struct AttachPrivateData priv,
int  op 
)
static

view attachment as text - Implements attach_function_t -

Definition at line 467 of file functions.c.

468{
469 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
470 mutt_view_attachment(cur_att->fp, cur_att->body, MUTT_VA_AS_TEXT,
471 priv->actx->email, priv->actx, priv->menu->win);
473 return FR_SUCCESS;
474}
@ MUTT_VA_AS_TEXT
Force viewing as text.
Definition: mutt_attach.h:46
+ Here is the call graph for this function:

◆ op_bounce_message()

static int op_bounce_message ( struct AttachPrivateData priv,
int  op 
)
static

remail a message to another user - Implements attach_function_t -

Definition at line 479 of file functions.c.

480{
481 if (check_attach(priv))
482 return FR_ERROR;
483 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
484 attach_bounce_message(priv->mailbox, cur_att->fp, priv->actx,
485 priv->menu->tag_prefix ? NULL : cur_att->body);
487 return FR_SUCCESS;
488}
static bool check_attach(struct AttachPrivateData *priv)
Check if in attach-message mode.
Definition: functions.c:168
void attach_bounce_message(struct Mailbox *m, FILE *fp, struct AttachCtx *actx, struct Body *b)
Bounce function, from the attachment menu.
Definition: recvcmd.c:166
+ Here is the call graph for this function:

◆ op_check_traditional()

static int op_check_traditional ( struct AttachPrivateData priv,
int  op 
)
static

check for classic PGP - Implements attach_function_t -

Definition at line 493 of file functions.c.

494{
495 if (((WithCrypto & APPLICATION_PGP) != 0) &&
497 {
498 priv->actx->email->security = crypt_query(NULL);
500 }
501 return FR_SUCCESS;
502}
static int recvattach_pgp_check_traditional(struct AttachCtx *actx, struct Menu *menu)
Is the Attachment inline PGP?
Definition: functions.c:229
SecurityFlags crypt_query(struct Body *b)
Check out the type of encryption used.
Definition: crypt.c:687
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
+ Here is the call graph for this function:

◆ op_compose_to_sender()

static int op_compose_to_sender ( struct AttachPrivateData priv,
int  op 
)
static

compose new message to the current message sender - Implements attach_function_t -

Definition at line 507 of file functions.c.

508{
509 if (check_attach(priv))
510 return FR_ERROR;
511 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
512 mutt_attach_mail_sender(priv->actx, priv->menu->tag_prefix ? NULL : cur_att->body);
514 return FR_SUCCESS;
515}
void mutt_attach_mail_sender(struct AttachCtx *actx, struct Body *b)
Compose an email to the sender in the email attachment.
Definition: recvcmd.c:1127
+ Here is the call graph for this function:

◆ op_exit()

static int op_exit ( struct AttachPrivateData priv,
int  op 
)
static

exit this menu - Implements attach_function_t -

Definition at line 520 of file functions.c.

521{
522 priv->actx->email->attach_del = false;
523 for (int i = 0; i < priv->actx->idxlen; i++)
524 {
525 if (priv->actx->idx[i]->body && priv->actx->idx[i]->body->deleted)
526 {
527 priv->actx->email->attach_del = true;
528 break;
529 }
530 }
531 if (priv->actx->email->attach_del)
532 priv->actx->email->changed = true;
533
534 mutt_actx_free(&priv->actx);
535 return FR_DONE;
536}
void mutt_actx_free(struct AttachCtx **ptr)
Free an Attachment Context.
Definition: attach.c:198
@ FR_DONE
Exit the Dialog.
Definition: dispatcher.h:35
short idxlen
Number of attachmentes.
Definition: attach.h:70
bool changed
Email has been edited.
Definition: email.h:77
bool attach_del
Has an attachment marked for deletion.
Definition: email.h:102
+ Here is the call graph for this function:

◆ op_extract_keys()

static int op_extract_keys ( struct AttachPrivateData priv,
int  op 
)
static

extract supported public keys - Implements attach_function_t -

Definition at line 541 of file functions.c.

542{
544 return FR_NO_ACTION;
545
548
549 return FR_SUCCESS;
550}
static void recvattach_extract_pgp_keys(struct AttachCtx *actx, struct Menu *menu)
Extract PGP keys from attachments.
Definition: functions.c:202
+ Here is the call graph for this function:

◆ op_forget_passphrase()

static int op_forget_passphrase ( struct AttachPrivateData priv,
int  op 
)
static

wipe passphrases from memory - Implements attach_function_t -

Definition at line 555 of file functions.c.

556{
558 return FR_SUCCESS;
559}
void crypt_forget_passphrase(void)
Forget a passphrase and display a message.
Definition: crypt.c:90
+ Here is the call graph for this function:

◆ op_forward_message()

static int op_forward_message ( struct AttachPrivateData priv,
int  op 
)
static

forward a message with comments - Implements attach_function_t -

Definition at line 564 of file functions.c.

565{
566 if (check_attach(priv))
567 return FR_ERROR;
568 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
569 mutt_attach_forward(cur_att->fp, priv->actx->email, priv->actx,
570 priv->menu->tag_prefix ? NULL : cur_att->body, SEND_NO_FLAGS);
572 return FR_SUCCESS;
573}
void mutt_attach_forward(FILE *fp, struct Email *e, struct AttachCtx *actx, struct Body *b, SendFlags flags)
Forward an Attachment.
Definition: recvcmd.c:793
#define SEND_NO_FLAGS
No flags are set.
Definition: send.h:41
+ Here is the call graph for this function:

◆ op_list_subscribe()

static int op_list_subscribe ( struct AttachPrivateData priv,
int  op 
)
static

subscribe to a mailing list - Implements attach_function_t -

Definition at line 578 of file functions.c.

579{
580 if (!check_attach(priv))
582 return FR_SUCCESS;
583}
bool mutt_send_list_subscribe(struct Mailbox *m, struct Email *e)
Send a mailing-list subscription email.
Definition: send.c:3024
+ Here is the call graph for this function:

◆ op_list_unsubscribe()

static int op_list_unsubscribe ( struct AttachPrivateData priv,
int  op 
)
static

unsubscribe from a mailing list - Implements attach_function_t -

Definition at line 588 of file functions.c.

589{
590 if (!check_attach(priv))
592 return FR_SUCCESS;
593}
bool mutt_send_list_unsubscribe(struct Mailbox *m, struct Email *e)
Send a mailing-list unsubscription email.
Definition: send.c:3053
+ Here is the call graph for this function:

◆ op_reply()

static int op_reply ( struct AttachPrivateData priv,
int  op 
)
static

reply to a message - Implements attach_function_t -

Definition at line 598 of file functions.c.

599{
600 if (check_attach(priv))
601 return FR_ERROR;
602
603 SendFlags flags = SEND_REPLY;
604 if (op == OP_GROUP_REPLY)
605 flags |= SEND_GROUP_REPLY;
606 else if (op == OP_GROUP_CHAT_REPLY)
607 flags |= SEND_GROUP_CHAT_REPLY;
608 else if (op == OP_LIST_REPLY)
609 flags |= SEND_LIST_REPLY;
610
611 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
612 mutt_attach_reply(cur_att->fp, priv->mailbox, priv->actx->email, priv->actx,
613 priv->menu->tag_prefix ? NULL : cur_att->body, flags);
615 return FR_SUCCESS;
616}
void mutt_attach_reply(FILE *fp, struct Mailbox *m, struct Email *e, struct AttachCtx *actx, struct Body *b, SendFlags flags)
Attach a reply.
Definition: recvcmd.c:949
#define SEND_GROUP_CHAT_REPLY
Reply to all recipients preserving To/Cc.
Definition: send.h:54
uint32_t SendFlags
Flags for mutt_send_message(), e.g. SEND_REPLY.
Definition: send.h:40
#define SEND_GROUP_REPLY
Reply to all.
Definition: send.h:43
#define SEND_LIST_REPLY
Reply to mailing list.
Definition: send.h:44
#define SEND_REPLY
Reply to sender.
Definition: send.h:42
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ op_resend()

static int op_resend ( struct AttachPrivateData priv,
int  op 
)
static

use the current message as a template for a new one - Implements attach_function_t -

Definition at line 621 of file functions.c.

622{
623 if (check_attach(priv))
624 return FR_ERROR;
625 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
626 mutt_attach_resend(cur_att->fp, priv->mailbox, priv->actx,
627 priv->menu->tag_prefix ? NULL : cur_att->body);
629 return FR_SUCCESS;
630}
void mutt_attach_resend(FILE *fp, struct Mailbox *m, struct AttachCtx *actx, struct Body *b)
Resend-message, from the attachment menu.
Definition: recvcmd.c:290
+ Here is the call graph for this function:

◆ op_followup()

static int op_followup ( struct AttachPrivateData priv,
int  op 
)
static

followup to newsgroup - Implements attach_function_t -

Definition at line 637 of file functions.c.

638{
639 if (check_attach(priv))
640 return FR_ERROR;
641
642 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
643 if (!cur_att->body->email->env->followup_to ||
644 !mutt_istr_equal(cur_att->body->email->env->followup_to, "poster") ||
645 (query_quadoption(_("Reply by mail as poster prefers?"), NeoMutt->sub,
646 "followup_to_poster") != MUTT_YES))
647 {
648 mutt_attach_reply(cur_att->fp, priv->mailbox, priv->actx->email, priv->actx,
649 priv->menu->tag_prefix ? NULL : cur_att->body, SEND_NEWS | SEND_REPLY);
651 return FR_SUCCESS;
652 }
653
654 return op_reply(priv, op);
655}
static int op_reply(struct AttachPrivateData *priv, int op)
reply to a message - Implements attach_function_t -
Definition: functions.c:598
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_quadoption(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
Definition: question.c:365
#define SEND_NEWS
Reply to a news article.
Definition: send.h:55
struct Email * email
header information for message/rfc822
Definition: body.h:73
struct Envelope * env
Envelope information.
Definition: email.h:68
char * followup_to
List of 'followup-to' fields.
Definition: envelope.h:80
+ Here is the call graph for this function:

◆ op_forward_to_group()

static int op_forward_to_group ( struct AttachPrivateData priv,
int  op 
)
static

forward to newsgroup - Implements attach_function_t -

Definition at line 660 of file functions.c.

661{
662 if (check_attach(priv))
663 return FR_ERROR;
664 struct AttachPtr *cur_att = current_attachment(priv->actx, priv->menu);
665 mutt_attach_forward(cur_att->fp, priv->actx->email, priv->actx,
666 priv->menu->tag_prefix ? NULL : cur_att->body, SEND_NEWS);
668 return FR_SUCCESS;
669}
+ Here is the call graph for this function: