NeoMutt  2022-04-29-249-gaae397
Teaching an old dog new tricks
DOXYGEN
Compose Function API

Prototype for a Compose Function. More...

+ Collaboration diagram for Compose Function API:

Functions

static int op_attachment_attach_file (struct ComposeSharedData *shared, int op)
 Attach files to this message - Implements compose_function_t -. More...
 
static int op_attachment_attach_key (struct ComposeSharedData *shared, int op)
 Attach a PGP public key - Implements compose_function_t -. More...
 
static int op_attachment_attach_message (struct ComposeSharedData *shared, int op)
 Attach messages to this message - Implements compose_function_t -. More...
 
static int op_attachment_detach (struct ComposeSharedData *shared, int op)
 Delete the current entry - Implements compose_function_t -. More...
 
static int op_attachment_edit_content_id (struct ComposeSharedData *shared, int op)
 Edit the 'Content-ID' of the attachment - Implements compose_function_t -. More...
 
static int op_attachment_edit_description (struct ComposeSharedData *shared, int op)
 Edit attachment description - Implements compose_function_t -. More...
 
static int op_attachment_edit_encoding (struct ComposeSharedData *shared, int op)
 Edit attachment transfer-encoding - Implements compose_function_t -. More...
 
static int op_attachment_edit_language (struct ComposeSharedData *shared, int op)
 Edit the 'Content-Language' of the attachment - Implements compose_function_t -. More...
 
static int op_attachment_edit_mime (struct ComposeSharedData *shared, int op)
 Edit attachment using mailcap entry - Implements compose_function_t -. More...
 
static int op_attachment_edit_type (struct ComposeSharedData *shared, int op)
 Edit attachment content type - Implements compose_function_t -. More...
 
static int op_attachment_filter (struct ComposeSharedData *shared, int op)
 Filter attachment through a shell command - Implements compose_function_t -. More...
 
static int op_attachment_get_attachment (struct ComposeSharedData *shared, int op)
 Get a temporary copy of an attachment - Implements compose_function_t -. More...
 
static int op_attachment_group_alts (struct ComposeSharedData *shared, int op)
 Group tagged attachments as 'multipart/alternative' - Implements compose_function_t -. More...
 
static int op_attachment_group_lingual (struct ComposeSharedData *shared, int op)
 Group tagged attachments as 'multipart/multilingual' - Implements compose_function_t -. More...
 
static int op_attachment_group_related (struct ComposeSharedData *shared, int op)
 Group tagged attachments as 'multipart/related' - Implements compose_function_t -. More...
 
static int op_attachment_move_down (struct ComposeSharedData *shared, int op)
 Move an attachment down in the attachment list - Implements compose_function_t -. More...
 
static int op_attachment_move_up (struct ComposeSharedData *shared, int op)
 Move an attachment up in the attachment list - Implements compose_function_t -. More...
 
static int op_attachment_new_mime (struct ComposeSharedData *shared, int op)
 Compose new attachment using mailcap entry - Implements compose_function_t -. More...
 
static int op_attachment_print (struct ComposeSharedData *shared, int op)
 Print the current entry - Implements compose_function_t -. More...
 
static int op_attachment_rename_attachment (struct ComposeSharedData *shared, int op)
 Send attachment with a different name - Implements compose_function_t -. More...
 
static int op_attachment_save (struct ComposeSharedData *shared, int op)
 Save message/attachment to a mailbox/file - Implements compose_function_t -. More...
 
static int op_attachment_toggle_disposition (struct ComposeSharedData *shared, int op)
 Toggle disposition between inline/attachment - Implements compose_function_t -. More...
 
static int op_attachment_toggle_recode (struct ComposeSharedData *shared, int op)
 Toggle recoding of this attachment - Implements compose_function_t -. More...
 
static int op_attachment_toggle_unlink (struct ComposeSharedData *shared, int op)
 Toggle whether to delete file after sending it - Implements compose_function_t -. More...
 
static int op_attachment_ungroup (struct ComposeSharedData *shared, int op)
 Ungroup a 'multipart' attachment - Implements compose_function_t -. More...
 
static int op_attachment_update_encoding (struct ComposeSharedData *shared, int op)
 Update an attachment's encoding info - Implements compose_function_t -. More...
 
static int op_envelope_edit_headers (struct ComposeSharedData *shared, int op)
 Edit the message with headers - Implements compose_function_t -. More...
 
static int op_compose_edit_file (struct ComposeSharedData *shared, int op)
 Edit the file to be attached - Implements compose_function_t -. More...
 
static int op_compose_edit_message (struct ComposeSharedData *shared, int op)
 Edit the message - Implements compose_function_t -. More...
 
static int op_compose_ispell (struct ComposeSharedData *shared, int op)
 Run ispell on the message - Implements compose_function_t -. More...
 
static int op_compose_postpone_message (struct ComposeSharedData *shared, int op)
 Save this message to send later - Implements compose_function_t -. More...
 
static int op_compose_rename_file (struct ComposeSharedData *shared, int op)
 Rename/move an attached file - Implements compose_function_t -. More...
 
static int op_compose_send_message (struct ComposeSharedData *shared, int op)
 Send the message - Implements compose_function_t -. More...
 
static int op_compose_write_message (struct ComposeSharedData *shared, int op)
 Write the message to a folder - Implements compose_function_t -. More...
 
static int op_display_headers (struct ComposeSharedData *shared, int op)
 Display message and toggle header weeding - Implements compose_function_t -. More...
 
static int op_exit (struct ComposeSharedData *shared, int op)
 Exit this menu - Implements compose_function_t -. More...
 
static int op_forget_passphrase (struct ComposeSharedData *shared, int op)
 Wipe passphrases from memory - Implements compose_function_t -. More...
 

Detailed Description

Prototype for a Compose Function.

Parameters
sharedShared Compose data
opOperation to perform, e.g. OP_COMPOSE_WRITE_MESSAGE
Return values
enumFunctionRetval

Function Documentation

◆ op_attachment_attach_file()

static int op_attachment_attach_file ( struct ComposeSharedData shared,
int  op 
)
static

Attach files to this message - Implements compose_function_t -.

Definition at line 590 of file functions.c.

