compose.c

   1 /*
   2  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
   3  * Copyright (C) 2004 g10 Code GmbH
   4  *
   5  *     This program is free software; you can redistribute it and/or modify
   6  *     it under the terms of the GNU General Public License as published by
   7  *     the Free Software Foundation; either version 2 of the License, or
   8  *     (at your option) any later version.
   9  *
  10  *     This program is distributed in the hope that it will be useful,
  11  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *     GNU General Public License for more details.
  14  *
  15  *     You should have received a copy of the GNU General Public License
  16  *     along with this program; if not, write to the Free Software
  17  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #if HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 #include "mutt.h"
  25 #include "mutt_curses.h"
  26 #include "mutt_idna.h"
  27 #include "mutt_menu.h"
  28 #include "rfc1524.h"
  29 #include "mime.h"
  30 #include "attach.h"
  31 #include "mapping.h"
  32 #include "mailbox.h"
  33 #include "sort.h"
  34 #include "charset.h"
  35
  36 #ifdef MIXMASTER
  37 #include "remailer.h"
  38 #endif
  39
  40 #include <errno.h>
  41 #include <string.h>
  42 #include <sys/stat.h>
  43 #include <sys/wait.h>
  44 #include <unistd.h>
  45 #include <stdlib.h>
  46
  47 static const char* There_are_no_attachments = N_("There are no attachments.");
  48
  49 #define CHECK_COUNT if (idxlen == 0) { mutt_error _(There_are_no_attachments); break; }
  50
  51
  52
  53 enum
  54 {
  55   HDR_FROM  = 1,
  56   HDR_TO,
  57   HDR_CC,
  58   HDR_BCC,
  59   HDR_SUBJECT,
  60   HDR_REPLYTO,
  61   HDR_FCC,
  62
  63 #ifdef MIXMASTER
  64   HDR_MIX,
  65 #endif
  66
  67   HDR_CRYPT,
  68   HDR_CRYPTINFO,
  69
  70   HDR_ATTACH  = (HDR_FCC + 5) /* where to start printing the attachments */
  71 };
  72
  73 #define HDR_XOFFSET 10
  74 #define TITLE_FMT "%10s" /* Used for Prompts, which are ASCII */
  75 #define W (COLS - HDR_XOFFSET)
  76
  77 static char *Prompts[] =
  78 {
  79   "From: ",
  80   "To: ",
  81   "Cc: ",
  82   "Bcc: ",
  83   "Subject: ",
  84   "Reply-To: ",
  85   "Fcc: "
  86 };
  87
  88 static struct mapping_t ComposeHelp[] = {
  89   { N_("Send"),    OP_COMPOSE_SEND_MESSAGE },
  90   { N_("Abort"),   OP_EXIT },
  91   { "To",      OP_COMPOSE_EDIT_TO },
  92   { "CC",      OP_COMPOSE_EDIT_CC },
  93   { "Subj",    OP_COMPOSE_EDIT_SUBJECT },
  94   { N_("Attach file"),  OP_COMPOSE_ATTACH_FILE },
  95   { N_("Descrip"), OP_COMPOSE_EDIT_DESCRIPTION },
  96   { N_("Help"),    OP_HELP },
  97   { NULL }
  98 };
  99
 100 static void snd_entry (char *b, size_t blen, MUTTMENU *menu, int num)
 101 {
 102     mutt_FormatString (b, blen, 0, NONULL (AttachFormat), mutt_attach_fmt,
 103             (unsigned long)(((ATTACHPTR **) menu->data)[num]),
 104             M_FORMAT_STAT_FILE | M_FORMAT_ARROWCURSOR);
 105 }
 106
 107
 108
 109 #include "mutt_crypt.h"
 110
 111 static void redraw_crypt_lines (HEADER *msg)
 112 {
 113   int off = 0;
 114
 115   if ((WithCrypto & APPLICATION_PGP) && (WithCrypto & APPLICATION_SMIME))
 116   {
 117     if (!msg->security)
 118       mvaddstr (HDR_CRYPT, 0,     "Security: ");
 119     else if (msg->security & APPLICATION_SMIME)
 120       mvaddstr (HDR_CRYPT, 0,     "  S/MIME: ");
 121     else if (msg->security & APPLICATION_PGP)
 122       mvaddstr (HDR_CRYPT, 0,     "     PGP: ");
 123   }
 124   else if ((WithCrypto & APPLICATION_SMIME))
 125     mvaddstr (HDR_CRYPT, 0,     "  S/MIME: ");
 126   else if ((WithCrypto & APPLICATION_PGP))
 127     mvaddstr (HDR_CRYPT, 0,     "     PGP: ");
 128   else
 129     return;
 130
 131   if ((msg->security & (ENCRYPT | SIGN)) == (ENCRYPT | SIGN))
 132     addstr (_("Sign, Encrypt"));
 133   else if (msg->security & ENCRYPT)
 134     addstr (_("Encrypt"));
 135   else if (msg->security & SIGN)
 136     addstr (_("Sign"));
 137   else
 138     addstr (_("Clear"));
 139
 140   if ((WithCrypto & APPLICATION_PGP))
 141     if ((msg->security & APPLICATION_PGP)
 142         && (msg->security & (ENCRYPT | SIGN)))
 143     {
 144       if ((msg->security & INLINE))
 145         addstr (_(" (inline)"));
 146       else
 147         addstr (_(" (PGP/MIME)"));
 148     }
 149   clrtoeol ();
 150
 151   move (HDR_CRYPTINFO, 0);
 152   clrtoeol ();
 153   if ((WithCrypto & APPLICATION_PGP)
 154       && msg->security & APPLICATION_PGP  && msg->security & SIGN)
 155     printw ("%s%s", _(" sign as: "), PgpSignAs ? PgpSignAs : _("<default>"));
 156
 157   if ((WithCrypto & APPLICATION_SMIME)
 158       && msg->security & APPLICATION_SMIME  && msg->security & SIGN) {
 159       printw ("%s%s", _(" sign as: "), SmimeDefaultKey ? SmimeDefaultKey : _("<default>"));
 160   }
 161
 162   if ((WithCrypto & APPLICATION_SMIME)
 163       && (msg->security & APPLICATION_SMIME)
 164       && (msg->security & ENCRYPT)
 165       && SmimeCryptAlg
 166       && *SmimeCryptAlg) {
 167       mvprintw (HDR_CRYPTINFO, 40, "%s%s", _("Encrypt with: "),
 168                 NONULL(SmimeCryptAlg));
 169       off = 20;
 170   }
 171 }
 172
 173
 174 #ifdef MIXMASTER
 175
 176 static void redraw_mix_line (LIST *chain)
 177 {
 178   int c;
 179   char *t;
 180
 181   mvaddstr (HDR_MIX, 0,     "     Mix: ");
 182
 183   if (!chain)
 184   {
 185     addstr ("<no chain defined>");
 186     clrtoeol ();
 187     return;
 188   }
 189
 190   for (c = 12; chain; chain = chain->next)
 191   {
 192     t = chain->data;
 193     if (t && t[0] == '0' && t[1] == '\0')
 194       t = "<random>";
 195
 196     if (c + mutt_strlen (t) + 2 >= COLS)
 197       break;
 198
 199     addstr (NONULL(t));
 200     if (chain->next)
 201       addstr (", ");
 202
 203     c += mutt_strlen (t) + 2;
 204   }
 205 }
 206 #endif /* MIXMASTER */
 207
 208 static int
 209 check_attachments(ATTACHPTR **idx, short idxlen)
 210 {
 211   int i, r;
 212   struct stat st;
 213   char pretty[_POSIX_PATH_MAX], msg[_POSIX_PATH_MAX + SHORT_STRING];
 214
 215   for (i = 0; i < idxlen; i++)
 216   {
 217     strfcpy(pretty, idx[i]->content->filename, sizeof(pretty));
 218     if(stat(idx[i]->content->filename, &st) != 0)
 219     {
 220       mutt_pretty_mailbox(pretty);
 221       mutt_error(_("%s [#%d] no longer exists!"),
 222                  pretty, i+1);
 223       return -1;
 224     }
 225
 226     if(idx[i]->content->stamp < st.st_mtime)
 227     {
 228       mutt_pretty_mailbox(pretty);
 229       snprintf(msg, sizeof(msg), _("%s [#%d] modified. Update encoding?"),
 230                pretty, i+1);
 231
 232       if((r = mutt_yesorno(msg, M_YES)) == M_YES)
 233         mutt_update_encoding(idx[i]->content);
 234       else if(r == -1)
 235         return -1;
 236     }
 237   }
 238
 239   return 0;
 240 }
 241
 242 static void draw_envelope_addr (int line, ADDRESS *addr)
 243 {
 244   char buf[STRING];
 245
 246   buf[0] = 0;
 247   rfc822_write_address (buf, sizeof (buf), addr, 1);
 248   mvprintw (line, 0, TITLE_FMT, Prompts[line - 1]);
 249   mutt_paddstr (W, buf);
 250 }
 251
 252 static void draw_envelope (HEADER *msg, char *fcc)
 253 {
 254   draw_envelope_addr (HDR_FROM, msg->env->from);
 255   draw_envelope_addr (HDR_TO, msg->env->to);
 256   draw_envelope_addr (HDR_CC, msg->env->cc);
 257   draw_envelope_addr (HDR_BCC, msg->env->bcc);
 258   mvprintw (HDR_SUBJECT, 0, TITLE_FMT, Prompts[HDR_SUBJECT - 1]);
 259   mutt_paddstr (W, NONULL (msg->env->subject));
 260   draw_envelope_addr (HDR_REPLYTO, msg->env->reply_to);
 261   mvprintw (HDR_FCC, 0, TITLE_FMT, Prompts[HDR_FCC - 1]);
 262   mutt_paddstr (W, fcc);
 263
 264   if (WithCrypto)
 265     redraw_crypt_lines (msg);
 266
 267 #ifdef MIXMASTER
 268   redraw_mix_line (msg->chain);
 269 #endif
 270
 271   SETCOLOR (MT_COLOR_STATUS);
 272   mvaddstr (HDR_ATTACH - 1, 0, _("-- Attachments"));
 273   BKGDSET (MT_COLOR_STATUS);
 274   clrtoeol ();
 275
 276   BKGDSET (MT_COLOR_NORMAL);
 277   SETCOLOR (MT_COLOR_NORMAL);
 278 }
 279
 280 static int edit_address_list (int line, ADDRESS **addr)
 281 {
 282   char buf[HUGE_STRING] = ""; /* needs to be large for alias expansion */
 283   char *err = NULL;
 284
 285   mutt_addrlist_to_local (*addr);
 286   rfc822_write_address (buf, sizeof (buf), *addr, 0);
 287   if (mutt_get_field (Prompts[line - 1], buf, sizeof (buf), M_ALIAS) == 0)
 288   {
 289     rfc822_free_address (addr);
 290     *addr = mutt_parse_adrlist (*addr, buf);
 291     *addr = mutt_expand_aliases (*addr);
 292   }
 293
 294   if (option (OPTNEEDREDRAW))
 295   {
 296     unset_option (OPTNEEDREDRAW);
 297     return (REDRAW_FULL);
 298   }
 299
 300   if (mutt_addrlist_to_idna (*addr, &err) != 0)
 301   {
 302     mutt_error (_("Warning: '%s' is a bad IDN."), err);
 303     mutt_refresh();
 304     FREE (&err);
 305   }
 306
 307   /* redraw the expanded list so the user can see the result */
 308   buf[0] = 0;
 309   rfc822_write_address (buf, sizeof (buf), *addr, 1);
 310   move (line, HDR_XOFFSET);
 311   mutt_paddstr (W, buf);
 312
 313   return 0;
 314 }
 315
 316 static int delete_attachment (MUTTMENU *menu, short *idxlen, int x)
 317 {
 318   ATTACHPTR **idx = (ATTACHPTR **) menu->data;
 319   int y;
 320
 321   menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
 322
 323   if (x == 0 && menu->max == 1)
 324   {
 325     mutt_error _("You may not delete the only attachment.");
 326     idx[x]->content->tagged = 0;
 327     return (-1);
 328   }
 329
 330   for (y = 0; y < *idxlen; y++)
 331   {
 332     if (idx[y]->content->next == idx[x]->content)
 333     {
 334       idx[y]->content->next = idx[x]->content->next;
 335       break;
 336     }
 337   }
 338
 339   idx[x]->content->next = NULL;
 340   idx[x]->content->parts = NULL;
 341   mutt_free_body (&(idx[x]->content));
 342   FREE (&idx[x]->tree);
 343   FREE (&idx[x]);
 344   for (; x < *idxlen - 1; x++)
 345     idx[x] = idx[x+1];
 346   menu->max = --(*idxlen);
 347
 348   return (0);
 349 }
 350
 351 static void update_idx (MUTTMENU *menu, ATTACHPTR **idx, short idxlen)
 352 {
 353   idx[idxlen]->level = (idxlen > 0) ? idx[idxlen-1]->level : 0;
 354   if (idxlen)
 355     idx[idxlen - 1]->content->next = idx[idxlen]->content;
 356   idx[idxlen]->content->aptr = idx[idxlen];
 357   menu->current = idxlen++;
 358   mutt_update_tree (idx, idxlen);
 359   menu->max = idxlen;
 360   return;
 361 }
 362
 363
 364 /*
 365  * cum_attachs_size: Cumulative Attachments Size
 366  *
 367  * Returns the total number of bytes used by the attachments in the
 368  * attachment list _after_ content-transfer-encodings have been
 369  * applied.
 370  *
 371  */
 372
 373 static unsigned long cum_attachs_size (MUTTMENU *menu)
 374 {
 375   size_t s;
 376   unsigned short i;
 377   ATTACHPTR **idx = menu->data;
 378   CONTENT *info;
 379   BODY *b;
 380
 381   for (i = 0, s = 0; i < menu->max; i++)
 382   {
 383     b = idx[i]->content;
 384
 385     if (!b->content)
 386       b->content = mutt_get_content_info (b->filename, b);
 387
 388     if ((info = b->content))
 389     {
 390       switch (b->encoding)
 391       {
 392         case ENCQUOTEDPRINTABLE:
 393           s += 3 * (info->lobin + info->hibin) + info->ascii + info->crlf;
 394           break;
 395         case ENCBASE64:
 396           s += (4 * (info->lobin + info->hibin + info->ascii + info->crlf)) / 3;
 397           break;
 398         default:
 399           s += info->lobin + info->hibin + info->ascii + info->crlf;
 400           break;
 401       }
 402     }
 403   }
 404
 405   return s;
 406 }
 407
 408 /* prototype for use below */
 409 static void compose_status_line (char *buf, size_t buflen, size_t col, MUTTMENU *menu,
 410       const char *p);
 411
 412 /*
 413  * compose_format_str()
 414  *
 415  * %a = total number of attachments
 416  * %h = hostname  [option]
 417  * %l = approx. length of current message (in bytes)
 418  * %v = Mutt version
 419  *
 420  * This function is similar to status_format_str().  Look at that function for
 421  * help when modifying this function.
 422  */
 423
 424 static const char *
 425 compose_format_str (char *buf, size_t buflen, size_t col, char op, const char *src,
 426                    const char *prefix, const char *ifstring,
 427                    const char *elsestring,
 428                    unsigned long data, format_flag flags)
 429 {
 430   char fmt[SHORT_STRING], tmp[SHORT_STRING];
 431   int optional = (flags & M_FORMAT_OPTIONAL);
 432   MUTTMENU *menu = (MUTTMENU *) data;
 433
 434   *buf = 0;
 435   switch (op)
 436   {
 437     case 'a': /* total number of attachments */
 438         snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
 439         snprintf (buf, buflen, fmt, menu->max);
 440       break;
 441
 442     case 'h':  /* hostname */
 443       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 444       snprintf (buf, buflen, fmt, NONULL(Hostname));
 445       break;
 446
 447     case 'l': /* approx length of current message in bytes */
 448         snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
 449         mutt_pretty_size (tmp, sizeof (tmp), menu ? cum_attachs_size(menu) : 0);
 450         snprintf (buf, buflen, fmt, tmp);
 451       break;
 452
 453     case 'v':
 454       snprintf (fmt, sizeof (fmt), "Mutt %%s");
 455       snprintf (buf, buflen, fmt, MUTT_VERSION);
 456       break;
 457
 458     case 0:
 459       *buf = 0;
 460       return (src);
 461
 462     default:
 463       snprintf (buf, buflen, "%%%s%c", prefix, op);
 464       break;
 465   }
 466
 467   if (optional)
 468     compose_status_line (buf, buflen, col, menu, ifstring);
 469   else if (flags & M_FORMAT_OPTIONAL)
 470     compose_status_line (buf, buflen, col, menu, elsestring);
 471
 472   return (src);
 473 }
 474
 475 static void compose_status_line (char *buf, size_t buflen, size_t col, MUTTMENU *menu,
 476       const char *p)
 477 {
 478   mutt_FormatString (buf, buflen, col, p, compose_format_str,
 479         (unsigned long) menu, 0);
 480 }
 481
 482
 483 /* return values:
 484  *
 485  * 1    message should be postponed
 486  * 0    normal exit
 487  * -1   abort message
 488  */
 489 int mutt_compose_menu (HEADER *msg,   /* structure for new message */
 490                     char *fcc,     /* where to save a copy of the message */
 491                     size_t fcclen,
 492                     HEADER *cur)   /* current message */
 493 {
 494   char helpstr[LONG_STRING];
 495   char buf[LONG_STRING];
 496   char fname[_POSIX_PATH_MAX];
 497   MUTTMENU *menu;
 498   ATTACHPTR **idx = NULL;
 499   short idxlen = 0;
 500   short idxmax = 0;
 501   int i, close = 0;
 502   int r = -1;           /* return value */
 503   int op = 0;
 504   int loop = 1;
 505   int fccSet = 0;       /* has the user edited the Fcc: field ? */
 506   CONTEXT *ctx = NULL, *this = NULL;
 507   /* Sort, SortAux could be changed in mutt_index_menu() */
 508   int oldSort, oldSortAux;
 509   struct stat st;
 510
 511   mutt_attach_init (msg->content);
 512   idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1);
 513
 514   menu = mutt_new_menu ();
 515   menu->menu = MENU_COMPOSE;
 516   menu->offset = HDR_ATTACH;
 517   menu->max = idxlen;
 518   menu->make_entry = snd_entry;
 519   menu->tag = mutt_tag_attach;
 520   menu->data = idx;
 521   menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_COMPOSE, ComposeHelp);
 522
 523   while (loop)
 524   {
 525     switch (op = mutt_menuLoop (menu))
 526     {
 527       case OP_REDRAW:
 528         draw_envelope (msg, fcc);
 529         menu->offset = HDR_ATTACH;
 530         menu->pagelen = LINES - HDR_ATTACH - 2;
 531         break;
 532       case OP_COMPOSE_EDIT_FROM:
 533         menu->redraw = edit_address_list (HDR_FROM, &msg->env->from);
 534         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 535         break;
 536       case OP_COMPOSE_EDIT_TO:
 537         menu->redraw = edit_address_list (HDR_TO, &msg->env->to);
 538         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 539         break;
 540       case OP_COMPOSE_EDIT_BCC:
 541         menu->redraw = edit_address_list (HDR_BCC, &msg->env->bcc);
 542         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 543         break;
 544       case OP_COMPOSE_EDIT_CC:
 545         menu->redraw = edit_address_list (HDR_CC, &msg->env->cc);
 546         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 547         break;
 548       case OP_COMPOSE_EDIT_SUBJECT:
 549         if (msg->env->subject)
 550           strfcpy (buf, msg->env->subject, sizeof (buf));
 551         else
 552           buf[0] = 0;
 553         if (mutt_get_field ("Subject: ", buf, sizeof (buf), 0) == 0)
 554         {
 555           mutt_str_replace (&msg->env->subject, buf);
 556           move (HDR_SUBJECT, HDR_XOFFSET);
 557           clrtoeol ();
 558           if (msg->env->subject)
 559             mutt_paddstr (W, msg->env->subject);
 560         }
 561         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 562         break;
 563       case OP_COMPOSE_EDIT_REPLY_TO:
 564         menu->redraw = edit_address_list (HDR_REPLYTO, &msg->env->reply_to);
 565         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 566         break;
 567       case OP_COMPOSE_EDIT_FCC:
 568         strfcpy (buf, fcc, sizeof (buf));
 569         if (mutt_get_field ("Fcc: ", buf, sizeof (buf), M_FILE | M_CLEAR) == 0)
 570         {
 571           strfcpy (fcc, buf, _POSIX_PATH_MAX);
 572           mutt_pretty_mailbox (fcc);
 573           move (HDR_FCC, HDR_XOFFSET);
 574           mutt_paddstr (W, fcc);
 575           fccSet = 1;
 576         }
 577         MAYBE_REDRAW (menu->redraw);
 578         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 579         break;
 580       case OP_COMPOSE_EDIT_MESSAGE:
 581         if (Editor && (mutt_strcmp ("builtin", Editor) != 0) && !option (OPTEDITHDRS))
 582         {
 583           mutt_edit_file (Editor, msg->content->filename);
 584           mutt_update_encoding (msg->content);
 585           menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
 586           mutt_message_hook (NULL, msg, M_SEND2HOOK);
 587           break;
 588         }
 589         /* fall through */
 590       case OP_COMPOSE_EDIT_HEADERS:
 591         if (mutt_strcmp ("builtin", Editor) != 0 &&
 592             (op == OP_COMPOSE_EDIT_HEADERS ||
 593             (op == OP_COMPOSE_EDIT_MESSAGE && option (OPTEDITHDRS))))
 594         {
 595           char *tag = NULL, *err = NULL;
 596           mutt_env_to_local (msg->env);
 597           mutt_edit_headers (NONULL (Editor), msg->content->filename, msg,
 598                              fcc, fcclen);
 599           if (mutt_env_to_idna (msg->env, &tag, &err))
 600           {
 601             mutt_error (_("Bad IDN in \"%s\": '%s'"), tag, err);
 602             FREE (&err);
 603           }
 604         }
 605         else
 606         {
 607           /* this is grouped with OP_COMPOSE_EDIT_HEADERS because the
 608              attachment list could change if the user invokes ~v to edit
 609              the message with headers, in which we need to execute the
 610              code below to regenerate the index array */
 611           mutt_builtin_editor (msg->content->filename, msg, cur);
 612         }
 613         mutt_update_encoding (msg->content);
 614
 615         /* attachments may have been added */
 616         if (idxlen && idx[idxlen - 1]->content->next)
 617         {
 618           for (i = 0; i < idxlen; i++)
 619             FREE (&idx[i]);
 620           idxlen = 0;
 621           idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1);
 622           menu->data = idx;
 623           menu->max = idxlen;
 624         }
 625
 626         menu->redraw = REDRAW_FULL;
 627         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 628         break;
 629
 630
 631
 632       case OP_COMPOSE_ATTACH_KEY:
 633         if (!(WithCrypto & APPLICATION_PGP))
 634           break;
 635         if (idxlen == idxmax)
 636         {
 637           safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
 638           menu->data = idx;
 639         }
 640
 641         idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
 642         if ((idx[idxlen]->content = crypt_pgp_make_key_attachment(NULL)) != NULL)
 643         {
 644           update_idx (menu, idx, idxlen++);
 645           menu->redraw |= REDRAW_INDEX;
 646         }
 647         else
 648           FREE (&idx[idxlen]);
 649
 650         menu->redraw |= REDRAW_STATUS;
 651
 652         if (option(OPTNEEDREDRAW))
 653         {
 654           menu->redraw = REDRAW_FULL;
 655           unset_option(OPTNEEDREDRAW);
 656         }
 657
 658         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 659         break;
 660
 661
 662       case OP_COMPOSE_ATTACH_FILE:
 663         {
 664           char *prompt, **files;
 665           int error, numfiles;
 666
 667           fname[0] = 0;
 668           prompt = _("Attach file");
 669           numfiles = 0;
 670           files = NULL;
 671
 672           if (_mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 0, 1, &files, &numfiles) == -1 ||
 673               *fname == '\0')
 674             break;
 675
 676           if (idxlen + numfiles >= idxmax)
 677           {
 678             safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + numfiles));
 679             menu->data = idx;
 680           }
 681
 682           error = 0;
 683           if (numfiles > 1)
 684             mutt_message _("Attaching selected files...");
 685           for (i = 0; i < numfiles; i++)
 686           {
 687             char *att = files[i];
 688             idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
 689             idx[idxlen]->unowned = 1;
 690             idx[idxlen]->content = mutt_make_file_attach (att);
 691             if (idx[idxlen]->content != NULL)
 692               update_idx (menu, idx, idxlen++);
 693             else
 694             {
 695               error = 1;
 696               mutt_error (_("Unable to attach %s!"), att);
 697               FREE (&idx[idxlen]);
 698             }
 699           }
 700
 701           FREE (&files);
 702           if (!error) mutt_clear_error ();
 703
 704           menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
 705         }
 706         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 707         break;
 708
 709       case OP_COMPOSE_ATTACH_MESSAGE:
 710         {
 711           char *prompt;
 712           HEADER *h;
 713
 714           fname[0] = 0;
 715           prompt = _("Open mailbox to attach message from");
 716
 717           if (Context)
 718           {
 719             strfcpy (fname, NONULL (Context->path), sizeof (fname));
 720             mutt_pretty_mailbox (fname);
 721           }
 722
 723           if (mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 1) == -1 || !fname[0])
 724             break;
 725
 726           mutt_expand_path (fname, sizeof (fname));
 727 #ifdef USE_IMAP
 728           if (!mx_is_imap (fname))
 729 #endif
 730 #ifdef USE_POP
 731           if (!mx_is_pop (fname))
 732 #endif
 733           /* check to make sure the file exists and is readable */
 734           if (access (fname, R_OK) == -1)
 735           {
 736             mutt_perror (fname);
 737             break;
 738           }
 739
 740           menu->redraw = REDRAW_FULL;
 741
 742           ctx = mx_open_mailbox (fname, M_READONLY, NULL);
 743           if (ctx == NULL)
 744           {
 745             mutt_perror (fname);
 746             break;
 747           }
 748
 749           if (!ctx->msgcount)
 750           {
 751             mx_close_mailbox (ctx, NULL);
 752             FREE (&ctx);
 753             mutt_error _("No messages in that folder.");
 754             break;
 755           }
 756
 757           this = Context; /* remember current folder and sort methods*/
 758           oldSort = Sort; oldSortAux = SortAux;
 759
 760           Context = ctx;
 761           set_option(OPTATTACHMSG);
 762           mutt_message _("Tag the messages you want to attach!");
 763           close = mutt_index_menu ();
 764           unset_option(OPTATTACHMSG);
 765
 766           if (!Context)
 767           {
 768             /* go back to the folder we started from */
 769             Context = this;
 770             /* Restore old $sort and $sort_aux */
 771             Sort = oldSort;
 772             SortAux = oldSortAux;
 773             menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
 774             break;
 775           }
 776
 777           if (idxlen + Context->tagged >= idxmax)
 778           {
 779             safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + Context->tagged));
 780             menu->data = idx;
 781           }
 782
 783           for (i = 0; i < Context->msgcount; i++)
 784           {
 785             h = Context->hdrs[i];
 786             if (h->tagged)
 787             {
 788               idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
 789               idx[idxlen]->content = mutt_make_message_attach (Context, h, 1);
 790               if (idx[idxlen]->content != NULL)
 791                 update_idx (menu, idx, idxlen++);
 792               else
 793               {
 794                 mutt_error _("Unable to attach!");
 795                 FREE (&idx[idxlen]);
 796               }
 797             }
 798           }
 799           menu->redraw |= REDRAW_FULL;
 800
 801           if (close == OP_QUIT)
 802             mx_close_mailbox (Context, NULL);
 803           else
 804             mx_fastclose_mailbox (Context);
 805           FREE (&Context);
 806
 807           /* go back to the folder we started from */
 808           Context = this;
 809           /* Restore old $sort and $sort_aux */
 810           Sort = oldSort;
 811           SortAux = oldSortAux;
 812         }
 813         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 814         break;
 815
 816       case OP_DELETE:
 817         CHECK_COUNT;
 818         if (idx[menu->current]->unowned)
 819           idx[menu->current]->content->unlink = 0;
 820         if (delete_attachment (menu, &idxlen, menu->current) == -1)
 821           break;
 822         mutt_update_tree (idx, idxlen);
 823         if (idxlen)
 824         {
 825           if (menu->current > idxlen - 1)
 826             menu->current = idxlen - 1;
 827         }
 828         else
 829           menu->current = 0;
 830
 831         if (menu->current == 0)
 832           msg->content = idx[0]->content;
 833
 834         menu->redraw |= REDRAW_STATUS;
 835         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 836         break;
 837
 838 #define CURRENT idx[menu->current]->content
 839
 840       case OP_COMPOSE_TOGGLE_RECODE:
 841       {
 842         CHECK_COUNT;
 843         if (!mutt_is_text_part (CURRENT))
 844         {
 845           mutt_error (_("Recoding only affects text attachments."));
 846           break;
 847         }
 848         CURRENT->noconv = !CURRENT->noconv;
 849         if (CURRENT->noconv)
 850           mutt_message (_("The current attachment won't be converted."));
 851         else
 852           mutt_message (_("The current attachment will be converted."));
 853         menu->redraw = REDRAW_CURRENT;
 854         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 855         break;
 856       }
 857 #undef CURRENT
 858
 859       case OP_COMPOSE_EDIT_DESCRIPTION:
 860         CHECK_COUNT;
 861         strfcpy (buf,
 862                  idx[menu->current]->content->description ?
 863                  idx[menu->current]->content->description : "",
 864                  sizeof (buf));
 865         /* header names should not be translated */
 866         if (mutt_get_field ("Description: ", buf, sizeof (buf), 0) == 0)
 867         {
 868           mutt_str_replace (&idx[menu->current]->content->description, buf);
 869           menu->redraw = REDRAW_CURRENT;
 870         }
 871         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 872         break;
 873
 874       case OP_COMPOSE_UPDATE_ENCODING:
 875         CHECK_COUNT;
 876         if (menu->tagprefix)
 877         {
 878           BODY *top;
 879           for (top = msg->content; top; top = top->next)
 880           {
 881             if (top->tagged)
 882               mutt_update_encoding (top);
 883           }
 884           menu->redraw = REDRAW_FULL;
 885         }
 886         else
 887         {
 888           mutt_update_encoding(idx[menu->current]->content);
 889           menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
 890         }
 891         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 892         break;
 893
 894       case OP_COMPOSE_TOGGLE_DISPOSITION:
 895         /* toggle the content-disposition between inline/attachment */
 896         idx[menu->current]->content->disposition = (idx[menu->current]->content->disposition == DISPINLINE) ? DISPATTACH : DISPINLINE;
 897         menu->redraw = REDRAW_CURRENT;
 898         break;
 899
 900       case OP_EDIT_TYPE:
 901         CHECK_COUNT;
 902         {
 903           mutt_edit_content_type (NULL, idx[menu->current]->content, NULL);
 904
 905           /* this may have been a change to text/something */
 906           mutt_update_encoding (idx[menu->current]->content);
 907
 908           menu->redraw = REDRAW_CURRENT;
 909         }
 910         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 911         break;
 912
 913       case OP_COMPOSE_EDIT_ENCODING:
 914         CHECK_COUNT;
 915         strfcpy (buf, ENCODING (idx[menu->current]->content->encoding),
 916                                                               sizeof (buf));
 917         if (mutt_get_field ("Content-Transfer-Encoding: ", buf,
 918                                             sizeof (buf), 0) == 0 && buf[0])
 919         {
 920           if ((i = mutt_check_encoding (buf)) != ENCOTHER && i != ENCUUENCODED)
 921           {
 922             idx[menu->current]->content->encoding = i;
 923             menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
 924             mutt_clear_error();
 925           }
 926           else
 927             mutt_error _("Invalid encoding.");
 928         }
 929         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 930         break;
 931
 932       case OP_COMPOSE_SEND_MESSAGE:
 933
 934         /* Note: We don't invoke send2-hook here, since we want to leave
 935          * users an opportunity to change settings from the ":" prompt.
 936          */
 937
 938         if(check_attachments(idx, idxlen) != 0)
 939         {
 940           menu->redraw = REDRAW_FULL;
 941           break;
 942         }
 943
 944
 945 #ifdef MIXMASTER
 946         if (msg->chain && mix_check_message (msg) != 0)
 947           break;
 948 #endif
 949
 950         if (!fccSet && *fcc)
 951         {
 952           if ((i = query_quadoption (OPT_COPY,
 953                                 _("Save a copy of this message?"))) == -1)
 954             break;
 955           else if (i == M_NO)
 956             *fcc = 0;
 957         }
 958
 959         loop = 0;
 960         r = 0;
 961         break;
 962
 963       case OP_COMPOSE_EDIT_FILE:
 964         CHECK_COUNT;
 965         mutt_edit_file (NONULL(Editor), idx[menu->current]->content->filename);
 966         mutt_update_encoding (idx[menu->current]->content);
 967         menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
 968         mutt_message_hook (NULL, msg, M_SEND2HOOK);
 969         break;
 970
 971       case OP_COMPOSE_TOGGLE_UNLINK:
 972         CHECK_COUNT;
 973         idx[menu->current]->content->unlink = !idx[menu->current]->content->unlink;
 974
 975 #if 0
 976         /* OPTRESOLVE is otherwise ignored on this menu.
 977          * Where's the bug?
 978          */
 979
 980         if (option (OPTRESOLVE) && menu->current + 1 < menu->max)
 981           menu->current++;
 982 # endif
 983         menu->redraw = REDRAW_INDEX;
 984         /* No send2hook since this doesn't change the message. */
 985         break;
 986
 987       case OP_COMPOSE_GET_ATTACHMENT:
 988         CHECK_COUNT;
 989         if(menu->tagprefix)
 990         {
 991           BODY *top;
 992           for(top = msg->content; top; top = top->next)
 993           {
 994             if(top->tagged)
 995               mutt_get_tmp_attachment(top);
 996           }
 997           menu->redraw = REDRAW_FULL;
 998         }
 999         else if (mutt_get_tmp_attachment(idx[menu->current]->content) == 0)
