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