591{
592 char *prompt = _("Attach file");
593 int numfiles = 0;
594 char **files = NULL;
595
596 struct Buffer *fname = mutt_buffer_pool_get();
597 if ((mutt_buffer_enter_fname(prompt, fname, false, NULL, true, &files,
598 &numfiles, MUTT_SEL_MULTI) == -1) ||
600 {
601 for (int i = 0; i < numfiles; i++)
602 FREE(&files[i]);
603
604 FREE(&files);
606 return FR_NO_ACTION;
607 }
608
609 bool error = false;
610 bool added_attachment = false;
611 if (numfiles > 1)
612 {
613 mutt_message(ngettext("Attaching selected file...",
614 "Attaching selected files...", numfiles));
615 }
616 for (int i = 0; i < numfiles; i++)
617 {
618 char *att = files[i];
619 if (!att)
620 continue;
621
622 struct AttachPtr *ap = mutt_aptr_new();
623 ap->unowned = true;
624 ap->body = mutt_make_file_attach(att, shared->sub);
625 if (ap->body)
626 {
627 added_attachment = true;
628 update_idx(shared->adata->menu, shared->adata->actx, ap);
629 }
630 else
631 {
632 error = true;
633 mutt_error(_("Unable to attach %s"), att);
634 mutt_aptr_free(&ap);
635 }
636 FREE(&files[i]);
637 }
638
639 FREE(&files);
641
642 if (!error)
644
647 if (added_attachment)
649 return FR_SUCCESS;
650}
struct AttachPtr * mutt_aptr_new(void)
Create a new Attachment Pointer.
Definition: attach.c:40
void mutt_aptr_free(struct AttachPtr **ptr)
Free an Attachment Pointer.
Definition: attach.c:49
#define MUTT_SEL_MULTI
Multi-selection is enabled.
Definition: lib.h:57
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:260
static void update_idx(struct Menu *menu, struct AttachCtx *actx, struct AttachPtr *ap)
Add a new attachment to the message.
Definition: functions.c:281
int mutt_buffer_enter_fname(const char *prompt, struct Buffer *fname, bool mailbox, struct Mailbox *m, bool multiple, char ***files, int *numfiles, SelectFileFlags flags)
Ask the user to select a file.
Definition: curs_lib.c:445
@ FR_SUCCESS
Valid function - successfully performed.
Definition: dispatcher.h:39
@ FR_NO_ACTION
Valid function - no action performed.
Definition: dispatcher.h:37
@ NT_EMAIL_CHANGE_ATTACH
Email's Attachments have changed.
Definition: email.h:153
#define mutt_error(...)
Definition: logging.h:87
#define mutt_message(...)
Definition: logging.h:86
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:658
#define MUTT_SEND2_HOOK
send2-hook: when changing fields in the compose menu
Definition: hook.h:49
#define FREE(x)
Definition: memory.h:43
#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:178
#define _(a)
Definition: message.h:28
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:171
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
@ NT_EMAIL
Email has changed, NotifyEmail, EventEmail.
Definition: notify_type.h:44
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
struct Body * mutt_make_file_attach(const char *path, struct ConfigSubset *sub)
Create a file attachment.
Definition: sendlib.c:598
An email to which things will be attached.
Definition: attach.h:35
struct Body * body
Attachment.
Definition: attach.h:36
bool unowned
Don't unlink on detach.
Definition: attach.h:42
String manipulation buffer.
Definition: buffer.h:34
struct Menu * menu
Menu displaying the attachments.
Definition: attach_data.h:35
struct AttachCtx * actx
Set of attachments.
Definition: attach_data.h:34
struct ConfigSubset * sub
Config set to use.
Definition: shared_data.h:34
struct ComposeAttachData * adata
Attachments.
Definition: shared_data.h:37
struct Email * email
Email being composed.
Definition: shared_data.h:36
struct Notify * notify
Notifications: NotifyEmail, EventEmail.
Definition: email.h:71
+ Here is the call graph for this function:

◆ op_attachment_attach_key()

static int op_attachment_attach_key ( struct ComposeSharedData shared,
int  op 
)
static

Attach a PGP public key - Implements compose_function_t -.

Definition at line 655 of file functions.c.

656{
658 return FR_NOT_IMPL;
659 struct AttachPtr *ap = mutt_aptr_new();
661 if (ap->body)
662 {
663 update_idx(shared->adata->menu, shared->adata->actx, ap);
666 }
667 else
668 {
669 mutt_aptr_free(&ap);
670 }
671
673 return FR_SUCCESS;
674}
struct Body * crypt_pgp_make_key_attachment(void)
Wrapper for CryptModuleSpecs::pgp_make_key_attachment()
Definition: cryptglue.c:305
@ FR_NOT_IMPL
Invalid function - feature not enabled.
Definition: dispatcher.h:36
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define WithCrypto
Definition: lib.h:116
+ Here is the call graph for this function:

◆ op_attachment_attach_message()

static int op_attachment_attach_message ( struct ComposeSharedData shared,
int  op 
)
static

Attach messages to this message - Implements compose_function_t -.

This function handles:

  • OP_ATTACHMENT_ATTACH_MESSAGE
  • OP_ATTACHMENT_ATTACH_NEWS_MESSAGE

Definition at line 683 of file functions.c.

684{
685 char *prompt = _("Open mailbox to attach message from");
686
687#ifdef USE_NNTP
688 OptNews = false;
689 if (shared->mailbox && (op == OP_ATTACHMENT_ATTACH_NEWS_MESSAGE))
690 {
691 const char *const c_news_server = cs_subset_string(shared->sub, "news_server");
692 CurrentNewsSrv = nntp_select_server(shared->mailbox, c_news_server, false);
693 if (!CurrentNewsSrv)
694 return FR_NO_ACTION;
695
696 prompt = _("Open newsgroup to attach message from");
697 OptNews = true;
698 }
699#endif
700
701 struct Buffer *fname = mutt_buffer_pool_get();
702 if (shared->mailbox)
703 {
704#ifdef USE_NNTP
705 if ((op == OP_ATTACHMENT_ATTACH_MESSAGE) ^ (shared->mailbox->type == MUTT_NNTP))
706#endif
707 {
708 mutt_buffer_strcpy(fname, mailbox_path(shared->mailbox));
710 }
711 }
712
713 if ((mutt_buffer_enter_fname(prompt, fname, true, shared->mailbox, false,
714 NULL, NULL, MUTT_SEL_NO_FLAGS) == -1) ||
716 {
718 return FR_NO_ACTION;
719 }
720
721#ifdef USE_NNTP
722 if (OptNews)
724 else
725#endif
727#ifdef USE_IMAP
728 if (imap_path_probe(mutt_buffer_string(fname), NULL) != MUTT_IMAP)
729#endif
730#ifdef USE_POP
731 if (pop_path_probe(mutt_buffer_string(fname), NULL) != MUTT_POP)
732#endif
733#ifdef USE_NNTP
734 if (!OptNews && (nntp_path_probe(mutt_buffer_string(fname), NULL) != MUTT_NNTP))
735#endif
737 {
738 /* check to make sure the file exists and is readable */
739 if (access(mutt_buffer_string(fname), R_OK) == -1)
740 {
743 return FR_ERROR;
744 }
745 }
746
748
749 struct Mailbox *m_attach = mx_path_resolve(mutt_buffer_string(fname));
750 const bool old_readonly = m_attach->readonly;
751 if (!mx_mbox_open(m_attach, MUTT_READONLY))
752 {
753 mutt_error(_("Unable to open mailbox %s"), mutt_buffer_string(fname));
754 mx_fastclose_mailbox(m_attach, false);
755 m_attach = NULL;
757 return FR_ERROR;
758 }
760
761 if (m_attach->msg_count == 0)
762 {
763 mx_mbox_close(m_attach);
764 mutt_error(_("No messages in that folder"));
765 return FR_NO_ACTION;
766 }
767
768 /* `$sort`, `$sort_aux`, `$use_threads` could be changed in mutt_index_menu() */
769 const enum SortType old_sort = cs_subset_sort(shared->sub, "sort");
770 const enum SortType old_sort_aux = cs_subset_sort(shared->sub, "sort_aux");
771 const unsigned char old_use_threads = cs_subset_enum(shared->sub, "use_threads");
772
773 OptAttachMsg = true;
774 mutt_message(_("Tag the messages you want to attach"));
775 struct MuttWindow *dlg_index = index_pager_init();
776 dialog_push(dlg_index);
777 struct Mailbox *m_attach_new = mutt_index_menu(dlg_index, m_attach);
778 dialog_pop();
779 mutt_window_free(&dlg_index);
780 OptAttachMsg = false;
781
782 if (!shared->mailbox)
783 {
784 /* Restore old $sort variables */
785 cs_subset_str_native_set(shared->sub, "sort", old_sort, NULL);
786 cs_subset_str_native_set(shared->sub, "sort_aux", old_sort_aux, NULL);
787 cs_subset_str_native_set(shared->sub, "use_threads", old_use_threads, NULL);
790 return FR_SUCCESS;
791 }
792
793 bool added_attachment = false;
794 for (int i = 0; i < m_attach_new->msg_count; i++)
795 {
796 if (!m_attach_new->emails[i])
797 break;
798 if (!message_is_tagged(m_attach_new->emails[i]))
799 continue;
800
801 struct AttachPtr *ap = mutt_aptr_new();
802 ap->body = mutt_make_message_attach(m_attach_new, m_attach_new->emails[i],
803 true, shared->sub);
804 if (ap->body)
805 {
806 added_attachment = true;
807 update_idx(shared->adata->menu, shared->adata->actx, ap);
808 }
809 else
810 {
811 mutt_error(_("Unable to attach"));
812 mutt_aptr_free(&ap);
813 }
814 }
816
817 if (m_attach_new == m_attach)
818 {
819 m_attach->readonly = old_readonly;
820 }
821 mx_fastclose_mailbox(m_attach_new, false);
822
823 /* Restore old $sort variables */
824 cs_subset_str_native_set(shared->sub, "sort", old_sort, NULL);
825 cs_subset_str_native_set(shared->sub, "sort_aux", old_sort_aux, NULL);
826 cs_subset_str_native_set(shared->sub, "use_threads", old_use_threads, NULL);
827 if (added_attachment)
829 return FR_SUCCESS;
830}
#define MUTT_SEL_NO_FLAGS
No flags are set.
Definition: lib.h:55
size_t mutt_buffer_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:327
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
unsigned char cs_subset_enum(const struct ConfigSubset *sub, const char *name)
Get a enumeration config item by name.
Definition: helpers.c:97
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:292
void dialog_push(struct MuttWindow *dlg)
Display a Window to the user.
Definition: dialog.c:103
void dialog_pop(void)
Hide a Window from the user.
Definition: dialog.c:137
@ FR_ERROR
Valid function - error occurred.
Definition: dispatcher.h:38
struct Mailbox * mutt_index_menu(struct MuttWindow *dlg, struct Mailbox *m_init)
Display a list of emails.
Definition: dlg_index.c:1058
struct MuttWindow * index_pager_init(void)
Allocate the Windows for the Index/Pager.
Definition: dlg_index.c:1403
#define mutt_perror(...)
Definition: logging.h:88
enum MailboxType nntp_path_probe(const char *path, const struct stat *st)
Is this an NNTP Mailbox? - Implements MxOps::path_probe() -.
Definition: nntp.c:2701
enum MailboxType pop_path_probe(const char *path, const struct stat *st)
Is this a POP Mailbox? - Implements MxOps::path_probe() -.
Definition: pop.c:1157
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe() -.
Definition: imap.c:2400
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:210
@ MUTT_NOTMUCH
'Notmuch' (virtual) Mailbox type
Definition: mailbox.h:51
@ MUTT_POP
'POP3' Mailbox type
Definition: mailbox.h:52
@ MUTT_NNTP
'NNTP' (Usenet) Mailbox type
Definition: mailbox.h:49
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
#define MENU_REDRAW_FULL
Redraw everything.
Definition: lib.h:59
void mutt_window_free(struct MuttWindow **ptr)
Free a Window and its children.
Definition: mutt_window.c:201
void mutt_buffer_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:599
void mutt_buffer_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:322
bool message_is_tagged(struct Email *e)
Is a message in the index tagged (and within limit)
Definition: mview.c:352
void mx_fastclose_mailbox(struct Mailbox *m, bool keep_account)
Free up memory associated with the Mailbox.
Definition: mx.c:430
bool mx_mbox_open(struct Mailbox *m, OpenMailboxFlags flags)
Open a mailbox and parse it.
Definition: mx.c:304
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1327
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1677
enum MxStatus mx_mbox_close(struct Mailbox *m)
Save changes and close mailbox.
Definition: mx.c:615
#define MUTT_READONLY
Open in read-only mode.
Definition: mxapi.h:64
void nntp_expand_path(char *buf, size_t buflen, struct ConnAccount *acct)
Make fully qualified url from newsgroup name.
Definition: newsrc.c:561
struct NntpAccountData * CurrentNewsSrv
Current NNTP news server.
Definition: nntp.c:77
struct NntpAccountData * nntp_select_server(struct Mailbox *m, const char *server, bool leave_lock)
Open a connection to an NNTP server.
Definition: newsrc.c:1019
bool OptNews
(pseudo) used to change reader mode
Definition: options.h:50
bool OptAttachMsg
(pseudo) used by attach-message
Definition: options.h:37
struct Body * mutt_make_message_attach(struct Mailbox *m, struct Email *e, bool attach_msg, struct ConfigSubset *sub)
Create a message attachment.
Definition: sendlib.c:445
SortType
Methods for sorting.
Definition: sort2.h:42
size_t dsize
Length of data.
Definition: buffer.h:37
char * data
Pointer to data.
Definition: buffer.h:35
struct Mailbox * mailbox
Current Mailbox.
Definition: shared_data.h:35
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:50
A mailbox.
Definition: mailbox.h:79
int msg_count
Total number of messages.
Definition: mailbox.h:88
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
bool readonly
Don't allow changes to the mailbox.
Definition: mailbox.h:115
struct Connection * conn
Connection to NNTP Server.
Definition: adata.h:63
int cs_subset_str_native_set(const struct ConfigSubset *sub, const char *name, intptr_t value, struct Buffer *err)
Natively set the value of a string config item.
Definition: subset.c:305
+ Here is the call graph for this function:

◆ op_attachment_detach()

static int op_attachment_detach ( struct ComposeSharedData shared,
int  op 
)
static

Delete the current entry - Implements compose_function_t -.

Definition at line 835 of file functions.c.

836{
837 struct AttachCtx *actx = shared->adata->actx;
838 if (!check_count(actx))
839 return FR_NO_ACTION;
840
841 struct Menu *menu = shared->adata->menu;
842 struct AttachPtr *cur_att = current_attachment(actx, menu);
843 if (cur_att->unowned)
844 cur_att->body->unlink = false;
845
846 int index = menu_get_index(menu);
847 if (delete_attachment(actx, index) == -1)
848 return FR_ERROR;
849
850 menu->num_tagged = 0;
851 for (int i = 0; i < actx->idxlen; i++)
852 {
853 if (actx->idx[i]->body->tagged)
854 menu->num_tagged++;
855 }
856
857 update_menu(actx, menu, false);
859
860 index = menu_get_index(menu);
861 if (index == 0)
862 shared->email->body = actx->idx[0]->body;
863
865 return FR_SUCCESS;
866}
static bool check_count(struct AttachCtx *actx)
Check if there are any attachments.
Definition: functions.c:90
static int delete_attachment(struct AttachCtx *actx, int aidx)
Delete an attachment.
Definition: functions.c:207
void update_menu(struct AttachCtx *actx, struct Menu *menu, bool init)
Redraw the compose window.
Definition: compose.c:222
int menu_get_index(struct Menu *menu)
Get the current selection in the Menu.
Definition: menu.c:154
struct AttachPtr * current_attachment(struct AttachCtx *actx, struct Menu *menu)
Get the current attachment.
Definition: recvattach.c:69
A set of attachments.
Definition: attach.h:51
struct AttachPtr ** idx
Array of attachments.
Definition: attach.h:55
short idxlen
Number of attachmentes.
Definition: attach.h:56
bool unlink
If true, filename should be unlink()ed before free()ing this structure.
Definition: body.h:67
bool tagged
This attachment is tagged.
Definition: body.h:89
struct Body * body
List of MIME parts.
Definition: email.h:67
Definition: lib.h:69
int num_tagged
Number of tagged entries.
Definition: lib.h:83
+ Here is the call graph for this function:

◆ op_attachment_edit_content_id()

static int op_attachment_edit_content_id ( struct ComposeSharedData shared,
int  op 
)
static

Edit the 'Content-ID' of the attachment - Implements compose_function_t -.

Definition at line 871 of file functions.c.

872{
873 if (!check_count(shared->adata->actx))
874 return FR_NO_ACTION;
875
876 int rc = FR_NO_ACTION;
877 struct Buffer *buf = mutt_buffer_pool_get();
878 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
879 shared->adata->menu);
880
881 char *id = mutt_param_get(&cur_att->body->parameter, "content-id");
882 if (id)
883 {
884 mutt_buffer_strcpy(buf, id);
885 }
886 else
887 {
888 id = gen_cid();
889 mutt_buffer_strcpy(buf, id);
890 FREE(&id);
891 }
892
893 if (mutt_buffer_get_field("Content-ID: ", buf, MUTT_COMP_NO_FLAGS, false,
894 NULL, NULL, NULL) == 0)
895 {
896 if (!mutt_str_equal(id, mutt_buffer_string(buf)))
897 {
899 {
900 mutt_param_set(&cur_att->body->parameter, "content-id", mutt_buffer_string(buf));
904 rc = FR_SUCCESS;
905 }
906 else
907 {
908 mutt_error(_("Content-ID can only contain the characters: -.0-9@A-Z_a-z"));
909 rc = FR_ERROR;
910 }
911 }
912 }
913
915
916 if (rc != FR_ERROR)
918
919 return rc;
920}
static char * gen_cid(void)
Generate a random Content ID.
Definition: functions.c:107
static bool check_cid(const char *cid)
Check if a Content-ID is valid.
Definition: functions.c:123
int mutt_buffer_get_field(const char *field, struct Buffer *buf, CompletionFlags complete, bool multiple, struct Mailbox *m, char ***files, int *numfiles)
Ask the user for a string.
Definition: window.c:180
#define MENU_REDRAW_CURRENT
Redraw the current line of the menu.
Definition: lib.h:58
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:807
#define MUTT_COMP_NO_FLAGS
No flags are set.
Definition: mutt.h:52
char * mutt_param_get(const struct ParameterList *pl, const char *s)
Find a matching Parameter.
Definition: parameter.c:84
void mutt_param_set(struct ParameterList *pl, const char *attribute, const char *value)
Set a Parameter.
Definition: parameter.c:110
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:62
+ Here is the call graph for this function:

◆ op_attachment_edit_description()

static int op_attachment_edit_description ( struct ComposeSharedData shared,
int  op 
)
static

Edit attachment description - Implements compose_function_t -.

Definition at line 925 of file functions.c.

926{
927 if (!check_count(shared->adata->actx))
928 return FR_NO_ACTION;
929
930 int rc = FR_NO_ACTION;
931 struct Buffer *buf = mutt_buffer_pool_get();
932
933 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
934 shared->adata->menu);
935 mutt_buffer_strcpy(buf, cur_att->body->description);
936
937 /* header names should not be translated */
938 if (mutt_buffer_get_field("Description: ", buf, MUTT_COMP_NO_FLAGS, false,
939 NULL, NULL, NULL) == 0)
940 {
942 {
946 rc = FR_SUCCESS;
947 }
948 }
949
951 return rc;
952}
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:326
char * description
content-description
Definition: body.h:55
+ Here is the call graph for this function:

◆ op_attachment_edit_encoding()

static int op_attachment_edit_encoding ( struct ComposeSharedData shared,
int  op 
)
static

Edit attachment transfer-encoding - Implements compose_function_t -.

Definition at line 957 of file functions.c.

958{
959 if (!check_count(shared->adata->actx))
960 return FR_NO_ACTION;
961
962 int rc = FR_NO_ACTION;
963 struct Buffer *buf = mutt_buffer_pool_get();
964
965 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
966 shared->adata->menu);
967 mutt_buffer_strcpy(buf, ENCODING(cur_att->body->encoding));
968
969 if ((mutt_buffer_get_field("Content-Transfer-Encoding: ", buf,
970 MUTT_COMP_NO_FLAGS, false, NULL, NULL, NULL) == 0) &&
972 {
974 if ((enc != ENC_OTHER) && (enc != ENC_UUENCODED))
975 {
976 if (enc != cur_att->body->encoding)
977 {
978 cur_att->body->encoding = enc;
983 rc = FR_SUCCESS;
984 }
985 }
986 else
987 {
988 mutt_error(_("Invalid encoding"));
989 rc = FR_ERROR;
990 }
991 }
992
994 return rc;
995}
@ ENC_UUENCODED
UUEncoded text.
Definition: mime.h:54
@ ENC_OTHER
Encoding unknown.
Definition: mime.h:48
#define ENCODING(x)
Definition: mime.h:92
int mutt_check_encoding(const char *c)
Check the encoding type.
Definition: parse.c:396
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
+ Here is the call graph for this function:

◆ op_attachment_edit_language()

static int op_attachment_edit_language ( struct ComposeSharedData shared,
int  op 
)
static

Edit the 'Content-Language' of the attachment - Implements compose_function_t -.

Definition at line 1000 of file functions.c.

1001{
1002 if (!check_count(shared->adata->actx))
1003 return FR_NO_ACTION;
1004
1005 int rc = FR_NO_ACTION;
1006 struct Buffer *buf = mutt_buffer_pool_get();
1007 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1008 shared->adata->menu);
1009
1010 mutt_buffer_strcpy(buf, cur_att->body->language);
1011 if (mutt_buffer_get_field("Content-Language: ", buf, MUTT_COMP_NO_FLAGS,
1012 false, NULL, NULL, NULL) == 0)
1013 {
1014 if (!mutt_str_equal(cur_att->body->language, mutt_buffer_string(buf)))
1015 {
1019 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1020 rc = FR_SUCCESS;
1021 }
1023 }
1024 else
1025 {
1026 mutt_warning(_("Empty 'Content-Language'"));
1027 rc = FR_ERROR;
1028 }
1029
1031 return rc;
1032}
#define mutt_warning(...)
Definition: logging.h:85
char * language
content-language (RFC8255)
Definition: body.h:77
+ Here is the call graph for this function:

◆ op_attachment_edit_mime()

static int op_attachment_edit_mime ( struct ComposeSharedData shared,
int  op 
)
static

Edit attachment using mailcap entry - Implements compose_function_t -.

Definition at line 1037 of file functions.c.

1038{
1039 if (!check_count(shared->adata->actx))
1040 return FR_NO_ACTION;
1041 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1042 shared->adata->menu);
1043 if (!mutt_edit_attachment(cur_att->body))
1044 return FR_NO_ACTION;
1045
1046 mutt_update_encoding(cur_att->body, shared->sub);
1048 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1049 return FR_SUCCESS;
1050}
bool mutt_edit_attachment(struct Body *a)
Edit an attachment.
Definition: mutt_attach.c:260
void mutt_update_encoding(struct Body *a, struct ConfigSubset *sub)
Update the encoding type.
Definition: sendlib.c:413
+ Here is the call graph for this function:

◆ op_attachment_edit_type()

static int op_attachment_edit_type ( struct ComposeSharedData shared,
int  op 
)
static

Edit attachment content type - Implements compose_function_t -.

Definition at line 1055 of file functions.c.

1056{
1057 if (!check_count(shared->adata->actx))
1058 return FR_NO_ACTION;
1059
1060 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1061 shared->adata->menu);
1062 if (!mutt_edit_content_type(NULL, cur_att->body, NULL))
1063 return FR_NO_ACTION;
1064
1065 /* this may have been a change to text/something */
1066 mutt_update_encoding(cur_att->body, shared->sub);
1068 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1069 return FR_SUCCESS;
1070}
bool mutt_edit_content_type(struct Email *e, struct Body *b, FILE *fp)
Edit the content type of an attachment.
Definition: commands.c:1105
+ Here is the call graph for this function:

◆ op_attachment_filter()

static int op_attachment_filter ( struct ComposeSharedData shared,
int  op 
)
static

Filter attachment through a shell command - Implements compose_function_t -.

This function handles:

  • OP_ATTACHMENT_FILTER
  • OP_PIPE

Definition at line 1079 of file functions.c.

1080{
1081 struct AttachCtx *actx = shared->adata->actx;
1082 if (!check_count(actx))
1083 return FR_NO_ACTION;
1084
1085 struct Menu *menu = shared->adata->menu;
1086 struct AttachPtr *cur_att = current_attachment(actx, menu);
1087 if (cur_att->body->type == TYPE_MULTIPART)
1088 {
1089 mutt_error(_("Can't filter multipart attachments"));
1090 return FR_ERROR;
1091 }
1092 mutt_pipe_attachment_list(actx, NULL, menu->tag_prefix, cur_att->body,
1093 (op == OP_ATTACHMENT_FILTER));
1094 if (op == OP_ATTACHMENT_FILTER) /* cte might have changed */
1095 {
1097 }
1099 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1100 return FR_SUCCESS;
1101}
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
void mutt_pipe_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag, struct Body *top, bool filter)
Pipe a list of attachments to a command.
Definition: recvattach.c:705
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
bool tag_prefix
User has pressed <tag-prefix>
Definition: lib.h:75
+ Here is the call graph for this function:

◆ op_attachment_get_attachment()

static int op_attachment_get_attachment ( struct ComposeSharedData shared,
int  op 
)
static

Get a temporary copy of an attachment - Implements compose_function_t -.

Definition at line 1106 of file functions.c.

1107{
1108 struct AttachCtx *actx = shared->adata->actx;
1109 if (!check_count(actx))
1110 return FR_NO_ACTION;
1111
1112 int rc = FR_ERROR;
1113 struct Menu *menu = shared->adata->menu;
1114 struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
1115 ba_add_tagged(&ba, actx, menu);
1116 if (ARRAY_EMPTY(&ba))
1117 goto done;
1118
1119 struct Body **bp = NULL;
1120 ARRAY_FOREACH(bp, &ba)
1121 {
1122 if ((*bp)->type == TYPE_MULTIPART)
1123 {
1124 mutt_warning(_("Can't get multipart attachments"));
1125 continue;
1126 }
1128 }
1129
1131 rc = FR_SUCCESS;
1132
1133done:
1134 ARRAY_FREE(&ba);
1135 /* No send2hook since this doesn't change the message. */
1136 return rc;
1137}
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition: array.h:211
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:73
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:203
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:57
int mutt_get_tmp_attachment(struct Body *a)
Get a temporary copy of an attachment.
Definition: mutt_attach.c:69
int ba_add_tagged(struct BodyArray *ba, struct AttachCtx *actx, struct Menu *menu)
Get an array of tagged Attachments.
Definition: recvattach.c:1219
The body of an email.
Definition: body.h:36
+ Here is the call graph for this function:

◆ op_attachment_group_alts()

static int op_attachment_group_alts ( struct ComposeSharedData shared,
int  op 
)
static

Group tagged attachments as 'multipart/alternative' - Implements compose_function_t -.

Definition at line 1142 of file functions.c.

1143{
1144 if (shared->adata->menu->num_tagged < 2)
1145 {
1146 mutt_error(_("Grouping 'alternatives' requires at least 2 tagged messages"));
1147 return FR_ERROR;
1148 }
1149
1150 return group_attachments(shared, "alternative");
1151}
static int group_attachments(struct ComposeSharedData *shared, char *subtype)
Group tagged attachments into a multipart group.
Definition: functions.c:372
+ Here is the call graph for this function:

◆ op_attachment_group_lingual()

static int op_attachment_group_lingual ( struct ComposeSharedData shared,
int  op 
)
static

Group tagged attachments as 'multipart/multilingual' - Implements compose_function_t -.

Definition at line 1156 of file functions.c.

1157{
1158 if (shared->adata->menu->num_tagged < 2)
1159 {
1160 mutt_error(_("Grouping 'multilingual' requires at least 2 tagged messages"));
1161 return FR_ERROR;
1162 }
1163
1164 /* traverse to see whether all the parts have Content-Language: set */
1165 int tagged_with_lang_num = 0;
1166 for (struct Body *b = shared->email->body; b; b = b->next)
1167 if (b->tagged && b->language && *b->language)
1168 tagged_with_lang_num++;
1169
1170 if (shared->adata->menu->num_tagged != tagged_with_lang_num)
1171 {
1172 if (mutt_yesorno(_("Not all parts have 'Content-Language' set, continue?"), MUTT_YES) != MUTT_YES)
1173 {
1174 mutt_message(_("Not sending this message"));
1175 return FR_ERROR;
1176 }
1177 }
1178
1179 return group_attachments(shared, "multilingual");
1180}
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption mutt_yesorno(const char *msg, enum QuadOption def)
Ask the user a Yes/No question.
Definition: question.c:194
struct Body * next
next attachment in the list
Definition: body.h:71
+ Here is the call graph for this function:

◆ op_attachment_group_related()

static int op_attachment_group_related ( struct ComposeSharedData shared,
int  op 
)
static

Group tagged attachments as 'multipart/related' - Implements compose_function_t -.

Definition at line 1185 of file functions.c.

1186{
1187 if (shared->adata->menu->num_tagged < 2)
1188 {
1189 mutt_error(_("Grouping 'related' requires at least 2 tagged messages"));
1190 return FR_ERROR;
1191 }
1192
1193 // ensure Content-ID is set for tagged attachments
1194 for (struct Body *b = shared->email->body; b; b = b->next)
1195 {
1196 if (!b->tagged || (b->type == TYPE_MULTIPART))
1197 continue;
1198
1199 char *id = mutt_param_get(&b->parameter, "content-id");
1200 if (id)
1201 continue;
1202
1203 id = gen_cid();
1204 if (id)
1205 {
1206 mutt_param_set(&b->parameter, "content-id", id);
1207 FREE(&id);
1208 }
1209 }
1210
1211 return group_attachments(shared, "related");
1212}
+ Here is the call graph for this function:

◆ op_attachment_move_down()

static int op_attachment_move_down ( struct ComposeSharedData shared,
int  op 
)
static

Move an attachment down in the attachment list - Implements compose_function_t -.

Definition at line 1217 of file functions.c.

1218{
1219 int index = menu_get_index(shared->adata->menu);
1220
1221 struct AttachCtx *actx = shared->adata->actx;
1222
1223 if (index < 0)
1224 return FR_ERROR;
1225
1226 if (index == (actx->idxlen - 1))
1227 {
1228 mutt_error(_("Attachment is already at bottom"));
1229 return FR_NO_ACTION;
1230 }
1231 if ((actx->idx[index]->parent_type == TYPE_MULTIPART) &&
1232 !actx->idx[index]->body->next)
1233 {
1234 mutt_error(_("Attachment can't be moved out of group"));
1235 return FR_ERROR;
1236 }
1237
1238 // find next attachment at current level
1239 int nextidx = index + 1;
1240 while ((nextidx < actx->idxlen) &&
1241 (actx->idx[nextidx]->level > actx->idx[index]->level))
1242 {
1243 nextidx++;
1244 }
1245 if (nextidx == actx->idxlen)
1246 {
1247 mutt_error(_("Attachment is already at bottom"));
1248 return FR_NO_ACTION;
1249 }
1250
1251 // find final position
1252 int finalidx = index + 1;
1253 if (nextidx < actx->idxlen - 1)
1254 {
1255 if ((actx->idx[nextidx]->body->type == TYPE_MULTIPART) &&
1256 (actx->idx[nextidx + 1]->level > actx->idx[nextidx]->level))
1257 {
1258 finalidx += attach_body_count(actx->idx[nextidx]->body->parts, true);
1259 }
1260 }
1261
1262 compose_attach_swap(shared->email, shared->adata->actx, index, nextidx);
1263 mutt_update_tree(shared->adata->actx);
1265 menu_set_index(shared->adata->menu, finalidx);
1266 return FR_SUCCESS;
1267}
int attach_body_count(struct Body *body, bool recurse)
Count bodies.
Definition: lib.c:42
static void compose_attach_swap(struct Email *e, struct AttachCtx *actx, int first, int second)
Swap two adjacent entries in the attachment list.
Definition: functions.c:306
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:168
void mutt_update_tree(struct AttachCtx *actx)
Refresh the list of attachments.
Definition: recvattach.c:112
int level
Nesting depth of attachment.
Definition: attach.h:40
int parent_type
Type of parent attachment, e.g. TYPE_MULTIPART.
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_move_up()

static int op_attachment_move_up ( struct ComposeSharedData shared,
int  op 
)
static

Move an attachment up in the attachment list - Implements compose_function_t -.

Definition at line 1272 of file functions.c.

1273{
1274 int index = menu_get_index(shared->adata->menu);
1275 if (index < 0)
1276 return FR_ERROR;
1277
1278 struct AttachCtx *actx = shared->adata->actx;
1279
1280 if (index == 0)
1281 {
1282 mutt_error(_("Attachment is already at top"));
1283 return FR_NO_ACTION;
1284 }
1285 if (actx->idx[index - 1]->level < actx->idx[index]->level)
1286 {
1287 mutt_error(_("Attachment can't be moved out of group"));
1288 return FR_ERROR;
1289 }
1290
1291 // find previous attachment at current level
1292 int previdx = index - 1;
1293 while ((previdx > 0) && (actx->idx[previdx]->level > actx->idx[index]->level))
1294 previdx--;
1295
1296 compose_attach_swap(shared->email, actx, previdx, index);
1297 mutt_update_tree(actx);
1299 menu_set_index(shared->adata->menu, previdx);
1300 return FR_SUCCESS;
1301}
+ Here is the call graph for this function:

◆ op_attachment_new_mime()

static int op_attachment_new_mime ( struct ComposeSharedData shared,
int  op 
)
static

Compose new attachment using mailcap entry - Implements compose_function_t -.

Definition at line 1306 of file functions.c.

1307{
1308 int rc = FR_NO_ACTION;
1309 struct Buffer *fname = mutt_buffer_pool_get();
1310 struct Buffer *type = NULL;
1311 struct AttachPtr *ap = NULL;
1312
1313 if ((mutt_buffer_get_field(_("New file: "), fname, MUTT_COMP_FILE, false,
1314 NULL, NULL, NULL) != 0) ||
1315 mutt_buffer_is_empty(fname))
1316 {
1317 goto done;
1318 }
1320
1321 /* Call to lookup_mime_type () ? maybe later */
1322 type = mutt_buffer_pool_get();
1323 if ((mutt_buffer_get_field("Content-Type: ", type, MUTT_COMP_NO_FLAGS, false,
1324 NULL, NULL, NULL) != 0) ||
1326 {
1327 goto done;
1328 }
1329
1330 rc = FR_ERROR;
1331 char *p = strchr(mutt_buffer_string(type), '/');
1332 if (!p)
1333 {
1334 mutt_error(_("Content-Type is of the form base/sub"));
1335 goto done;
1336 }
1337 *p++ = 0;
1339 if (itype == TYPE_OTHER)
1340 {
1341 mutt_error(_("Unknown Content-Type %s"), mutt_buffer_string(type));
1342 goto done;
1343 }
1344
1345 ap = mutt_aptr_new();
1346 /* Touch the file */
1347 FILE *fp = mutt_file_fopen(mutt_buffer_string(fname), "w");
1348 if (!fp)
1349 {
1350 mutt_error(_("Can't create file %s"), mutt_buffer_string(fname));
1351 goto done;
1352 }
1354
1355 ap->body = mutt_make_file_attach(mutt_buffer_string(fname), shared->sub);
1356 if (!ap->body)
1357 {
1358 mutt_error(_("What we have here is a failure to make an attachment"));
1359 goto done;
1360 }
1361 update_idx(shared->adata->menu, shared->adata->actx, ap);
1362 ap = NULL; // shared->adata->actx has taken ownership
1363
1364 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1365 shared->adata->menu);
1366 cur_att->body->type = itype;
1367 mutt_str_replace(&cur_att->body->subtype, p);
1368 cur_att->body->unlink = true;
1371
1372 if (mutt_compose_attachment(cur_att->body))
1373 {
1374 mutt_update_encoding(cur_att->body, shared->sub);
1376 }
1377 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1378 rc = FR_SUCCESS;
1379
1380done:
1381 mutt_aptr_free(&ap);
1384 return rc;
1385}
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:618
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
ContentType
Content-Type.
Definition: mime.h:30
@ TYPE_OTHER
Unknown Content-Type.
Definition: mime.h:31
#define MUTT_COMP_FILE
File completion (in browser)
Definition: mutt.h:55
int mutt_compose_attachment(struct Body *a)
Create an attachment.
Definition: mutt_attach.c:115
enum ContentType mutt_check_mime_type(const char *s)
Check a MIME type string.
Definition: parse.c:323
FILE * fp
Used in the recvattach menu.
Definition: attach.h:37
char * subtype
content-type subtype
Definition: body.h:60
+ Here is the call graph for this function:

◆ op_attachment_print()

static int op_attachment_print ( struct ComposeSharedData shared,
int  op 
)
static

Print the current entry - Implements compose_function_t -.

Definition at line 1390 of file functions.c.

1391{
1392 struct AttachCtx *actx = shared->adata->actx;
1393 if (!check_count(actx))
1394 return FR_NO_ACTION;
1395
1396 struct Menu *menu = shared->adata->menu;
1397 struct AttachPtr *cur_att = current_attachment(actx, menu);
1398 if (cur_att->body->type == TYPE_MULTIPART)
1399 {
1400 mutt_error(_("Can't print multipart attachments"));
1401 return FR_ERROR;
1402 }
1403
1404 mutt_print_attachment_list(actx, NULL, menu->tag_prefix, cur_att->body);
1405 /* no send2hook, since this doesn't modify the message */
1406 return FR_SUCCESS;
1407}
void mutt_print_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag, struct Body *top)
Print a list of Attachments.
Definition: recvattach.c:863
+ Here is the call graph for this function:

◆ op_attachment_rename_attachment()

static int op_attachment_rename_attachment ( struct ComposeSharedData shared,
int  op 
)
static

Send attachment with a different name - Implements compose_function_t -.

Definition at line 1412 of file functions.c.

1413{
1414 if (!check_count(shared->adata->actx))
1415 return FR_NO_ACTION;
1416 char *src = NULL;
1417 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1418 shared->adata->menu);
1419 if (cur_att->body->d_filename)
1420 src = cur_att->body->d_filename;
1421 else
1422 src = cur_att->body->filename;
1423 struct Buffer *fname = mutt_buffer_pool_get();
1425 int rc = mutt_buffer_get_field(_("Send attachment with name: "), fname,
1426 MUTT_COMP_FILE, false, NULL, NULL, NULL);
1427 if (rc == 0)
1428 {
1429 // It's valid to set an empty string here, to erase what was set
1432 }
1434 return FR_SUCCESS;
1435}
const char * mutt_path_basename(const char *f)
Find the last component for a pathname.
Definition: path.c:329
#define NONULL(x)
Definition: string2.h:37
char * d_filename
filename to be used for the content-disposition header If NULL, filename is used instead.
Definition: body.h:56
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:58
+ Here is the call graph for this function:

◆ op_attachment_save()

static int op_attachment_save ( struct ComposeSharedData shared,
int  op 
)
static

Save message/attachment to a mailbox/file - Implements compose_function_t -.

Definition at line 1440 of file functions.c.

1441{
1442 struct AttachCtx *actx = shared->adata->actx;
1443 if (!check_count(actx))
1444 return FR_NO_ACTION;
1445
1446 struct Menu *menu = shared->adata->menu;
1447 struct AttachPtr *cur_att = current_attachment(actx, menu);
1448 if (cur_att->body->type == TYPE_MULTIPART)
1449 {
1450 mutt_error(_("Can't save multipart attachments"));
1451 return FR_ERROR;
1452 }
1453
1454 mutt_save_attachment_list(actx, NULL, menu->tag_prefix, cur_att->body, NULL, menu);
1455 /* no send2hook, since this doesn't modify the message */
1456 return FR_SUCCESS;
1457}
void mutt_save_attachment_list(struct AttachCtx *actx, FILE *fp, bool tag, struct Body *top, struct Email *e, struct Menu *menu)
Save a list of attachments.
Definition: recvattach.c:413
+ Here is the call graph for this function:

◆ op_attachment_toggle_disposition()

static int op_attachment_toggle_disposition ( struct ComposeSharedData shared,
int  op 
)
static

Toggle disposition between inline/attachment - Implements compose_function_t -.

Definition at line 1462 of file functions.c.

1463{
1464 /* toggle the content-disposition between inline/attachment */
1465 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1466 shared->adata->menu);
1467 cur_att->body->disposition = (cur_att->body->disposition == DISP_INLINE) ?
1468 DISP_ATTACH :
1471 return FR_SUCCESS;
1472}
@ DISP_ATTACH
Content is attached.
Definition: mime.h:63
@ DISP_INLINE
Content is inline.
Definition: mime.h:62
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
+ Here is the call graph for this function:

◆ op_attachment_toggle_recode()

static int op_attachment_toggle_recode ( struct ComposeSharedData shared,
int  op 
)
static

Toggle recoding of this attachment - Implements compose_function_t -.

Definition at line 1477 of file functions.c.

1478{
1479 if (!check_count(shared->adata->actx))
1480 return FR_NO_ACTION;
1481 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1482 shared->adata->menu);
1483 if (!mutt_is_text_part(cur_att->body))
1484 {
1485 mutt_error(_("Recoding only affects text attachments"));
1486 return FR_ERROR;
1487 }
1488 cur_att->body->noconv = !cur_att->body->noconv;
1489 if (cur_att->body->noconv)
1490 mutt_message(_("The current attachment won't be converted"));
1491 else
1492 mutt_message(_("The current attachment will be converted"));
1494 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1495 return FR_SUCCESS;
1496}
bool mutt_is_text_part(struct Body *b)
Is this part of an email in plain text?
Definition: muttlib.c:433
bool noconv
Don't do character set conversion.
Definition: body.h:46
+ Here is the call graph for this function:

◆ op_attachment_toggle_unlink()

static int op_attachment_toggle_unlink ( struct ComposeSharedData shared,
int  op 
)
static

Toggle whether to delete file after sending it - Implements compose_function_t -.

Definition at line 1501 of file functions.c.

1502{
1503 if (!check_count(shared->adata->actx))
1504 return FR_NO_ACTION;
1505 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1506 shared->adata->menu);
1507 cur_att->body->unlink = !cur_att->body->unlink;
1508
1510 /* No send2hook since this doesn't change the message. */
1511 return FR_SUCCESS;
1512}
+ Here is the call graph for this function:

◆ op_attachment_ungroup()

static int op_attachment_ungroup ( struct ComposeSharedData shared,
int  op 
)
static

Ungroup a 'multipart' attachment - Implements compose_function_t -.

Definition at line 1517 of file functions.c.

1518{
1519 if (shared->adata->actx->idx[shared->adata->menu->current]->body->type != TYPE_MULTIPART)
1520 {
1521 mutt_error(_("Attachment is not 'multipart'"));
1522 return FR_ERROR;
1523 }
1524
1525 int aidx = shared->adata->menu->current;
1526 struct AttachCtx *actx = shared->adata->actx;
1527 struct Body *bptr = actx->idx[aidx]->body;
1528 struct Body *bptr_next = bptr->next;
1529 struct Body *bptr_previous = NULL;
1530 struct Body *bptr_parent = NULL;
1531 int parent_type = actx->idx[aidx]->parent_type;
1532 int level = actx->idx[aidx]->level;
1533
1534 // reorder body pointers
1535 if (attach_body_previous(shared->email->body, bptr, &bptr_previous))
1536 bptr_previous->next = bptr->parts;
1537 else if (attach_body_parent(shared->email->body, NULL, bptr, &bptr_parent))
1538 bptr_parent->parts = bptr->parts;
1539 else
1540 shared->email->body = bptr->parts;
1541
1542 // update attachment list
1543 int i = aidx + 1;
1544 while (actx->idx[i]->level > level)
1545 {
1546 actx->idx[i]->level--;
1547 if (actx->idx[i]->level == level)
1548 {
1549 actx->idx[i]->parent_type = parent_type;
1550 // set body->next for final attachment in group
1551 if (!actx->idx[i]->body->next)
1552 actx->idx[i]->body->next = bptr_next;
1553 }
1554 i++;
1555 if (i == actx->idxlen)
1556 break;
1557 }
1558
1559 // free memory
1560 actx->idx[aidx]->body->parts = NULL;
1561 actx->idx[aidx]->body->next = NULL;
1562 actx->idx[aidx]->body->email = NULL;
1563 mutt_body_free(&actx->idx[aidx]->body);
1564 FREE(&actx->idx[aidx]->tree);
1565 FREE(&actx->idx[aidx]);
1566
1567 // reorder attachment list
1568 for (int j = aidx; j < (actx->idxlen - 1); j++)
1569 actx->idx[j] = actx->idx[j + 1];
1570 actx->idx[actx->idxlen - 1] = NULL;
1571 actx->idxlen--;
1572 update_menu(actx, shared->adata->menu, false);
1573
1574 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1575 return FR_SUCCESS;
1576}
bool attach_body_parent(struct Body *start, struct Body *start_parent, struct Body *body, struct Body **body_parent)
Find the parent of a body.
Definition: lib.c:71
bool attach_body_previous(struct Body *start, struct Body *body, struct Body **previous)
Find the previous body of a body.
Definition: lib.c:142
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
char * tree
Tree characters to display.
Definition: attach.h:39
struct Email * email
header information for message/rfc822
Definition: body.h:73
int current
Current entry.
Definition: lib.h:70
+ Here is the call graph for this function:

◆ op_attachment_update_encoding()

static int op_attachment_update_encoding ( struct ComposeSharedData shared,
int  op 
)
static

Update an attachment's encoding info - Implements compose_function_t -.

Definition at line 1581 of file functions.c.

1582{
1583 struct AttachCtx *actx = shared->adata->actx;
1584 if (!check_count(actx))
1585 return FR_NO_ACTION;
1586
1587 int rc = FR_NO_ACTION;
1588 struct Menu *menu = shared->adata->menu;
1589 struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
1590 ba_add_tagged(&ba, actx, menu);
1591 if (ARRAY_EMPTY(&ba))
1592 goto done;
1593
1594 struct Body **bp = NULL;
1595 ARRAY_FOREACH(bp, &ba)
1596 {
1597 mutt_update_encoding(*bp, shared->sub);
1598 }
1599
1602 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1603 rc = FR_SUCCESS;
1604
1605done:
1606 ARRAY_FREE(&ba);
1607 return rc;
1608}
+ Here is the call graph for this function:

◆ op_envelope_edit_headers()

static int op_envelope_edit_headers ( struct ComposeSharedData shared,
int  op 
)
static

Edit the message with headers - Implements compose_function_t -.

Definition at line 1615 of file functions.c.

1616{
1618 const char *tag = NULL;
1619 char *err = NULL;
1620 mutt_env_to_local(shared->email->env);
1621 const char *const c_editor = cs_subset_string(shared->sub, "editor");
1622 if (shared->email->body->type == TYPE_MULTIPART)
1623 {
1624 struct Body *b = shared->email->body->parts;
1625 while (b->parts)
1626 b = b->parts;
1627 mutt_edit_headers(NONULL(c_editor), b->filename, shared->email, shared->fcc);
1628 }
1629 else
1630 {
1631 mutt_edit_headers(NONULL(c_editor), shared->email->body->filename,
1632 shared->email, shared->fcc);
1633 }
1634
1635 if (mutt_env_to_intl(shared->email->env, &tag, &err))
1636 {
1637 mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
1638 FREE(&err);
1639 }
1641
1643 mutt_update_encoding(shared->email->body, shared->sub);
1644
1645 /* attachments may have been added */
1646 if (shared->adata->actx->idxlen &&
1647 shared->adata->actx->idx[shared->adata->actx->idxlen - 1]->body->next)
1648 {
1650 update_menu(shared->adata->actx, shared->adata->menu, true);
1651 }
1652
1654 /* Unconditional hook since editor was invoked */
1655 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1656 return FR_SUCCESS;
1657}
void mutt_actx_entries_free(struct AttachCtx *actx)
Free entries in an Attachment Context.
Definition: attach.c:162
@ NT_EMAIL_CHANGE_ENVELOPE
Email's Envelope has changed.
Definition: email.h:152
int mutt_env_to_intl(struct Envelope *env, const char **tag, char **err)
Convert an Envelope's Address fields to Punycode format.
Definition: envelope.c:326
void mutt_env_to_local(struct Envelope *env)
Convert an Envelope's Address fields to local format.
Definition: envelope.c:288
void mutt_edit_headers(const char *editor, const char *body, struct Email *e, struct Buffer *fcc)
Let the user edit the message header and body.
Definition: mutt_header.c:172
void mutt_rfc3676_space_unstuff(struct Email *e)
Remove RFC3676 space stuffing.
Definition: rfc3676.c:494
void mutt_rfc3676_space_stuff(struct Email *e)
Perform RFC3676 space stuffing on an Email.
Definition: rfc3676.c:481
struct Buffer * fcc
Buffer to save FCC.
Definition: shared_data.h:40
struct Envelope * env
Envelope information.
Definition: email.h:66
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ op_compose_edit_file()

static int op_compose_edit_file ( struct ComposeSharedData shared,
int  op 
)
static

Edit the file to be attached - Implements compose_function_t -.

Definition at line 1662 of file functions.c.

1663{
1664 if (!check_count(shared->adata->actx))
1665 return FR_NO_ACTION;
1666 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1667 shared->adata->menu);
1668 if (cur_att->body->type == TYPE_MULTIPART)
1669 {
1670 mutt_error(_("Can't edit multipart attachments"));
1671 return FR_ERROR;
1672 }
1673 const char *const c_editor = cs_subset_string(shared->sub, "editor");
1674 mutt_edit_file(NONULL(c_editor), cur_att->body->filename);
1675 mutt_update_encoding(cur_att->body, shared->sub);
1678 /* Unconditional hook since editor was invoked */
1679 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1680 return FR_SUCCESS;
1681}
void mutt_edit_file(const char *editor, const char *file)
Let the user edit a file.
Definition: curs_lib.c:312
+ Here is the call graph for this function:

◆ op_compose_edit_message()

static int op_compose_edit_message ( struct ComposeSharedData shared,
int  op 
)
static

Edit the message - Implements compose_function_t -.

Definition at line 1686 of file functions.c.

1687{
1688 const bool c_edit_headers = cs_subset_bool(shared->sub, "edit_headers");
1689 if (!c_edit_headers)
1690 {
1692 const char *const c_editor = cs_subset_string(shared->sub, "editor");
1693 mutt_edit_file(c_editor, shared->email->body->filename);
1695 mutt_update_encoding(shared->email->body, shared->sub);
1697 /* Unconditional hook since editor was invoked */
1698 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1699 return FR_SUCCESS;
1700 }
1701
1702 return op_envelope_edit_headers(shared, op);
1703}
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
static int op_envelope_edit_headers(struct ComposeSharedData *shared, int op)
Edit the message with headers - Implements compose_function_t -.
Definition: functions.c:1615
+ Here is the call graph for this function:

◆ op_compose_ispell()

static int op_compose_ispell ( struct ComposeSharedData shared,
int  op 
)
static

Run ispell on the message - Implements compose_function_t -.

Definition at line 1708 of file functions.c.

1709{
1710 endwin();
1711 const char *const c_ispell = cs_subset_string(shared->sub, "ispell");
1712 char buf[PATH_MAX] = { 0 };
1713 snprintf(buf, sizeof(buf), "%s -x %s", NONULL(c_ispell), shared->email->body->filename);
1714 if (mutt_system(buf) == -1)
1715 {
1716 mutt_error(_("Error running \"%s\""), buf);
1717 return FR_ERROR;
1718 }
1719
1720 mutt_update_encoding(shared->email->body, shared->sub);
1722 return FR_SUCCESS;
1723}
#define PATH_MAX
Definition: mutt.h:40
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:51
+ Here is the call graph for this function:

◆ op_compose_postpone_message()

static int op_compose_postpone_message ( struct ComposeSharedData shared,
int  op 
)
static

Save this message to send later - Implements compose_function_t -.

Definition at line 1728 of file functions.c.

1729{
1730 if (check_attachments(shared->adata->actx, shared->sub) != 0)
1731 {
1733 return FR_ERROR;
1734 }
1735
1736 shared->rc = 1;
1737 return FR_DONE;
1738}
static int check_attachments(struct AttachCtx *actx, struct ConfigSubset *sub)
Check if any attachments have changed or been deleted.
Definition: functions.c:143
@ FR_DONE
Exit the Dialog.
Definition: dispatcher.h:35
int rc
Return code to leave compose.
Definition: shared_data.h:43
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ op_compose_rename_file()

static int op_compose_rename_file ( struct ComposeSharedData shared,
int  op 
)
static

Rename/move an attached file - Implements compose_function_t -.

Definition at line 1743 of file functions.c.

1744{
1745 if (!check_count(shared->adata->actx))
1746 return FR_NO_ACTION;
1747 struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
1748 shared->adata->menu);
1749 if (cur_att->body->type == TYPE_MULTIPART)
1750 {
1751 mutt_error(_("Can't rename multipart attachments"));
1752 return FR_ERROR;
1753 }
1754 struct Buffer *fname = mutt_buffer_pool_get();
1755 mutt_buffer_strcpy(fname, cur_att->body->filename);
1757 if ((mutt_buffer_get_field(_("Rename to: "), fname, MUTT_COMP_FILE, false,
1758 NULL, NULL, NULL) == 0) &&
1759 !mutt_buffer_is_empty(fname))
1760 {
1761 struct stat st = { 0 };
1762 if (stat(cur_att->body->filename, &st) == -1)
1763 {
1764 /* L10N: "stat" is a system call. Do "man 2 stat" for more information. */
1765 mutt_error(_("Can't stat %s: %s"), mutt_buffer_string(fname), strerror(errno));
1767 return FR_ERROR;
1768 }
1769
1771 if (mutt_file_rename(cur_att->body->filename, mutt_buffer_string(fname)))
1772 {
1774 return FR_ERROR;
1775 }
1776
1779
1780 if (cur_att->body->stamp >= st.st_mtime)
1781 mutt_stamp_attachment(cur_att->body);
1782 mutt_message_hook(NULL, shared->email, MUTT_SEND2_HOOK);
1783 }
1785 return FR_SUCCESS;
1786}
int mutt_file_rename(const char *oldfile, const char *newfile)
Rename a file.
Definition: file.c:1403
void mutt_stamp_attachment(struct Body *a)
Timestamp an Attachment.
Definition: sendlib.c:401
time_t stamp
Time stamp of last encoding update.
Definition: body.h:76
+ Here is the call graph for this function:

◆ op_compose_send_message()

static int op_compose_send_message ( struct ComposeSharedData shared,
int  op 
)
static

Send the message - Implements compose_function_t -.

Definition at line 1791 of file functions.c.

1792{
1793 /* Note: We don't invoke send2-hook here, since we want to leave
1794 * users an opportunity to change settings from the ":" prompt. */
1795 if (check_attachments(shared->adata->actx, shared->sub) != 0)
1796 {
1798 return FR_NO_ACTION;
1799 }
1800
1801#ifdef MIXMASTER
1802 if (!STAILQ_EMPTY(&shared->email->chain) && (mix_check_message(shared->email) != 0))
1803 return FR_NO_ACTION;
1804#endif
1805
1806 if (!shared->fcc_set && !mutt_buffer_is_empty(shared->fcc))
1807 {
1808 const enum QuadOption c_copy = cs_subset_quad(shared->sub, "copy");
1809 enum QuadOption ans = query_quadoption(c_copy, _("Save a copy of this message?"));
1810 if (ans == MUTT_ABORT)
1811 return FR_NO_ACTION;
1812 else if (ans == MUTT_NO)
1813 mutt_buffer_reset(shared->fcc);
1814 }
1815
1816 shared->rc = 0;
1817 return FR_DONE;
1818}
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:85
enum QuadOption cs_subset_quad(const struct ConfigSubset *sub, const char *name)
Get a quad-value config item by name.
Definition: helpers.c:218
int mix_check_message(struct Email *e)
Safety-check the message before passing it to mixmaster.
Definition: mixmaster.c:51
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: question.c:386
#define STAILQ_EMPTY(head)
Definition: queue.h:348
bool fcc_set
User has edited the Fcc: field.
Definition: shared_data.h:42
struct ListHead chain
Mixmaster chain.
Definition: email.h:90
+ Here is the call graph for this function:

◆ op_compose_write_message()

static int op_compose_write_message ( struct ComposeSharedData shared,
int  op 
)
static

Write the message to a folder - Implements compose_function_t -.

Definition at line 1823 of file functions.c.

1824{
1825 int rc = FR_NO_ACTION;
1826 struct Buffer *fname = mutt_buffer_pool_get();
1827 if (shared->mailbox)
1828 {
1829 mutt_buffer_strcpy(fname, mailbox_path(shared->mailbox));
1831 }
1832 if (shared->adata->actx->idxlen)
1833 shared->email->body = shared->adata->actx->idx[0]->body;
1834 if ((mutt_buffer_enter_fname(_("Write message to mailbox"), fname, true,
1835 shared->mailbox, false, NULL, NULL, MUTT_SEL_NO_FLAGS) != -1) &&
1836 !mutt_buffer_is_empty(fname))
1837 {
1838 mutt_message(_("Writing message to %s ..."), mutt_buffer_string(fname));
1840
1841 if (shared->email->body->next)
1842 shared->email->body = mutt_make_multipart(shared->email->body);
1843
1844 if (mutt_write_fcc(mutt_buffer_string(fname), shared->email, NULL, false,
1845 NULL, NULL, shared->sub) == 0)
1846 mutt_message(_("Message written"));
1847
1848 shared->email->body = mutt_remove_multipart(shared->email->body);
1849 rc = FR_SUCCESS;
1850 }
1852 return rc;
1853}
struct Body * mutt_remove_multipart(struct Body *b)
Extract the multipart body if it exists.
Definition: multipart.c:126
struct Body * mutt_make_multipart(struct Body *b)
Create a multipart email.
Definition: multipart.c:100
int mutt_write_fcc(const char *path, struct Email *e, const char *msgid, bool post, const char *fcc, char **finalpath, struct ConfigSubset *sub)
Write email to FCC mailbox.
Definition: sendlib.c:1030
+ Here is the call graph for this function:

◆ op_display_headers()

static int op_display_headers ( struct ComposeSharedData shared,
int  op 
)
static

Display message and toggle header weeding - Implements compose_function_t -.

This function handles:

  • OP_ATTACHMENT_VIEW
  • OP_DISPLAY_HEADERS

Definition at line 1862 of file functions.c.

1863{
1864 if (!check_count(shared->adata->actx))
1865 return FR_NO_ACTION;
1866 mutt_attach_display_loop(shared->sub, shared->adata->menu, op, shared->email,
1867 shared->adata->actx, false);
1869 /* no send2hook, since this doesn't modify the message */
1870 return FR_SUCCESS;
1871}
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:938
+ Here is the call graph for this function:

◆ op_exit()

static int op_exit ( struct ComposeSharedData shared,
int  op 
)
static

Exit this menu - Implements compose_function_t -.

Definition at line 1876 of file functions.c.

1877{
1878 const enum QuadOption c_postpone = cs_subset_quad(shared->sub, "postpone");
1879 enum QuadOption ans = query_quadoption(c_postpone, _("Save (postpone) draft message?"));
1880 if (ans == MUTT_NO)
1881 {
1882 for (int i = 0; i < shared->adata->actx->idxlen; i++)
1883 if (shared->adata->actx->idx[i]->unowned)
1884 shared->adata->actx->idx[i]->body->unlink = false;
1885
1886 if (!(shared->flags & MUTT_COMPOSE_NOFREEHEADER))
1887 {
1888 for (int i = 0; i < shared->adata->actx->idxlen; i++)
1889 {
1890 /* avoid freeing other attachments */
1891 shared->adata->actx->idx[i]->body->next = NULL;
1892 /* See the comment in delete_attachment() */
1893 if (!shared->adata->actx->idx[i]->body->email)
1894 shared->adata->actx->idx[i]->body->parts = NULL;
1895 mutt_body_free(&shared->adata->actx->idx[i]->body);
1896 }
1897 }
1898 shared->rc = -1;
1899 return FR_DONE;
1900 }
1901 else if (ans == MUTT_ABORT)
1902 return FR_NO_ACTION;
1903
1904 return op_compose_postpone_message(shared, op);
1905}
#define MUTT_COMPOSE_NOFREEHEADER
Definition: lib.h:50
static int op_compose_postpone_message(struct ComposeSharedData *shared, int op)
Save this message to send later - Implements compose_function_t -.
Definition: functions.c:1728
int flags
Flags, e.g. MUTT_COMPOSE_NOFREEHEADER.
Definition: shared_data.h:41
+ Here is the call graph for this function:

◆ op_forget_passphrase()

static int op_forget_passphrase ( struct ComposeSharedData shared,
int  op 
)
static

Wipe passphrases from memory - Implements compose_function_t -.

Definition at line 1910 of file functions.c.

1911{
1913 return FR_SUCCESS;
1914}
void crypt_forget_passphrase(void)
Forget a passphrase and display a message.
Definition: crypt.c:92
+ Here is the call graph for this function: