remove yet anoter round of str_* functions, replaced with their inlineable
[apps/madmutt.git] / recvcmd.c
1 /*
2  * Copyright notice from original mutt:
3  * Copyright (C) 1999-2000 Thomas Roessler <roessler@does-not-exist.org>
4  *
5  * This file is part of mutt-ng, see http://www.muttng.org/.
6  * It's licensed under the GNU General Public License,
7  * please see the file GPL in the top level source directory.
8  */
9
10 #if HAVE_CONFIG_H
11 # include "config.h"
12 #endif
13
14 #include <lib-lib/mem.h>
15 #include <lib-lib/str.h>
16 #include <lib-lib/macros.h>
17 #include <lib-lib/file.h>
18
19 #include "mutt.h"
20 #include "enter.h"
21 #include "state.h"
22 #include "handler.h"
23 #include "recvattach.h"
24 #include "mutt_curses.h"
25 #include "mutt_menu.h"
26 #include "rfc1524.h"
27 #include "mime.h"
28 #include "attach.h"
29 #include "mapping.h"
30 #include "mx.h"
31 #include "copy.h"
32 #include "mutt_idna.h"
33
34
35 /* some helper functions to verify that we are exclusively operating
36  * on message/rfc822 attachments
37  */
38
39 static short check_msg (BODY * b, short err)
40 {
41   if (!mutt_is_message_type (b->type, b->subtype)) {
42     if (err)
43       mutt_error _("You may only bounce message/rfc822 parts.");
44
45     return -1;
46   }
47   return 0;
48 }
49
50 static short check_all_msg (ATTACHPTR ** idx, short idxlen,
51                             BODY * cur, short err)
52 {
53   short i;
54
55   if (cur && check_msg (cur, err) == -1)
56     return -1;
57   else if (!cur) {
58     for (i = 0; i < idxlen; i++) {
59       if (idx[i]->content->tagged) {
60         if (check_msg (idx[i]->content, err) == -1)
61           return -1;
62       }
63     }
64   }
65   return 0;
66 }
67
68
69 /* can we decode all tagged attachments? */
70
71 static short check_can_decode (ATTACHPTR ** idx, short idxlen, BODY * cur)
72 {
73   short i;
74
75   if (cur)
76     return mutt_can_decode (cur);
77
78   for (i = 0; i < idxlen; i++)
79     if (idx[i]->content->tagged && !mutt_can_decode (idx[i]->content))
80       return 0;
81
82   return 1;
83 }
84
85 static short count_tagged (ATTACHPTR ** idx, short idxlen)
86 {
87   short count = 0;
88   short i;
89
90   for (i = 0; i < idxlen; i++)
91     if (idx[i]->content->tagged)
92       count++;
93
94   return count;
95 }
96
97 /* count the number of tagged children below a multipart or message
98  * attachment.
99  */
100
101 static short count_tagged_children (ATTACHPTR ** idx, short idxlen, short i)
102 {
103   short level = idx[i]->level;
104   short count = 0;
105
106   while ((++i < idxlen) && (level < idx[i]->level))
107     if (idx[i]->content->tagged)
108       count++;
109
110   return count;
111 }
112 \f
113
114
115 /**
116  **
117  ** The bounce function, from the attachment menu
118  **
119  **/
120
121 void mutt_attach_bounce (FILE * fp, HEADER * hdr,
122                          ATTACHPTR ** idx, short idxlen, BODY * cur)
123 {
124   short i;
125   char prompt[STRING];
126   char buf[HUGE_STRING];
127   char *err = NULL;
128   ADDRESS *adr = NULL;
129   int ret = 0;
130   int p = 0;
131
132   if (check_all_msg (idx, idxlen, cur, 1) == -1)
133     return;
134
135   /* one or more messages? */
136   p = (cur || count_tagged (idx, idxlen) == 1);
137
138   if (p)
139     strfcpy (prompt, _("Bounce message to: "), sizeof (prompt));
140   else
141     strfcpy (prompt, _("Bounce tagged messages to: "), sizeof (prompt));
142
143   buf[0] = '\0';
144   if (mutt_get_field (prompt, buf, sizeof (buf), M_ALIAS)
145       || buf[0] == '\0')
146     return;
147
148   if (!(adr = rfc822_parse_adrlist (adr, buf))) {
149     mutt_error _("Error parsing address!");
150
151     return;
152   }
153
154   adr = mutt_expand_aliases (adr);
155
156   if (mutt_addrlist_to_idna (adr, &err) < 0) {
157     mutt_error (_("Bad IDN: '%s'"), err);
158     p_delete(&err);
159     rfc822_free_address (&adr);
160     return;
161   }
162
163   buf[0] = 0;
164   rfc822_write_address (buf, sizeof (buf), adr, 1);
165
166 #define extra_space (15+7+2)
167   /*
168    * See commands.c.
169    */
170   snprintf (prompt, sizeof (prompt) - 4,
171             (p ? _("Bounce message to %s") : _("Bounce messages to %s")),
172             buf);
173
174   if (mutt_strwidth (prompt) > COLS - extra_space) {
175     mutt_format_string (prompt, sizeof (prompt) - 4,
176                         0, COLS - extra_space, 0, 0,
177                         prompt, sizeof (prompt), 0);
178     m_strcat(prompt, sizeof(prompt), "...?");
179   } else {
180     m_strcat(prompt, sizeof(prompt), "?");
181   }
182
183   if (query_quadoption (OPT_BOUNCE, prompt) != M_YES) {
184     rfc822_free_address (&adr);
185     CLEARLINE (LINES - 1);
186     mutt_message (p ? _("Message not bounced.") : _("Messages not bounced."));
187     return;
188   }
189
190   CLEARLINE (LINES - 1);
191
192   if (cur)
193     ret = mutt_bounce_message (fp, cur->hdr, adr);
194   else {
195     for (i = 0; i < idxlen; i++) {
196       if (idx[i]->content->tagged)
197         if (mutt_bounce_message (fp, idx[i]->content->hdr, adr))
198           ret = 1;
199     }
200   }
201
202   if (!ret)
203     mutt_message (p ? _("Message bounced.") : _("Messages bounced."));
204   else
205     mutt_error (p ? _("Error bouncing message!") :
206                 _("Error bouncing messages!"));
207 }
208 \f
209
210
211 /**
212  **
213  ** resend-message, from the attachment menu 
214  **
215  **
216  **/
217
218 void mutt_attach_resend (FILE * fp, HEADER * hdr, ATTACHPTR ** idx,
219                          short idxlen, BODY * cur)
220 {
221   short i;
222
223   if (check_all_msg (idx, idxlen, cur, 1) == -1)
224     return;
225
226   if (cur)
227     mutt_resend_message (fp, Context, cur->hdr);
228   else {
229     for (i = 0; i < idxlen; i++)
230       if (idx[i]->content->tagged)
231         mutt_resend_message (fp, Context, idx[i]->content->hdr);
232   }
233 }
234 \f
235
236 /**
237  **
238  ** forward-message, from the attachment menu 
239  **
240  **/
241
242 /* try to find a common parent message for the tagged attachments. */
243
244 static HEADER *find_common_parent (ATTACHPTR ** idx, short idxlen,
245                                    short nattach)
246 {
247   short i;
248   short nchildren;
249
250   for (i = 0; i < idxlen; i++)
251     if (idx[i]->content->tagged)
252       break;
253
254   while (--i >= 0) {
255     if (mutt_is_message_type
256         (idx[i]->content->type, idx[i]->content->subtype)) {
257       nchildren = count_tagged_children (idx, idxlen, i);
258       if (nchildren == nattach)
259         return idx[i]->content->hdr;
260     }
261   }
262
263   return NULL;
264 }
265
266 /* 
267  * check whether attachment #i is a parent of the attachment
268  * pointed to by cur
269  * 
270  * Note: This and the calling procedure could be optimized quite a 
271  * bit.  For now, it's not worth the effort.
272  */
273
274 static int is_parent (short i, ATTACHPTR ** idx, short idxlen, BODY * cur)
275 {
276   short level = idx[i]->level;
277
278   while ((++i < idxlen) && idx[i]->level > level) {
279     if (idx[i]->content == cur)
280       return 1;
281   }
282
283   return 0;
284 }
285
286 static HEADER *find_parent (ATTACHPTR ** idx, short idxlen, BODY * cur,
287                             short nattach)
288 {
289   short i;
290   HEADER *parent = NULL;
291
292   if (cur) {
293     for (i = 0; i < idxlen; i++) {
294       if (mutt_is_message_type
295           (idx[i]->content->type, idx[i]->content->subtype)
296           && is_parent (i, idx, idxlen, cur))
297         parent = idx[i]->content->hdr;
298       if (idx[i]->content == cur)
299         break;
300     }
301   }
302   else if (nattach)
303     parent = find_common_parent (idx, idxlen, nattach);
304
305   return parent;
306 }
307
308 static void include_header (int quote, FILE * ifp,
309                             HEADER * hdr, FILE * ofp, char *_prefix)
310 {
311   int chflags = CH_DECODE;
312   char prefix[SHORT_STRING];
313
314   if (option (OPTWEED))
315     chflags |= CH_WEED | CH_REORDER;
316
317   if (quote) {
318     if (_prefix)
319       strfcpy (prefix, _prefix, sizeof (prefix));
320     else if (!option (OPTTEXTFLOWED))
321       _mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix),
322                          Context, hdr, 0);
323     else
324       strfcpy (prefix, ">", sizeof (prefix));
325
326     chflags |= CH_PREFIX;
327   }
328
329   mutt_copy_header (ifp, hdr, ofp, chflags, quote ? prefix : NULL);
330 }
331
332 /* Attach all the body parts which can't be decoded. 
333  * This code is shared by forwarding and replying. */
334
335 static BODY **copy_problematic_attachments (FILE * fp,
336                                             BODY ** last,
337                                             ATTACHPTR ** idx,
338                                             short idxlen, short force)
339 {
340   short i;
341
342   for (i = 0; i < idxlen; i++) {
343     if (idx[i]->content->tagged &&
344         (force || !mutt_can_decode (idx[i]->content))) {
345       if (mutt_copy_body (fp, last, idx[i]->content) == -1)
346         return NULL;            /* XXXXX - may lead to crashes */
347       last = &((*last)->next);
348     }
349   }
350   return last;
351 }
352
353 /* 
354  * forward one or several MIME bodies 
355  * (non-message types)
356  */
357
358 static void attach_forward_bodies (FILE * fp, HEADER * hdr,
359                                    ATTACHPTR ** idx, short idxlen,
360                                    BODY * cur, short nattach, int flags)
361 {
362   short i;
363   short mime_fwd_all = 0;
364   short mime_fwd_any = 1;
365   HEADER *parent = NULL;
366   HEADER *tmphdr = NULL;
367   BODY **last;
368   char tmpbody[_POSIX_PATH_MAX];
369   FILE *tmpfp = NULL;
370
371   char prefix[STRING];
372
373   int rc = 0;
374
375   STATE st;
376
377   /* 
378    * First, find the parent message.
379    * Note: This could be made an option by just
380    * putting the following lines into an if block.
381    */
382
383
384   parent = find_parent (idx, idxlen, cur, nattach);
385
386   if (parent == NULL)
387     parent = hdr;
388
389
390   tmphdr = mutt_new_header ();
391   tmphdr->env = mutt_new_envelope ();
392   mutt_make_forward_subject (tmphdr->env, Context, parent);
393
394   mutt_mktemp (tmpbody);
395   if ((tmpfp = safe_fopen (tmpbody, "w")) == NULL) {
396     mutt_error (_("Can't open temporary file %s."), tmpbody);
397     return;
398   }
399
400   mutt_forward_intro (tmpfp, parent);
401
402   /* prepare the prefix here since we'll need it later. */
403
404   if (option (OPTFORWQUOTE)) {
405     if (!option (OPTTEXTFLOWED))
406       _mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix), Context,
407                          parent, 0);
408     else
409       strfcpy (prefix, ">", sizeof (prefix));
410   }
411
412   include_header (option (OPTFORWQUOTE), fp, parent, tmpfp, prefix);
413
414
415   /* 
416    * Now, we have prepared the first part of the message body: The
417    * original message's header. 
418    *
419    * The next part is more interesting: either include the message bodies,
420    * or attach them.
421    */
422
423   if ((!cur || mutt_can_decode (cur)) &&
424       (rc = query_quadoption (OPT_MIMEFWD,
425                               _("Forward as attachments?"))) == M_YES)
426     mime_fwd_all = 1;
427   else if (rc == -1)
428     goto bail;
429
430   /* 
431    * shortcut MIMEFWDREST when there is only one attachment.  Is 
432    * this intuitive?
433    */
434
435   if (!mime_fwd_all && !cur && (nattach > 1)
436       && !check_can_decode (idx, idxlen, cur)) {
437     if ((rc = query_quadoption (OPT_MIMEFWDREST,
438                                 _
439                                 ("Can't decode all tagged attachments.  MIME-forward the others?")))
440         == -1)
441       goto bail;
442     else if (rc == M_NO)
443       mime_fwd_any = 0;
444   }
445
446   /* initialize a state structure */
447
448   p_clear(&st, 1);
449
450   if (option (OPTFORWQUOTE))
451     st.prefix = prefix;
452   st.flags = M_CHARCONV;
453   if (option (OPTWEED))
454     st.flags |= M_WEED;
455   st.fpin = fp;
456   st.fpout = tmpfp;
457
458   /* where do we append new MIME parts? */
459   last = &tmphdr->content;
460
461   if (cur) {
462     /* single body case */
463
464     if (!mime_fwd_all && mutt_can_decode (cur)) {
465       mutt_body_handler (cur, &st);
466       state_putc ('\n', &st);
467     }
468     else {
469       if (mutt_copy_body (fp, last, cur) == -1)
470         goto bail;
471       last = &((*last)->next);
472     }
473   }
474   else {
475     /* multiple body case */
476
477     if (!mime_fwd_all) {
478       for (i = 0; i < idxlen; i++) {
479         if (idx[i]->content->tagged && mutt_can_decode (idx[i]->content)) {
480           mutt_body_handler (idx[i]->content, &st);
481           state_putc ('\n', &st);
482         }
483       }
484     }
485
486     if (mime_fwd_any &&
487         (last =
488          copy_problematic_attachments (fp, last, idx, idxlen,
489                                        mime_fwd_all)) == NULL)
490       goto bail;
491   }
492
493   mutt_forward_trailer (tmpfp);
494
495   fclose (tmpfp);
496   tmpfp = NULL;
497
498   /* now that we have the template, send it. */
499   ci_send_message (flags, tmphdr, tmpbody, NULL, parent);
500   return;
501
502 bail:
503
504   if (tmpfp) {
505     fclose (tmpfp);
506     mutt_unlink (tmpbody);
507   }
508
509   mutt_free_header (&tmphdr);
510 }
511
512
513 /* 
514  * Forward one or several message-type attachments. This 
515  * is different from the previous function
516  * since we want to mimic the index menu's behaviour.
517  *
518  * Code reuse from ci_send_message is not possible here -
519  * ci_send_message relies on a context structure to find messages,
520  * while, on the attachment menu, messages are referenced through
521  * the attachment index. 
522  */
523
524 static void attach_forward_msgs (FILE * fp, HEADER * hdr,
525                                  ATTACHPTR ** idx, short idxlen, BODY * cur,
526                                  int flags)
527 {
528   HEADER *curhdr = NULL;
529   HEADER *tmphdr;
530   short i;
531   int rc;
532
533   BODY **last;
534   char tmpbody[_POSIX_PATH_MAX];
535   FILE *tmpfp = NULL;
536
537   int cmflags = 0;
538   int chflags = CH_XMIT;
539
540   if (cur)
541     curhdr = cur->hdr;
542   else {
543     for (i = 0; i < idxlen; i++)
544       if (idx[i]->content->tagged) {
545         curhdr = idx[i]->content->hdr;
546         break;
547       }
548   }
549
550   tmphdr = mutt_new_header ();
551   tmphdr->env = mutt_new_envelope ();
552   mutt_make_forward_subject (tmphdr->env, Context, curhdr);
553
554
555   tmpbody[0] = '\0';
556
557   if ((rc = query_quadoption (OPT_MIMEFWD,
558                               _("Forward MIME encapsulated?"))) == M_NO) {
559
560     /* no MIME encapsulation */
561
562     mutt_mktemp (tmpbody);
563     if (!(tmpfp = safe_fopen (tmpbody, "w"))) {
564       mutt_error (_("Can't create %s."), tmpbody);
565       mutt_free_header (&tmphdr);
566       return;
567     }
568
569     if (option (OPTFORWQUOTE)) {
570       chflags |= CH_PREFIX;
571       cmflags |= M_CM_PREFIX;
572     }
573
574     if (option (OPTFORWDECODE)) {
575       cmflags |= M_CM_DECODE | M_CM_CHARCONV;
576       if (option (OPTWEED)) {
577         chflags |= CH_WEED | CH_REORDER;
578         cmflags |= M_CM_WEED;
579       }
580     }
581
582
583     if (cur) {
584       /* mutt_message_hook (cur->hdr, M_MESSAGEHOOK); */
585       mutt_forward_intro (tmpfp, cur->hdr);
586       _mutt_copy_message (tmpfp, fp, cur->hdr, cur->hdr->content, cmflags,
587                           chflags);
588       mutt_forward_trailer (tmpfp);
589     }
590     else {
591       for (i = 0; i < idxlen; i++) {
592         if (idx[i]->content->tagged) {
593           /* mutt_message_hook (idx[i]->content->hdr, M_MESSAGEHOOK); */
594           mutt_forward_intro (tmpfp, idx[i]->content->hdr);
595           _mutt_copy_message (tmpfp, fp, idx[i]->content->hdr,
596                               idx[i]->content->hdr->content, cmflags,
597                               chflags);
598           mutt_forward_trailer (tmpfp);
599         }
600       }
601     }
602     fclose (tmpfp);
603   }
604   else if (rc == M_YES) {       /* do MIME encapsulation - we don't need to do much here */
605     last = &tmphdr->content;
606     if (cur)
607       mutt_copy_body (fp, last, cur);
608     else {
609       for (i = 0; i < idxlen; i++)
610         if (idx[i]->content->tagged) {
611           mutt_copy_body (fp, last, idx[i]->content);
612           last = &((*last)->next);
613         }
614     }
615   }
616   else
617     mutt_free_header (&tmphdr);
618
619   ci_send_message (flags, tmphdr, *tmpbody ? tmpbody : NULL, NULL, curhdr);
620
621 }
622
623 void mutt_attach_forward (FILE * fp, HEADER * hdr,
624                           ATTACHPTR ** idx, short idxlen, BODY * cur,
625                           int flags)
626 {
627   short nattach;
628
629
630   if (check_all_msg (idx, idxlen, cur, 0) == 0)
631     attach_forward_msgs (fp, hdr, idx, idxlen, cur, flags);
632   else {
633     nattach = count_tagged (idx, idxlen);
634     attach_forward_bodies (fp, hdr, idx, idxlen, cur, nattach, flags);
635   }
636 }
637 \f
638
639
640 /**
641  ** 
642  ** the various reply functions, from the attachment menu
643  **
644  **
645  **/
646
647 /* Create the envelope defaults for a reply.
648  *
649  * This function can be invoked in two ways.
650  * 
651  * Either, parent is NULL.  In this case, all tagged bodies are of a message type,
652  * and the header information is fetched from them.
653  * 
654  * Or, parent is non-NULL.  In this case, cur is the common parent of all the
655  * tagged attachments.
656  * 
657  * Note that this code is horribly similar to envelope_defaults () from send.c.
658  */
659
660 static int
661 attach_reply_envelope_defaults (ENVELOPE * env, ATTACHPTR ** idx,
662                                 short idxlen, HEADER * parent, int flags)
663 {
664   ENVELOPE *curenv = NULL;
665   HEADER *curhdr = NULL;
666   short i;
667
668   if (!parent) {
669     for (i = 0; i < idxlen; i++) {
670       if (idx[i]->content->tagged) {
671         curhdr = idx[i]->content->hdr;
672         curenv = curhdr->env;
673         break;
674       }
675     }
676   }
677   else {
678     curenv = parent->env;
679     curhdr = parent;
680   }
681
682   if (curenv == NULL || curhdr == NULL) {
683     mutt_error _("Can't find any tagged messages.");
684
685     return -1;
686   }
687
688 #ifdef USE_NNTP
689   if ((flags & SENDNEWS)) {
690     /* in case followup set Newsgroups: with Followup-To: if it present */
691     if (!env->newsgroups && curenv &&
692         m_strcasecmp(curenv->followup_to, "poster"))
693       env->newsgroups = m_strdup(curenv->followup_to);
694   }
695   else
696 #endif
697   {
698     if (parent) {
699       if (mutt_fetch_recips (env, curenv, flags) == -1)
700         return -1;
701     }
702     else {
703       for (i = 0; i < idxlen; i++) {
704         if (idx[i]->content->tagged
705             && mutt_fetch_recips (env, idx[i]->content->hdr->env,
706                                   flags) == -1)
707           return -1;
708       }
709     }
710
711     if ((flags & SENDLISTREPLY) && !env->to) {
712       mutt_error _("No mailing lists found!");
713
714       return (-1);
715     }
716
717     mutt_fix_reply_recipients (env);
718   }
719   mutt_make_misc_reply_headers (env, Context, curhdr, curenv);
720
721   if (parent)
722     mutt_add_to_reference_headers (env, curenv, NULL, NULL);
723   else {
724     LIST **p = NULL, **q = NULL;
725
726     for (i = 0; i < idxlen; i++) {
727       if (idx[i]->content->tagged)
728         mutt_add_to_reference_headers (env, idx[i]->content->hdr->env, &p,
729                                        &q);
730     }
731   }
732
733   return 0;
734 }
735
736
737 /*  This is _very_ similar to send.c's include_reply(). */
738
739 static void attach_include_reply (FILE * fp, FILE * tmpfp, HEADER * cur,
740                                   int flags)
741 {
742   int cmflags = M_CM_PREFIX | M_CM_DECODE | M_CM_CHARCONV;
743   int chflags = CH_DECODE;
744
745   /* mutt_message_hook (cur, M_MESSAGEHOOK); */
746
747   mutt_make_attribution (Context, cur, tmpfp);
748
749   if (!option (OPTHEADER))
750     cmflags |= M_CM_NOHEADER;
751   if (option (OPTWEED)) {
752     chflags |= CH_WEED;
753     cmflags |= M_CM_WEED;
754   }
755
756   _mutt_copy_message (tmpfp, fp, cur, cur->content, cmflags, chflags);
757   mutt_make_post_indent (Context, cur, tmpfp);
758 }
759
760 void mutt_attach_reply (FILE * fp, HEADER * hdr,
761                         ATTACHPTR ** idx, short idxlen, BODY * cur, int flags)
762 {
763   short mime_reply_any = 0;
764
765   short nattach = 0;
766   HEADER *parent = NULL;
767   HEADER *tmphdr = NULL;
768   short i;
769
770   STATE st;
771   char tmpbody[_POSIX_PATH_MAX];
772   FILE *tmpfp;
773
774   char prefix[SHORT_STRING];
775   int rc;
776
777 #ifdef USE_NNTP
778   if (flags & SENDNEWS)
779     set_option (OPTNEWSSEND);
780   else
781     unset_option (OPTNEWSSEND);
782 #endif
783
784   if (check_all_msg (idx, idxlen, cur, 0) == -1) {
785     nattach = count_tagged (idx, idxlen);
786     if ((parent = find_parent (idx, idxlen, cur, nattach)) == NULL)
787       parent = hdr;
788   }
789
790   if (nattach > 1 && !check_can_decode (idx, idxlen, cur)) {
791     if ((rc = query_quadoption (OPT_MIMEFWDREST,
792                                 _
793                                 ("Can't decode all tagged attachments.  MIME-encapsulate the others?")))
794         == -1)
795       return;
796     else if (rc == M_YES)
797       mime_reply_any = 1;
798   }
799   else if (nattach == 1)
800     mime_reply_any = 1;
801
802   tmphdr = mutt_new_header ();
803   tmphdr->env = mutt_new_envelope ();
804
805   if (attach_reply_envelope_defaults (tmphdr->env, idx, idxlen,
806                                       parent ? parent : (cur ? cur->
807                                                          hdr : NULL),
808                                       flags) == -1) {
809     mutt_free_header (&tmphdr);
810     return;
811   }
812
813   mutt_mktemp (tmpbody);
814   if ((tmpfp = safe_fopen (tmpbody, "w")) == NULL) {
815     mutt_error (_("Can't create %s."), tmpbody);
816     mutt_free_header (&tmphdr);
817     return;
818   }
819
820   if (!parent) {
821     if (cur)
822       attach_include_reply (fp, tmpfp, cur->hdr, flags);
823     else {
824       for (i = 0; i < idxlen; i++) {
825         if (idx[i]->content->tagged)
826           attach_include_reply (fp, tmpfp, idx[i]->content->hdr, flags);
827       }
828     }
829   }
830   else {
831     mutt_make_attribution (Context, parent, tmpfp);
832
833     p_clear(&st, 1);
834     st.fpin = fp;
835     st.fpout = tmpfp;
836
837     if (!option (OPTTEXTFLOWED))
838       _mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix),
839                          Context, parent, 0);
840     else
841       strfcpy (prefix, ">", sizeof (prefix));
842
843     st.prefix = prefix;
844     st.flags = M_CHARCONV;
845
846     if (option (OPTWEED))
847       st.flags |= M_WEED;
848
849     if (option (OPTHEADER))
850       include_header (1, fp, parent, tmpfp, prefix);
851
852     if (cur) {
853       if (mutt_can_decode (cur)) {
854         mutt_body_handler (cur, &st);
855         state_putc ('\n', &st);
856       }
857       else
858         mutt_copy_body (fp, &tmphdr->content, cur);
859     }
860     else {
861       for (i = 0; i < idxlen; i++) {
862         if (idx[i]->content->tagged && mutt_can_decode (idx[i]->content)) {
863           mutt_body_handler (idx[i]->content, &st);
864           state_putc ('\n', &st);
865         }
866       }
867     }
868
869     mutt_make_post_indent (Context, parent, tmpfp);
870
871     if (mime_reply_any && !cur &&
872         copy_problematic_attachments (fp, &tmphdr->content, idx, idxlen,
873                                       0) == NULL) {
874       mutt_free_header (&tmphdr);
875       fclose (tmpfp);
876       return;
877     }
878   }
879
880   fclose (tmpfp);
881
882   if (ci_send_message (flags, tmphdr, tmpbody, NULL, parent) == 0)
883     mutt_set_flag (Context, hdr, M_REPLIED, 1);
884 }