1000           menu->redraw = REDRAW_CURRENT;
1001
1002         /* No send2hook since this doesn't change the message. */
1003         break;
1004
1005       case OP_COMPOSE_RENAME_FILE:
1006         CHECK_COUNT;
1007         strfcpy (fname, idx[menu->current]->content->filename, sizeof (fname));
1008         mutt_pretty_mailbox (fname);
1009         if (mutt_get_field (_("Rename to: "), fname, sizeof (fname), M_FILE)
1010                                                         == 0 && fname[0])
1011         {
1012           if (stat(idx[menu->current]->content->filename, &st) == -1)
1013           {
1014             mutt_error (_("Can't stat %s: %s"), fname, strerror (errno));
1015             break;
1016           }
1017
1018           mutt_expand_path (fname, sizeof (fname));
1019           if(mutt_rename_file (idx[menu->current]->content->filename, fname))
1020             break;
1021
1022           mutt_str_replace (&idx[menu->current]->content->filename, fname);
1023           menu->redraw = REDRAW_CURRENT;
1024
1025           if(idx[menu->current]->content->stamp >= st.st_mtime)
1026             mutt_stamp_attachment(idx[menu->current]->content);
1027
1028         }
1029         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1030         break;
1031
1032       case OP_COMPOSE_NEW_MIME:
1033         {
1034           char type[STRING];
1035           char *p;
1036           int itype;
1037           FILE *fp;
1038
1039           CLEARLINE (LINES-1);
1040           fname[0] = 0;
1041           if (mutt_get_field (_("New file: "), fname, sizeof (fname), M_FILE)
1042               != 0 || !fname[0])
1043             continue;
1044           mutt_expand_path (fname, sizeof (fname));
1045
1046           /* Call to lookup_mime_type () ?  maybe later */
1047           type[0] = 0;
1048           if (mutt_get_field ("Content-Type: ", type, sizeof (type), 0) != 0
1049               || !type[0])
1050             continue;
1051
1052           if (!(p = strchr (type, '/')))
1053           {
1054             mutt_error _("Content-Type is of the form base/sub");
1055             continue;
1056           }
1057           *p++ = 0;
1058           if ((itype = mutt_check_mime_type (type)) == TYPEOTHER)
1059           {
1060             mutt_error (_("Unknown Content-Type %s"), type);
1061             continue;
1062           }
1063           if (idxlen == idxmax)
1064           {
1065             safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
1066             menu->data = idx;
1067           }
1068
1069           idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
1070           /* Touch the file */
1071           if (!(fp = safe_fopen (fname, "w")))
1072           {
1073             mutt_error (_("Can't create file %s"), fname);
1074             FREE (&idx[idxlen]);
1075             continue;
1076           }
1077           fclose (fp);
1078
1079           if ((idx[idxlen]->content = mutt_make_file_attach (fname)) == NULL)
1080           {
1081             mutt_error _("What we have here is a failure to make an attachment");
1082             continue;
1083           }
1084           update_idx (menu, idx, idxlen++);
1085
1086           idx[menu->current]->content->type = itype;
1087           mutt_str_replace (&idx[menu->current]->content->subtype, p);
1088           idx[menu->current]->content->unlink = 1;
1089           menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
1090
1091           if (mutt_compose_attachment (idx[menu->current]->content))
1092           {
1093             mutt_update_encoding (idx[menu->current]->content);
1094             menu->redraw = REDRAW_FULL;
1095           }
1096         }
1097         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1098         break;
1099
1100       case OP_COMPOSE_EDIT_MIME:
1101         CHECK_COUNT;
1102         if (mutt_edit_attachment (idx[menu->current]->content))
1103         {
1104           mutt_update_encoding (idx[menu->current]->content);
1105           menu->redraw = REDRAW_FULL;
1106         }
1107         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1108         break;
1109
1110       case OP_VIEW_ATTACH:
1111       case OP_DISPLAY_HEADERS:
1112         CHECK_COUNT;
1113         mutt_attach_display_loop (menu, op, NULL, NULL, NULL, &idx, &idxlen, NULL, 0);
1114         menu->redraw = REDRAW_FULL;
1115         /* no send2hook, since this doesn't modify the message */
1116         break;
1117
1118       case OP_SAVE:
1119         CHECK_COUNT;
1120         mutt_save_attachment_list (NULL, menu->tagprefix, menu->tagprefix ?  msg->content : idx[menu->current]->content, NULL, menu);
1121         MAYBE_REDRAW (menu->redraw);
1122         /* no send2hook, since this doesn't modify the message */
1123         break;
1124
1125       case OP_PRINT:
1126         CHECK_COUNT;
1127         mutt_print_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content);
1128         /* no send2hook, since this doesn't modify the message */
1129         break;
1130
1131       case OP_PIPE:
1132       case OP_FILTER:
1133         CHECK_COUNT;
1134         mutt_pipe_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content, op == OP_FILTER);
1135         if (op == OP_FILTER) /* cte might have changed */
1136           menu->redraw = menu->tagprefix ? REDRAW_FULL : REDRAW_CURRENT;
1137         menu->redraw |= REDRAW_STATUS;
1138         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1139         break;
1140
1141       case OP_EXIT:
1142         if ((i = query_quadoption (OPT_POSTPONE, _("Postpone this message?"))) == M_NO)
1143         {
1144           while (idxlen-- > 0)
1145           {
1146             /* avoid freeing other attachments */
1147             idx[idxlen]->content->next = NULL;
1148             idx[idxlen]->content->parts = NULL;
1149             if (idx[idxlen]->unowned)
1150               idx[idxlen]->content->unlink = 0;
1151             mutt_free_body (&idx[idxlen]->content);
1152             FREE (&idx[idxlen]->tree);
1153             FREE (&idx[idxlen]);
1154           }
1155           FREE (&idx);
1156           idxlen = 0;
1157           idxmax = 0;
1158           r = -1;
1159           loop = 0;
1160           break;
1161         }
1162         else if (i == -1)
1163           break; /* abort */
1164
1165         /* fall through to postpone! */
1166
1167       case OP_COMPOSE_POSTPONE_MESSAGE:
1168
1169         if(check_attachments(idx, idxlen) != 0)
1170         {
1171           menu->redraw = REDRAW_FULL;
1172           break;
1173         }
1174
1175         loop = 0;
1176         r = 1;
1177         break;
1178
1179       case OP_COMPOSE_ISPELL:
1180         endwin ();
1181         snprintf (buf, sizeof (buf), "%s -x %s", NONULL(Ispell), msg->content->filename);
1182         if (mutt_system (buf) == -1)
1183           mutt_error (_("Error running \"%s\"!"), buf);
1184         else
1185         {
1186           mutt_update_encoding (msg->content);
1187           menu->redraw |= REDRAW_STATUS;
1188         }
1189         break;
1190
1191       case OP_COMPOSE_WRITE_MESSAGE:
1192
1193        fname[0] = '\0';
1194        if (Context)
1195        {
1196          strfcpy (fname, NONULL (Context->path), sizeof (fname));
1197          mutt_pretty_mailbox (fname);
1198        }
1199        if (idxlen)
1200          msg->content = idx[0]->content;
1201        if (mutt_enter_fname (_("Write message to mailbox"), fname, sizeof (fname),
1202                              &menu->redraw, 1) != -1 && fname[0])
1203        {
1204          mutt_message (_("Writing message to %s ..."), fname);
1205          mutt_expand_path (fname, sizeof (fname));
1206
1207          if (msg->content->next)
1208            msg->content = mutt_make_multipart (msg->content);
1209
1210          if (mutt_write_fcc (fname, msg, NULL, 1, NULL) < 0)
1211            msg->content = mutt_remove_multipart (msg->content);
1212          else
1213            mutt_message _("Message written.");
1214        }
1215        break;
1216
1217
1218
1219       case OP_COMPOSE_PGP_MENU:
1220         if (!(WithCrypto & APPLICATION_PGP))
1221           break;
1222         if ((WithCrypto & APPLICATION_SMIME)
1223             && msg->security & APPLICATION_SMIME)
1224         {
1225           if (mutt_yesorno (_("S/MIME already selected. Clear & continue ? "),
1226                              M_YES) != M_YES)
1227           {
1228             mutt_clear_error ();
1229             break;
1230           }
1231           msg->security = 0;
1232         }
1233         msg->security = crypt_pgp_send_menu (msg, &menu->redraw);
1234         redraw_crypt_lines (msg);
1235         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1236         break;
1237
1238
1239       case OP_FORGET_PASSPHRASE:
1240         crypt_forget_passphrase ();
1241         break;
1242
1243
1244       case OP_COMPOSE_SMIME_MENU:
1245         if (!(WithCrypto & APPLICATION_SMIME))
1246           break;
1247
1248         if ((WithCrypto & APPLICATION_PGP)
1249             && msg->security & APPLICATION_PGP)
1250         {
1251           if (mutt_yesorno (_("PGP already selected. Clear & continue ? "),
1252                               M_YES) != M_YES)
1253           {
1254              mutt_clear_error ();
1255              break;
1256           }
1257           msg->security = 0;
1258         }
1259         msg->security = crypt_smime_send_menu(msg, &menu->redraw);
1260         redraw_crypt_lines (msg);
1261         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1262         break;
1263
1264
1265 #ifdef MIXMASTER
1266       case OP_COMPOSE_MIX:
1267
1268         mix_make_chain (&msg->chain, &menu->redraw);
1269         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1270         break;
1271 #endif
1272
1273     }
1274
1275     /* Draw formated compose status line */
1276     if (menu->redraw & REDRAW_STATUS)
1277     {
1278         compose_status_line (buf, sizeof (buf), 0, menu, NONULL(ComposeFormat));
1279         CLEARLINE (option (OPTSTATUSONTOP) ? 0 : LINES-2);
1280         SETCOLOR (MT_COLOR_STATUS);
1281         BKGDSET (MT_COLOR_STATUS);
1282         mutt_paddstr (COLS, buf);
1283         SETCOLOR (MT_COLOR_NORMAL);
1284         BKGDSET (MT_COLOR_NORMAL);
1285         menu->redraw &= ~REDRAW_STATUS;
1286     }
1287   }
1288
1289   mutt_menuDestroy (&menu);
1290
1291   if (idxlen)
1292   {
1293     msg->content = idx[0]->content;
1294     for (i = 0; i < idxlen; i++)
1295     {
1296       idx[i]->content->aptr = NULL;
1297       FREE (&idx[i]);
1298     }
1299   }
1300   else
1301     msg->content = NULL;
1302
1303   FREE (&idx);
1304
1305   return (r);
1306 }
1307