NeoMutt  2021-10-22-8-g9cb437
Teaching an old dog new tricks
DOXYGEN
recvcmd.h File Reference

Send/reply with an attachment. More...

#include <stdio.h>
#include "send/lib.h"
+ Include dependency graph for recvcmd.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void mutt_attach_bounce (struct Mailbox *m, FILE *fp, struct AttachCtx *actx, struct Body *cur)
 Bounce function, from the attachment menu. More...
 
void mutt_attach_resend (FILE *fp, struct Mailbox *m, struct AttachCtx *actx, struct Body *cur)
 Resend-message, from the attachment menu. More...
 
void mutt_attach_forward (FILE *fp, struct Email *e, struct AttachCtx *actx, struct Body *cur, SendFlags flags)
 Forward an Attachment. More...
 
void mutt_attach_reply (FILE *fp, struct Mailbox *m, struct Email *e, struct AttachCtx *actx, struct Body *e_cur, SendFlags flags)
 Attach a reply. More...
 
void mutt_attach_mail_sender (struct AttachCtx *actx, struct Body *cur)
 Compose an email to the sender in the email attachment. More...
 

Detailed Description

Send/reply with an attachment.

Authors
  • Thomas Roessler

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file recvcmd.h.

Function Documentation

◆ mutt_attach_bounce()

void mutt_attach_bounce ( struct Mailbox m,
FILE *  fp,
struct AttachCtx actx,
struct Body cur 
)

Bounce function, from the attachment menu.

Parameters
mMailbox
fpHandle of message
actxAttachment context
curBody of email

Definition at line 161 of file recvcmd.c.

