2 * Copyright notice from original mutt:
3 * Copyright (C) 1999-2000 Thomas Roessler <roessler@does-not-exist.org>
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.
10 #include <lib-lib/lib-lib.h>
12 #include <lib-mime/mime.h>
14 #include <lib-ui/curses.h>
15 #include <lib-ui/enter.h>
16 #include <lib-ui/menu.h>
17 #include <lib-mx/mx.h>
23 #include "recvattach.h"
26 #include "mutt_idna.h"
29 /* some helper functions to verify that we are exclusively operating
30 * on message/rfc822 attachments
33 static short check_msg (BODY * b, short err)
35 if (!mutt_is_message_type (b->type, b->subtype)) {
37 mutt_error _("You may only bounce message/rfc822 parts.");
44 static short check_all_msg (ATTACHPTR ** idx, short idxlen,
45 BODY * cur, short err)
49 if (cur && check_msg (cur, err) == -1)
52 for (i = 0; i < idxlen; i++) {
53 if (idx[i]->content->tagged) {
54 if (check_msg (idx[i]->content, err) == -1)
63 /* can we decode all tagged attachments? */
65 static short check_can_decode (ATTACHPTR ** idx, short idxlen, BODY * cur)
70 return mutt_can_decode (cur);
72 for (i = 0; i < idxlen; i++)
73 if (idx[i]->content->tagged && !mutt_can_decode (idx[i]->content))
79 static short count_tagged (ATTACHPTR ** idx, short idxlen)
84 for (i = 0; i < idxlen; i++)
85 if (idx[i]->content->tagged)
91 /* count the number of tagged children below a multipart or message
95 static short count_tagged_children (ATTACHPTR ** idx, short idxlen, short i)
97 short level = idx[i]->level;
100 while ((++i < idxlen) && (level < idx[i]->level))
101 if (idx[i]->content->tagged)
110 ** The bounce function, from the attachment menu
113 void mutt_attach_bounce (FILE * fp, HEADER * hdr __attribute__ ((unused)),
114 ATTACHPTR ** idx, short idxlen, BODY * cur)
118 char buf[HUGE_STRING];
120 address_t *adr = NULL;
124 if (check_all_msg (idx, idxlen, cur, 1) == -1)
127 /* one or more messages? */
128 p = (cur || count_tagged (idx, idxlen) == 1);
131 m_strcpy(prompt, sizeof(prompt), _("Bounce message to: "));
133 m_strcpy(prompt, sizeof(prompt), _("Bounce tagged messages to: "));
136 if (mutt_get_field (prompt, buf, sizeof (buf), M_ALIAS)
140 if (!(adr = rfc822_parse_adrlist (adr, buf))) {
141 mutt_error _("Error parsing address!");
146 adr = mutt_expand_aliases (adr);
148 if (mutt_addrlist_to_idna (adr, &err) < 0) {
149 mutt_error (_("Bad IDN: '%s'"), err);
151 address_list_wipe(&adr);
156 rfc822_write_address (buf, sizeof (buf), adr, 1);
158 #define extra_space (15+7+2)
162 snprintf (prompt, sizeof (prompt) - 4,
163 (p ? _("Bounce message to %s") : _("Bounce messages to %s")),
166 if (mutt_strwidth (prompt) > COLS - extra_space) {
167 mutt_format_string (prompt, sizeof (prompt) - 4,
168 0, COLS - extra_space, 0, 0,
169 prompt, sizeof (prompt), 0);
170 m_strcat(prompt, sizeof(prompt), "...?");
172 m_strcat(prompt, sizeof(prompt), "?");
175 if (query_quadoption (OPT_BOUNCE, prompt) != M_YES) {
176 address_list_wipe(&adr);
177 CLEARLINE (LINES - 1);
178 mutt_message (p ? _("Message not bounced.") : _("Messages not bounced."));
182 CLEARLINE (LINES - 1);
185 ret = mutt_bounce_message (fp, cur->hdr, adr);
187 for (i = 0; i < idxlen; i++) {
188 if (idx[i]->content->tagged)
189 if (mutt_bounce_message (fp, idx[i]->content->hdr, adr))
195 mutt_message (p ? _("Message bounced.") : _("Messages bounced."));
197 mutt_error (p ? _("Error bouncing message!") :
198 _("Error bouncing messages!"));
204 ** resend-message, from the attachment menu
207 void mutt_attach_resend (FILE * fp, HEADER * hdr __attribute__ ((unused)), ATTACHPTR ** idx,
208 short idxlen, BODY * cur)
212 if (check_all_msg (idx, idxlen, cur, 1) == -1)
216 mutt_resend_message (fp, Context, cur->hdr);
218 for (i = 0; i < idxlen; i++)
219 if (idx[i]->content->tagged)
220 mutt_resend_message (fp, Context, idx[i]->content->hdr);
226 ** forward-message, from the attachment menu
229 /* try to find a common parent message for the tagged attachments. */
231 static HEADER *find_common_parent (ATTACHPTR ** idx, short idxlen,
237 for (i = 0; i < idxlen; i++)
238 if (idx[i]->content->tagged)
242 if (mutt_is_message_type
243 (idx[i]->content->type, idx[i]->content->subtype)) {
244 nchildren = count_tagged_children (idx, idxlen, i);
245 if (nchildren == nattach)
246 return idx[i]->content->hdr;
254 * check whether attachment #i is a parent of the attachment
257 * Note: This and the calling procedure could be optimized quite a
258 * bit. For now, it's not worth the effort.
261 static int is_parent (short i, ATTACHPTR ** idx, short idxlen, BODY * cur)
263 short level = idx[i]->level;
265 while ((++i < idxlen) && idx[i]->level > level) {
266 if (idx[i]->content == cur)
273 static HEADER *find_parent (ATTACHPTR ** idx, short idxlen, BODY * cur,
277 HEADER *parent = NULL;
280 for (i = 0; i < idxlen; i++) {
281 if (mutt_is_message_type
282 (idx[i]->content->type, idx[i]->content->subtype)
283 && is_parent (i, idx, idxlen, cur))
284 parent = idx[i]->content->hdr;
285 if (idx[i]->content == cur)
290 parent = find_common_parent (idx, idxlen, nattach);
295 static void include_header (int quote, FILE * ifp,
296 HEADER * hdr, FILE * ofp, char *_prefix)
298 int chflags = CH_DECODE;
299 char prefix[SHORT_STRING];
301 if (option (OPTWEED))
302 chflags |= CH_WEED | CH_REORDER;
306 m_strcpy(prefix, sizeof(prefix), _prefix);
307 else if (!option (OPTTEXTFLOWED))
308 _mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix),
311 m_strcpy(prefix, sizeof(prefix), ">");
313 chflags |= CH_PREFIX;
316 mutt_copy_header (ifp, hdr, ofp, chflags, quote ? prefix : NULL);
319 /* create a send-mode duplicate from a receive-mode body */
320 static int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src)
322 char tmp[_POSIX_PATH_MAX];
325 parameter_t *par, **ppar;
331 m_strcpy(tmp, sizeof(tmp), src->filename);
337 mutt_adv_mktemp (NULL, tmp, sizeof (tmp));
338 if (mutt_save_attachment (fp, src, tmp, 0, NULL) == -1)
344 memcpy (b, src, sizeof (BODY));
348 b->filename = m_strdup(tmp);
349 b->use_disp = use_disp;
352 if (mutt_is_text_part (b))
355 b->xtype = m_strdup(b->xtype);
356 b->subtype = m_strdup(b->subtype);
357 b->form_name = m_strdup(b->form_name);
358 b->filename = m_strdup(b->filename);
359 b->d_filename = m_strdup(b->d_filename);
360 b->description = m_strdup(b->description);
363 * we don't seem to need the HEADER structure currently.
364 * XXX - this may change in the future
370 /* copy parameters */
371 for (par = b->parameter, ppar = &b->parameter; par;
372 ppar = &(*ppar)->next, par = par->next) {
373 *ppar = parameter_new();
374 (*ppar)->attribute = m_strdup(par->attribute);
375 (*ppar)->value = m_strdup(par->value);
378 mutt_stamp_attachment (b);
383 /* Attach all the body parts which can't be decoded.
384 * This code is shared by forwarding and replying. */
386 static BODY **copy_problematic_attachments (FILE * fp,
389 short idxlen, short force)
393 for (i = 0; i < idxlen; i++) {
394 if (idx[i]->content->tagged &&
395 (force || !mutt_can_decode (idx[i]->content))) {
396 if (mutt_copy_body (fp, last, idx[i]->content) == -1)
397 return NULL; /* XXXXX - may lead to crashes */
398 last = &((*last)->next);
405 * forward one or several MIME bodies
406 * (non-message types)
409 static void attach_forward_bodies (FILE * fp, HEADER * hdr,
410 ATTACHPTR ** idx, short idxlen,
411 BODY * cur, short nattach, int flags)
414 short mime_fwd_all = 0;
415 short mime_fwd_any = 1;
416 HEADER *parent = NULL;
417 HEADER *tmphdr = NULL;
419 char tmpbody[_POSIX_PATH_MAX];
429 * First, find the parent message.
430 * Note: This could be made an option by just
431 * putting the following lines into an if block.
435 parent = find_parent (idx, idxlen, cur, nattach);
441 tmphdr = header_new();
442 tmphdr->env = envelope_new();
443 mutt_make_forward_subject (tmphdr->env, Context, parent);
445 tmpfp = m_tempfile(tmpbody, sizeof(tmpbody), NONULL(Tempdir), NULL);
447 mutt_error(_("Could not create temporary file"));
451 mutt_forward_intro (tmpfp, parent);
453 /* prepare the prefix here since we'll need it later. */
455 if (option (OPTFORWQUOTE)) {
456 if (!option (OPTTEXTFLOWED))
457 _mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix), Context,
460 m_strcpy(prefix, sizeof(prefix), ">");
463 include_header (option (OPTFORWQUOTE), fp, parent, tmpfp, prefix);
467 * Now, we have prepared the first part of the message body: The
468 * original message's header.
470 * The next part is more interesting: either include the message bodies,
474 if ((!cur || mutt_can_decode (cur)) &&
475 (rc = query_quadoption (OPT_MIMEFWD,
476 _("Forward as attachments?"))) == M_YES)
482 * shortcut MIMEFWDREST when there is only one attachment. Is
486 if (!mime_fwd_all && !cur && (nattach > 1)
487 && !check_can_decode (idx, idxlen, cur)) {
488 if ((rc = query_quadoption (OPT_MIMEFWDREST,
490 ("Can't decode all tagged attachments. MIME-forward the others?")))
497 /* initialize a state structure */
501 if (option (OPTFORWQUOTE))
503 st.flags = M_CHARCONV;
504 if (option (OPTWEED))
509 /* where do we append new MIME parts? */
510 last = &tmphdr->content;
513 /* single body case */
515 if (!mime_fwd_all && mutt_can_decode (cur)) {
516 mutt_body_handler (cur, &st);
517 state_putc ('\n', &st);
520 if (mutt_copy_body (fp, last, cur) == -1)
522 last = &((*last)->next);
526 /* multiple body case */
529 for (i = 0; i < idxlen; i++) {
530 if (idx[i]->content->tagged && mutt_can_decode (idx[i]->content)) {
531 mutt_body_handler (idx[i]->content, &st);
532 state_putc ('\n', &st);
539 copy_problematic_attachments (fp, last, idx, idxlen,
540 mime_fwd_all)) == NULL)
544 mutt_forward_trailer (tmpfp);
547 /* now that we have the template, send it. */
548 ci_send_message (flags, tmphdr, tmpbody, NULL, parent);
553 mutt_unlink(tmpbody);
554 header_delete(&tmphdr);
559 * Forward one or several message-type attachments. This
560 * is different from the previous function
561 * since we want to mimic the index menu's behaviour.
563 * Code reuse from ci_send_message is not possible here -
564 * ci_send_message relies on a context structure to find messages,
565 * while, on the attachment menu, messages are referenced through
566 * the attachment index.
569 static void attach_forward_msgs (FILE * fp, HEADER * hdr __attribute__ ((unused)),
570 ATTACHPTR ** idx, short idxlen, BODY * cur,
573 HEADER *curhdr = NULL;
579 char tmpbody[_POSIX_PATH_MAX];
583 int chflags = CH_XMIT;
588 for (i = 0; i < idxlen; i++)
589 if (idx[i]->content->tagged) {
590 curhdr = idx[i]->content->hdr;
595 tmphdr = header_new();
596 tmphdr->env = envelope_new();
597 mutt_make_forward_subject (tmphdr->env, Context, curhdr);
602 if ((rc = query_quadoption (OPT_MIMEFWD,
603 _("Forward MIME encapsulated?"))) == M_NO) {
605 /* no MIME encapsulation */
607 tmpfp = m_tempfile(tmpbody, sizeof(tmpbody), NONULL(Tempdir), NULL);
609 mutt_error(_("Could not create temporary file"));
610 header_delete(&tmphdr);
614 if (option (OPTFORWQUOTE)) {
615 chflags |= CH_PREFIX;
616 cmflags |= M_CM_PREFIX;
619 if (option (OPTFORWDECODE)) {
620 cmflags |= M_CM_DECODE | M_CM_CHARCONV;
621 if (option (OPTWEED)) {
622 chflags |= CH_WEED | CH_REORDER;
623 cmflags |= M_CM_WEED;
629 /* mutt_message_hook (cur->hdr, M_MESSAGEHOOK); */
630 mutt_forward_intro (tmpfp, cur->hdr);
631 _mutt_copy_message (tmpfp, fp, cur->hdr, cur->hdr->content, cmflags,
633 mutt_forward_trailer (tmpfp);
636 for (i = 0; i < idxlen; i++) {
637 if (idx[i]->content->tagged) {
638 /* mutt_message_hook (idx[i]->content->hdr, M_MESSAGEHOOK); */
639 mutt_forward_intro (tmpfp, idx[i]->content->hdr);
640 _mutt_copy_message (tmpfp, fp, idx[i]->content->hdr,
641 idx[i]->content->hdr->content, cmflags,
643 mutt_forward_trailer (tmpfp);
649 else if (rc == M_YES) { /* do MIME encapsulation - we don't need to do much here */
650 last = &tmphdr->content;
652 mutt_copy_body (fp, last, cur);
654 for (i = 0; i < idxlen; i++)
655 if (idx[i]->content->tagged) {
656 mutt_copy_body (fp, last, idx[i]->content);
657 last = &((*last)->next);
662 header_delete(&tmphdr);
664 ci_send_message (flags, tmphdr, *tmpbody ? tmpbody : NULL, NULL, curhdr);
668 void mutt_attach_forward (FILE * fp, HEADER * hdr,
669 ATTACHPTR ** idx, short idxlen, BODY * cur,
675 if (check_all_msg (idx, idxlen, cur, 0) == 0)
676 attach_forward_msgs (fp, hdr, idx, idxlen, cur, flags);
678 nattach = count_tagged (idx, idxlen);
679 attach_forward_bodies (fp, hdr, idx, idxlen, cur, nattach, flags);
686 ** the various reply functions, from the attachment menu
689 /* Create the envelope defaults for a reply.
691 * This function can be invoked in two ways.
693 * Either, parent is NULL. In this case, all tagged bodies are of a message type,
694 * and the header information is fetched from them.
696 * Or, parent is non-NULL. In this case, cur is the common parent of all the
697 * tagged attachments.
699 * Note that this code is horribly similar to envelope_defaults () from send.c.
703 attach_reply_envelope_defaults (ENVELOPE * env, ATTACHPTR ** idx,
704 short idxlen, HEADER * parent, int flags)
706 ENVELOPE *curenv = NULL;
707 HEADER *curhdr = NULL;
711 for (i = 0; i < idxlen; i++) {
712 if (idx[i]->content->tagged) {
713 curhdr = idx[i]->content->hdr;
714 curenv = curhdr->env;
720 curenv = parent->env;
724 if (curenv == NULL || curhdr == NULL) {
725 mutt_error _("Can't find any tagged messages.");
731 if ((flags & SENDNEWS)) {
732 /* in case followup set Newsgroups: with Followup-To: if it present */
733 if (!env->newsgroups && curenv &&
734 m_strcasecmp(curenv->followup_to, "poster"))
735 env->newsgroups = m_strdup(curenv->followup_to);
741 if (mutt_fetch_recips (env, curenv, flags) == -1)
745 for (i = 0; i < idxlen; i++) {
746 if (idx[i]->content->tagged
747 && mutt_fetch_recips (env, idx[i]->content->hdr->env,
753 if ((flags & SENDLISTREPLY) && !env->to) {
754 mutt_error _("No mailing lists found!");
759 mutt_fix_reply_recipients (env);
761 mutt_make_misc_reply_headers (env, Context, curhdr, curenv);
764 mutt_add_to_reference_headers (env, curenv, NULL, NULL);
766 string_list_t **p = NULL, **q = NULL;
768 for (i = 0; i < idxlen; i++) {
769 if (idx[i]->content->tagged)
770 mutt_add_to_reference_headers (env, idx[i]->content->hdr->env, &p,
779 /* This is _very_ similar to send.c's include_reply(). */
781 static void attach_include_reply (FILE * fp, FILE * tmpfp, HEADER * cur,
782 int flags __attribute__ ((unused)))
784 int cmflags = M_CM_PREFIX | M_CM_DECODE | M_CM_CHARCONV;
785 int chflags = CH_DECODE;
787 /* mutt_message_hook (cur, M_MESSAGEHOOK); */
789 mutt_make_attribution (Context, cur, tmpfp);
791 if (!option (OPTHEADER))
792 cmflags |= M_CM_NOHEADER;
793 if (option (OPTWEED)) {
795 cmflags |= M_CM_WEED;
798 _mutt_copy_message (tmpfp, fp, cur, cur->content, cmflags, chflags);
799 mutt_make_post_indent (Context, cur, tmpfp);
802 void mutt_attach_reply (FILE * fp, HEADER * hdr,
803 ATTACHPTR ** idx, short idxlen, BODY * cur, int flags)
805 short mime_reply_any = 0;
808 HEADER *parent = NULL;
809 HEADER *tmphdr = NULL;
813 char tmpbody[_POSIX_PATH_MAX];
816 char prefix[SHORT_STRING];
820 if (flags & SENDNEWS)
821 set_option (OPTNEWSSEND);
823 unset_option (OPTNEWSSEND);
826 if (check_all_msg (idx, idxlen, cur, 0) == -1) {
827 nattach = count_tagged (idx, idxlen);
828 if ((parent = find_parent (idx, idxlen, cur, nattach)) == NULL)
832 if (nattach > 1 && !check_can_decode (idx, idxlen, cur)) {
833 if ((rc = query_quadoption (OPT_MIMEFWDREST,
835 ("Can't decode all tagged attachments. MIME-encapsulate the others?")))
838 else if (rc == M_YES)
841 else if (nattach == 1)
844 tmphdr = header_new();
845 tmphdr->env = envelope_new();
847 if (attach_reply_envelope_defaults (tmphdr->env, idx, idxlen,
848 parent ? parent : (cur ? cur->
851 header_delete(&tmphdr);
855 tmpfp = m_tempfile(tmpbody, sizeof(tmpbody), NONULL(Tempdir), NULL);
857 mutt_error(_("Could not create temporary file"));
858 header_delete(&tmphdr);
864 attach_include_reply (fp, tmpfp, cur->hdr, flags);
866 for (i = 0; i < idxlen; i++) {
867 if (idx[i]->content->tagged)
868 attach_include_reply (fp, tmpfp, idx[i]->content->hdr, flags);
873 mutt_make_attribution (Context, parent, tmpfp);
879 if (!option (OPTTEXTFLOWED))
880 _mutt_make_string (prefix, sizeof (prefix), NONULL (Prefix),
883 m_strcpy(prefix, sizeof(prefix), ">");
886 st.flags = M_CHARCONV;
888 if (option (OPTWEED))
891 if (option (OPTHEADER))
892 include_header (1, fp, parent, tmpfp, prefix);
895 if (mutt_can_decode (cur)) {
896 mutt_body_handler (cur, &st);
897 state_putc ('\n', &st);
900 mutt_copy_body (fp, &tmphdr->content, cur);
903 for (i = 0; i < idxlen; i++) {
904 if (idx[i]->content->tagged && mutt_can_decode (idx[i]->content)) {
905 mutt_body_handler (idx[i]->content, &st);
906 state_putc ('\n', &st);
911 mutt_make_post_indent (Context, parent, tmpfp);
913 if (mime_reply_any && !cur &&
914 copy_problematic_attachments (fp, &tmphdr->content, idx, idxlen,
916 header_delete(&tmphdr);
924 if (ci_send_message (flags, tmphdr, tmpbody, NULL, parent) == 0)
925 mutt_set_flag (Context, hdr, M_REPLIED, 1);