162 {
163  if (!m || !fp || !actx)
164  return;
165 
166  char prompt[256];
167  char buf[8192];
168  char *err = NULL;
169  int ret = 0;
170  int p = 0;
171 
172  if (!check_all_msg(actx, cur, true))
173  return;
174 
175  /* one or more messages? */
176  p = cur ? 1 : count_tagged(actx);
177 
178  /* RFC5322 mandates a From: header, so warn before bouncing
179  * messages without one */
180  if (cur)
181  {
182  if (TAILQ_EMPTY(&cur->email->env->from))
183  {
184  mutt_error(_("Warning: message contains no From: header"));
186  }
187  }
188  else
189  {
190  for (short i = 0; i < actx->idxlen; i++)
191  {
192  if (actx->idx[i]->body->tagged)
193  {
194  if (TAILQ_EMPTY(&actx->idx[i]->body->email->env->from))
195  {
196  mutt_error(_("Warning: message contains no From: header"));
198  break;
199  }
200  }
201  }
202  }
203 
204  if (p)
205  mutt_str_copy(prompt, _("Bounce message to: "), sizeof(prompt));
206  else
207  mutt_str_copy(prompt, _("Bounce tagged messages to: "), sizeof(prompt));
208 
209  buf[0] = '\0';
210  if (mutt_get_field(prompt, buf, sizeof(buf), MUTT_ALIAS, false, NULL, NULL) ||
211  (buf[0] == '\0'))
212  {
213  return;
214  }
215 
216  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
217  mutt_addrlist_parse(&al, buf);
218  if (TAILQ_EMPTY(&al))
219  {
220  mutt_error(_("Error parsing address"));
221  return;
222  }
223 
224  mutt_expand_aliases(&al);
225 
226  if (mutt_addrlist_to_intl(&al, &err) < 0)
227  {
228  mutt_error(_("Bad IDN: '%s'"), err);
229  FREE(&err);
230  goto end;
231  }
232 
233  buf[0] = '\0';
234  mutt_addrlist_write(&al, buf, sizeof(buf), true);
235 
236 #define EXTRA_SPACE (15 + 7 + 2)
237  /* See commands.c. */
238  snprintf(prompt, sizeof(prompt) - 4,
239  ngettext("Bounce message to %s?", "Bounce messages to %s?", p), buf);
240 
241  const size_t width = msgwin_get_width();
242  if (mutt_strwidth(prompt) > (width - EXTRA_SPACE))
243  {
244  mutt_simple_format(prompt, sizeof(prompt) - 4, 0, width - EXTRA_SPACE,
245  JUSTIFY_LEFT, 0, prompt, sizeof(prompt), false);
246  mutt_str_cat(prompt, sizeof(prompt), "...?");
247  }
248  else
249  mutt_str_cat(prompt, sizeof(prompt), "?");
250 
251  const enum QuadOption c_bounce = cs_subset_quad(NeoMutt->sub, "bounce");
252  if (query_quadoption(c_bounce, prompt) != MUTT_YES)
253  {
255  mutt_message(ngettext("Message not bounced", "Messages not bounced", p));
256  goto end;
257  }
258 
260 
261  if (cur)
262  ret = mutt_bounce_message(fp, m, cur->email, &al, NeoMutt->sub);
263  else
264  {
265  for (short i = 0; i < actx->idxlen; i++)
266  {
267  if (actx->idx[i]->body->tagged)
268  {
269  if (mutt_bounce_message(actx->idx[i]->fp, m, actx->idx[i]->body->email,
270  &al, NeoMutt->sub))
271  {
272  ret = 1;
273  }
274  }
275  }
276  }
277 
278  if (ret == 0)
279  mutt_message(ngettext("Message bounced", "Messages bounced", p));
280  else
281  mutt_error(ngettext("Error bouncing message", "Error bouncing messages", p));
282 
283 end:
284  mutt_addrlist_clear(&al);
285 }
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1470
size_t mutt_addrlist_write(const struct AddressList *al, char *buf, size_t buflen, bool display)
Write an Address to a buffer.
Definition: address.c:1150
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:458
int mutt_addrlist_to_intl(struct AddressList *al, char **err)
Convert an Address list to Punycode.
Definition: address.c:1305
void mutt_expand_aliases(struct AddressList *al)
Expand aliases in a List of Addresses.
Definition: alias.c:300
void mutt_simple_format(char *buf, size_t buflen, int min_width, int max_width, enum FormatJustify justify, char pad_char, const char *s, size_t n, bool arboreal)
Format a string, like snprintf()
Definition: curs_lib.c:721
int mutt_get_field(const char *field, char *buf, size_t buflen, CompletionFlags complete, bool multiple, char ***files, int *numfiles)
Ask the user for a string.
Definition: curs_lib.c:335
int mutt_strwidth(const char *s)
Measure a string's width in screen cells.
Definition: curs_lib.c:988
@ JUSTIFY_LEFT
Left justify the text.
Definition: curs_lib.h:43
#define mutt_error(...)
Definition: logging.h:87
#define mutt_message(...)
Definition: logging.h:86
enum QuadOption cs_subset_quad(const struct ConfigSubset *sub, const char *name)
Get a quad-value config item by name.
Definition: helpers.c:218
#define FREE(x)
Definition: memory.h:40
size_t msgwin_get_width(void)
Get the width of the Message Window.
Definition: msgwin.c:260
void msgwin_clear_text(void)
Clear the text in the Message Window.
Definition: msgwin.c:240
#define _(a)
Definition: message.h:28
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:749
char * mutt_str_cat(char *buf, size_t buflen, const char *s)
Concatenate two strings.
Definition: string.c:385
#define MUTT_ALIAS
Do alias "completion" by calling up the alias-menu.
Definition: mutt.h:53
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:113
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_quadoption(enum QuadOption opt, const char *prompt)
Ask the user a quad-question.
Definition: question.c:349
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
#define TAILQ_EMPTY(head)
Definition: queue.h:721
static short count_tagged(struct AttachCtx *actx)
Count the number of tagged attachments.
Definition: recvcmd.c:126
#define EXTRA_SPACE
static bool check_all_msg(struct AttachCtx *actx, struct Body *cur, bool err)
Are all the Attachments RFC822 messages?
Definition: recvcmd.c:85
int mutt_bounce_message(FILE *fp, struct Mailbox *m, struct Email *e, struct AddressList *to, struct ConfigSubset *sub)
Bounce an email message.
Definition: sendlib.c:1392
struct AttachPtr ** idx
Array of attachments.
Definition: attach.h:54
short idxlen
Number of attachmentes.
Definition: attach.h:55
struct Body * body
Attachment.
Definition: attach.h:36
FILE * fp
Used in the recvattach menu.
Definition: attach.h:37
struct Email * email
header information for message/rfc822
Definition: body.h:72
bool tagged
This attachment is tagged.
Definition: body.h:89
struct Envelope * env
Envelope information.
Definition: email.h:66
struct AddressList from
Email's 'From' list.
Definition: envelope.h:57
Container for Accounts, Notifications.
Definition: neomutt.h:37
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_attach_resend()

void mutt_attach_resend ( FILE *  fp,
struct Mailbox m,
struct AttachCtx actx,
struct Body cur 
)

Resend-message, from the attachment menu.

Parameters
fpFile containing email
mCurrent mailbox
actxAttachment context
curAttachment

Definition at line 294 of file recvcmd.c.

295 {
296  if (!check_all_msg(actx, cur, true))
297  return;
298 
299  if (cur)
300  mutt_resend_message(fp, m, cur->email, NeoMutt->sub);
301  else
302  {
303  for (short i = 0; i < actx->idxlen; i++)
304  {
305  if (actx->idx[i]->body->tagged)
306  {
307  mutt_resend_message(actx->idx[i]->fp, m, actx->idx[i]->body->email,
308  NeoMutt->sub);
309  }
310  }
311  }
312 }
int mutt_resend_message(FILE *fp, struct Mailbox *m, struct Email *e_cur, struct ConfigSubset *sub)
Resend an email.
Definition: send.c:1616
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_attach_forward()

void mutt_attach_forward ( FILE *  fp,
struct Email e,
struct AttachCtx actx,
struct Body cur,
SendFlags  flags 
)

Forward an Attachment.

Parameters
fpHandle to the attachment
eEmail
actxAttachment Context
curCurrent message
flagsSend mode, see SendFlags

Definition at line 784 of file recvcmd.c.

786 {
787  if (check_all_msg(actx, cur, false))
788  attach_forward_msgs(fp, actx, cur, flags);
789  else
790  {
791  const short nattach = count_tagged(actx);
792  attach_forward_bodies(fp, e, actx, cur, nattach);
793  }
794 }
static void attach_forward_bodies(FILE *fp, struct Email *e, struct AttachCtx *actx, struct Body *cur, short nattach)
Forward one or several MIME bodies.
Definition: recvcmd.c:471
static void attach_forward_msgs(FILE *fp, struct AttachCtx *actx, struct Body *cur, SendFlags flags)
Forward one or several message-type attachments.
Definition: recvcmd.c:654
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_attach_reply()

void mutt_attach_reply ( FILE *  fp,
struct Mailbox m,
struct Email e,
struct AttachCtx actx,
struct Body e_cur,
SendFlags  flags 
)

Attach a reply.

Parameters
fpFile handle to reply
mMailbox
eEmail
actxAttachment Context
e_curCurrent message
flagsSend mode, see SendFlags

Definition at line 938 of file recvcmd.c.

940 {
941  bool mime_reply_any = false;
942 
943  short nattach = 0;
944  struct AttachPtr *parent = NULL;
945  struct Email *e_parent = NULL;
946  FILE *fp_parent = NULL;
947  struct Email *e_tmp = NULL;
948  FILE *fp_tmp = NULL;
949  struct Buffer *tmpbody = NULL;
950  struct EmailList el = STAILQ_HEAD_INITIALIZER(el);
951 
952  char prefix[128];
953 
954 #ifdef USE_NNTP
955  if (flags & SEND_NEWS)
956  OptNewsSend = true;
957  else
958  OptNewsSend = false;
959 #endif
960 
961  if (!check_all_msg(actx, e_cur, false))
962  {
963  nattach = count_tagged(actx);
964  parent = find_parent(actx, e_cur, nattach);
965  if (parent)
966  {
967  e_parent = parent->body->email;
968  fp_parent = parent->fp;
969  }
970  else
971  {
972  e_parent = e;
973  fp_parent = actx->fp_root;
974  }
975  }
976 
977  if ((nattach > 1) && !check_can_decode(actx, e_cur))
978  {
979  const enum QuadOption c_mime_forward_rest =
980  cs_subset_quad(NeoMutt->sub, "mime_forward_rest");
981  const enum QuadOption ans = query_quadoption(
982  c_mime_forward_rest, _("Can't decode all tagged attachments. "
983  "MIME-encapsulate the others?"));
984  if (ans == MUTT_ABORT)
985  return;
986  if (ans == MUTT_YES)
987  mime_reply_any = true;
988  }
989  else if (nattach == 1)
990  mime_reply_any = true;
991 
992  e_tmp = email_new();
993  e_tmp->env = mutt_env_new();
994 
996  e_tmp->env, actx, e_parent ? e_parent : (e_cur ? e_cur->email : NULL), flags) == -1)
997  {
998  goto cleanup;
999  }
1000 
1001  tmpbody = mutt_buffer_pool_get();
1002  mutt_buffer_mktemp(tmpbody);
1003  fp_tmp = mutt_file_fopen(mutt_buffer_string(tmpbody), "w");
1004  if (!fp_tmp)
1005  {
1006  mutt_error(_("Can't create %s"), mutt_buffer_string(tmpbody));
1007  goto cleanup;
1008  }
1009 
1010  if (!e_parent)
1011  {
1012  if (e_cur)
1013  attach_include_reply(fp, fp_tmp, e_cur->email);
1014  else
1015  {
1016  for (short i = 0; i < actx->idxlen; i++)
1017  {
1018  if (actx->idx[i]->body->tagged)
1019  attach_include_reply(actx->idx[i]->fp, fp_tmp, actx->idx[i]->body->email);
1020  }
1021  }
1022  }
1023  else
1024  {
1025  mutt_make_attribution(e_parent, fp_tmp, NeoMutt->sub);
1026 
1027  struct State st;
1028  memset(&st, 0, sizeof(struct State));
1029  st.fp_out = fp_tmp;
1030 
1031  const bool c_text_flowed = cs_subset_bool(NeoMutt->sub, "text_flowed");
1032  if (c_text_flowed)
1033  {
1034  mutt_str_copy(prefix, ">", sizeof(prefix));
1035  }
1036  else
1037  {
1038  const char *const c_indent_string =
1039  cs_subset_string(NeoMutt->sub, "indent_string");
1040  mutt_make_string(prefix, sizeof(prefix), 0, NONULL(c_indent_string), m,
1041  -1, e_parent, MUTT_FORMAT_NO_FLAGS, NULL);
1042  }
1043 
1044  st.prefix = prefix;
1045  st.flags = MUTT_CHARCONV;
1046 
1047  const bool c_weed = cs_subset_bool(NeoMutt->sub, "weed");
1048  if (c_weed)
1049  st.flags |= MUTT_WEED;
1050 
1051  const bool c_header = cs_subset_bool(NeoMutt->sub, "header");
1052  if (c_header)
1053  include_header(true, fp_parent, e_parent, fp_tmp, prefix);
1054 
1055  if (e_cur)
1056  {
1057  if (mutt_can_decode(e_cur))
1058  {
1059  st.fp_in = fp;
1060  mutt_body_handler(e_cur, &st);
1061  state_putc(&st, '\n');
1062  }
1063  else
1064  mutt_body_copy(fp, &e_tmp->body, e_cur);
1065  }
1066  else
1067  {
1068  for (short i = 0; i < actx->idxlen; i++)
1069  {
1070  if (actx->idx[i]->body->tagged && mutt_can_decode(actx->idx[i]->body))
1071  {
1072  st.fp_in = actx->idx[i]->fp;
1073  mutt_body_handler(actx->idx[i]->body, &st);
1074  state_putc(&st, '\n');
1075  }
1076  }
1077  }
1078 
1079  mutt_make_post_indent(e_parent, fp_tmp, NeoMutt->sub);
1080 
1081  if (mime_reply_any && !e_cur && !copy_problematic_attachments(&e_tmp->body, actx, false))
1082  {
1083  goto cleanup;
1084  }
1085  }
1086 
1087  mutt_file_fclose(&fp_tmp);
1088 
1089  emaillist_add_email(&el, e_parent ? e_parent : (e_cur ? e_cur->email : NULL));
1090  if (mutt_send_message(flags, e_tmp, mutt_buffer_string(tmpbody), NULL, &el,
1091  NeoMutt->sub) == 0)
1092  {
1093  mutt_set_flag(m, e, MUTT_REPLIED, true);
1094  }
1095  e_tmp = NULL; /* mutt_send_message frees this */
1096 
1097 cleanup:
1098  if (fp_tmp)
1099  {
1100  mutt_file_fclose(&fp_tmp);
1102  }
1103  mutt_buffer_pool_release(&tmpbody);
1104  email_free(&e_tmp);
1105  emaillist_clear(&el);
1106 }
static const char * mutt_buffer_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:77
int emaillist_add_email(struct EmailList *el, struct Email *e)
Add an Email to a list.
Definition: email.c:159
struct Email * email_new(void)
Create a new Email.
Definition: email.c:78
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:44
void emaillist_clear(struct EmailList *el)
Drop a private list of Emails.
Definition: email.c:138
struct Envelope * mutt_env_new(void)
Create a new Envelope.
Definition: envelope.c:42
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:593
void mutt_file_unlink(const char *s)
Delete a file, carefully.
Definition: file.c:195
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
bool mutt_can_decode(struct Body *a)
Will decoding the attachment produce any output.
Definition: handler.c:1814
int mutt_body_handler(struct Body *b, struct State *s)
Handler for the Body of an email.
Definition: handler.c:1597
void mutt_make_string(char *buf, size_t buflen, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags, const char *progress)
Create formatted strings using mailbox expandos.
Definition: hdrline.c:1410
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:73
@ MUTT_REPLIED
Messages that have been replied to.
Definition: mutt.h:91
int mutt_body_copy(FILE *fp, struct Body **tgt, struct Body *src)
Create a send-mode duplicate from a receive-mode body.
Definition: mutt_body.c:48
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:74
bool OptNewsSend
(pseudo) used to change behavior when posting
Definition: options.h:51
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
#define mutt_set_flag(m, e, flag, bf)
Definition: protos.h:66
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
static void attach_include_reply(FILE *fp, FILE *fp_tmp, struct Email *e)
This is very similar to send.c's include_reply()
Definition: recvcmd.c:908
static struct Body ** copy_problematic_attachments(struct Body **last, struct AttachCtx *actx, bool force)
Attach the body parts which can't be decoded.
Definition: recvcmd.c:446
static void include_header(bool quote, FILE *fp_in, struct Email *e, FILE *fp_out, char *prefix)
Write an email header to a file, optionally quoting it.
Definition: recvcmd.c:407
static bool check_can_decode(struct AttachCtx *actx, struct Body *cur)
Can we decode all tagged attachments?
Definition: recvcmd.c:109
static int attach_reply_envelope_defaults(struct Envelope *env, struct AttachCtx *actx, struct Email *parent, SendFlags flags)
Create the envelope defaults for a reply.
Definition: recvcmd.c:815
static struct AttachPtr * find_parent(struct AttachCtx *actx, struct Body *cur, short nattach)
Find the parent of an Attachment.
Definition: recvcmd.c:376
void mutt_make_post_indent(struct Email *e, FILE *fp_out, struct ConfigSubset *sub)
Add suffix to replied email text.
Definition: send.c:714
void mutt_make_attribution(struct Email *e, FILE *fp_out, struct ConfigSubset *sub)
Add "on DATE, PERSON wrote" header.
Definition: send.c:606
int mutt_send_message(SendFlags flags, struct Email *e_templ, const char *tempfile, struct Mailbox *m, struct EmailList *el, struct ConfigSubset *sub)
Send an email.
Definition: send.c:2110
#define SEND_NEWS
Reply to a news article.
Definition: send.h:53
#define MUTT_WEED
Weed headers even when not in display mode.
Definition: state.h:35
#define state_putc(STATE, STR)
Definition: state.h:56
#define MUTT_CHARCONV
Do character set conversions.
Definition: state.h:36
#define NONULL(x)
Definition: string2.h:37
FILE * fp_root
Used by recvattach for updating.
Definition: attach.h:52
An email to which things will be attached.
Definition: attach.h:35
String manipulation buffer.
Definition: buffer.h:34
The envelope/body of an email.
Definition: email.h:37
struct Body * body
List of MIME parts.
Definition: email.h:67
Keep track when processing files.
Definition: state.h:45
StateFlags flags
Flags, e.g. MUTT_DISPLAY.
Definition: state.h:49
char * prefix
String to add to the beginning of each output line.
Definition: state.h:48
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_attach_mail_sender()

void mutt_attach_mail_sender ( struct AttachCtx actx,
struct Body cur 
)

Compose an email to the sender in the email attachment.

Parameters
actxAttachment Context
curCurrent attachment

Definition at line 1113 of file recvcmd.c.

1114 {
1115  if (!check_all_msg(actx, cur, 0))
1116  {
1117  /* L10N: You will see this error message if you invoke <compose-to-sender>
1118  when you are on a normal attachment. */
1119  mutt_error(_("You may only compose to sender with message/rfc822 parts"));
1120  return;
1121  }
1122 
1123  struct Email *e_tmp = email_new();
1124  e_tmp->env = mutt_env_new();
1125 
1126  if (cur)
1127  {
1128  if (mutt_fetch_recips(e_tmp->env, cur->email->env, SEND_TO_SENDER, NeoMutt->sub) == -1)
1129  {
1130  email_free(&e_tmp);
1131  return;
1132  }
1133  }
1134  else
1135  {
1136  for (int i = 0; i < actx->idxlen; i++)
1137  {
1138  if (actx->idx[i]->body->tagged &&
1139  (mutt_fetch_recips(e_tmp->env, actx->idx[i]->body->email->env,
1140  SEND_TO_SENDER, NeoMutt->sub) == -1))
1141  {
1142  email_free(&e_tmp);
1143  return;
1144  }
1145  }
1146  }
1147 
1148  // This call will free e_tmp for us
1149  mutt_send_message(SEND_NO_FLAGS, e_tmp, NULL, NULL, NULL, NeoMutt->sub);
1150 }
int mutt_fetch_recips(struct Envelope *out, struct Envelope *in, SendFlags flags, struct ConfigSubset *sub)
Generate recpients for a reply email.
Definition: send.c:900
#define SEND_TO_SENDER
Compose new email to sender.
Definition: send.h:51
#define SEND_NO_FLAGS
No flags are set.
Definition: send.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function: