]> git.llucax.com Git - software/mutt-debian.git/blob - compose.c
renaming the unmailboxes patch
[software/mutt-debian.git] / compose.c
1 /*
2  * Copyright (C) 1996-2000,2002,2007 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,       0 }
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, sizeof (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, sizeof (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 (MENU_COMPOSE);
515   menu->offset = HDR_ATTACH;
516   menu->max = idxlen;
517   menu->make_entry = snd_entry;
518   menu->tag = mutt_tag_attach;
519   menu->data = idx;
520   menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_COMPOSE, ComposeHelp);
521   
522   while (loop)
523   {
524     switch (op = mutt_menuLoop (menu))
525     {
526       case OP_REDRAW:
527         draw_envelope (msg, fcc);
528         menu->offset = HDR_ATTACH;
529         menu->pagelen = LINES - HDR_ATTACH - 2;
530         break;
531       case OP_COMPOSE_EDIT_FROM:
532         menu->redraw = edit_address_list (HDR_FROM, &msg->env->from);
533         mutt_message_hook (NULL, msg, M_SEND2HOOK);
534         break;
535       case OP_COMPOSE_EDIT_TO:
536         menu->redraw = edit_address_list (HDR_TO, &msg->env->to);
537         mutt_message_hook (NULL, msg, M_SEND2HOOK);
538         break;
539       case OP_COMPOSE_EDIT_BCC:
540         menu->redraw = edit_address_list (HDR_BCC, &msg->env->bcc);
541         mutt_message_hook (NULL, msg, M_SEND2HOOK);
542         break;
543       case OP_COMPOSE_EDIT_CC:
544         menu->redraw = edit_address_list (HDR_CC, &msg->env->cc);
545         mutt_message_hook (NULL, msg, M_SEND2HOOK);     
546         break;
547       case OP_COMPOSE_EDIT_SUBJECT:
548         if (msg->env->subject)
549           strfcpy (buf, msg->env->subject, sizeof (buf));
550         else
551           buf[0] = 0;
552         if (mutt_get_field ("Subject: ", buf, sizeof (buf), 0) == 0)
553         {
554           mutt_str_replace (&msg->env->subject, buf);
555           move (HDR_SUBJECT, HDR_XOFFSET);
556           clrtoeol ();
557           if (msg->env->subject)
558             mutt_paddstr (W, msg->env->subject);
559         }
560         mutt_message_hook (NULL, msg, M_SEND2HOOK);
561         break;
562       case OP_COMPOSE_EDIT_REPLY_TO:
563         menu->redraw = edit_address_list (HDR_REPLYTO, &msg->env->reply_to);
564         mutt_message_hook (NULL, msg, M_SEND2HOOK);
565         break;
566       case OP_COMPOSE_EDIT_FCC:
567         strfcpy (buf, fcc, sizeof (buf));
568         if (mutt_get_field ("Fcc: ", buf, sizeof (buf), M_FILE | M_CLEAR) == 0)
569         {
570           strfcpy (fcc, buf, fcclen);
571           mutt_pretty_mailbox (fcc, fcclen);
572           move (HDR_FCC, HDR_XOFFSET);
573           mutt_paddstr (W, fcc);
574           fccSet = 1;
575         }
576         MAYBE_REDRAW (menu->redraw);
577         mutt_message_hook (NULL, msg, M_SEND2HOOK);
578         break;
579       case OP_COMPOSE_EDIT_MESSAGE:
580         if (Editor && (mutt_strcmp ("builtin", Editor) != 0) && !option (OPTEDITHDRS))
581         {
582           mutt_edit_file (Editor, msg->content->filename);
583           mutt_update_encoding (msg->content);
584           menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
585           mutt_message_hook (NULL, msg, M_SEND2HOOK);
586           break;
587         }
588         /* fall through */
589       case OP_COMPOSE_EDIT_HEADERS:
590         if (mutt_strcmp ("builtin", Editor) != 0 &&
591             (op == OP_COMPOSE_EDIT_HEADERS ||
592             (op == OP_COMPOSE_EDIT_MESSAGE && option (OPTEDITHDRS))))
593         {
594           char *tag = NULL, *err = NULL;
595           mutt_env_to_local (msg->env);
596           mutt_edit_headers (NONULL (Editor), msg->content->filename, msg,
597                              fcc, fcclen);
598           if (mutt_env_to_idna (msg->env, &tag, &err))
599           {
600             mutt_error (_("Bad IDN in \"%s\": '%s'"), tag, err);
601             FREE (&err);
602           }
603         }
604         else
605         {
606           /* this is grouped with OP_COMPOSE_EDIT_HEADERS because the
607              attachment list could change if the user invokes ~v to edit
608              the message with headers, in which we need to execute the
609              code below to regenerate the index array */
610           mutt_builtin_editor (msg->content->filename, msg, cur);
611         }
612         mutt_update_encoding (msg->content);
613
614         /* attachments may have been added */
615         if (idxlen && idx[idxlen - 1]->content->next)
616         {
617           for (i = 0; i < idxlen; i++)
618             FREE (&idx[i]);
619           idxlen = 0;
620           idx = mutt_gen_attach_list (msg->content, -1, idx, &idxlen, &idxmax, 0, 1);
621           menu->data = idx;
622           menu->max = idxlen;
623         }
624
625         menu->redraw = REDRAW_FULL;
626         mutt_message_hook (NULL, msg, M_SEND2HOOK);
627         break;
628
629
630
631       case OP_COMPOSE_ATTACH_KEY:
632         if (!(WithCrypto & APPLICATION_PGP))
633           break;       
634         if (idxlen == idxmax)
635         {
636           safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
637           menu->data = idx;
638         }
639         
640         idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
641         if ((idx[idxlen]->content = crypt_pgp_make_key_attachment(NULL)) != NULL)
642         {
643           update_idx (menu, idx, idxlen++);
644           menu->redraw |= REDRAW_INDEX;
645         }
646         else
647           FREE (&idx[idxlen]);
648
649         menu->redraw |= REDRAW_STATUS;
650
651         if (option(OPTNEEDREDRAW))
652         {
653           menu->redraw = REDRAW_FULL;
654           unset_option(OPTNEEDREDRAW);
655         }
656         
657         mutt_message_hook (NULL, msg, M_SEND2HOOK);
658         break;
659
660
661       case OP_COMPOSE_ATTACH_FILE:
662         {
663           char *prompt, **files;
664           int error, numfiles;
665
666           fname[0] = 0;
667           prompt = _("Attach file");
668           numfiles = 0;
669           files = NULL;
670
671           if (_mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 0, 1, &files, &numfiles) == -1 ||
672               *fname == '\0')
673             break;
674
675           if (idxlen + numfiles >= idxmax)
676           {
677             safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + numfiles));
678             menu->data = idx;
679           }
680
681           error = 0;
682           if (numfiles > 1)
683             mutt_message _("Attaching selected files...");
684           for (i = 0; i < numfiles; i++)
685           {
686             char *att = files[i];
687             idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
688             idx[idxlen]->unowned = 1;
689             idx[idxlen]->content = mutt_make_file_attach (att);
690             if (idx[idxlen]->content != NULL)
691               update_idx (menu, idx, idxlen++);
692             else
693             {
694               error = 1;
695               mutt_error (_("Unable to attach %s!"), att);
696               FREE (&idx[idxlen]);
697             }
698           }
699           
700           FREE (&files);
701           if (!error) mutt_clear_error ();
702
703           menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
704         }
705         mutt_message_hook (NULL, msg, M_SEND2HOOK);
706         break;
707
708       case OP_COMPOSE_ATTACH_MESSAGE:
709         {
710           char *prompt;
711           HEADER *h;
712
713           fname[0] = 0;
714           prompt = _("Open mailbox to attach message from");
715
716           if (Context)
717           {
718             strfcpy (fname, NONULL (Context->path), sizeof (fname));
719             mutt_pretty_mailbox (fname, sizeof (fname));
720           }
721
722           if (mutt_enter_fname (prompt, fname, sizeof (fname), &menu->redraw, 1) == -1 || !fname[0])
723             break;
724
725           mutt_expand_path (fname, sizeof (fname));
726 #ifdef USE_IMAP
727           if (!mx_is_imap (fname))
728 #endif
729 #ifdef USE_POP
730           if (!mx_is_pop (fname))
731 #endif
732           /* check to make sure the file exists and is readable */
733           if (access (fname, R_OK) == -1)
734           {
735             mutt_perror (fname);
736             break;
737           }
738
739           menu->redraw = REDRAW_FULL;
740
741           ctx = mx_open_mailbox (fname, M_READONLY, NULL);
742           if (ctx == NULL)
743           {
744             mutt_perror (fname);
745             break;
746           }
747
748           if (!ctx->msgcount)
749           {
750             mx_close_mailbox (ctx, NULL);
751             FREE (&ctx);
752             mutt_error _("No messages in that folder.");
753             break;
754           }
755
756           this = Context; /* remember current folder and sort methods*/
757           oldSort = Sort; oldSortAux = SortAux;
758           
759           Context = ctx;
760           set_option(OPTATTACHMSG);
761           mutt_message _("Tag the messages you want to attach!");
762           close = mutt_index_menu ();
763           unset_option(OPTATTACHMSG);
764
765           if (!Context)
766           {
767             /* go back to the folder we started from */
768             Context = this;
769             /* Restore old $sort and $sort_aux */
770             Sort = oldSort;
771             SortAux = oldSortAux;
772             menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
773             break;
774           }
775
776           if (idxlen + Context->tagged >= idxmax)
777           {
778             safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5 + Context->tagged));
779             menu->data = idx;
780           }
781
782           for (i = 0; i < Context->msgcount; i++)
783           {
784             h = Context->hdrs[i];
785             if (h->tagged)
786             {
787               idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
788               idx[idxlen]->content = mutt_make_message_attach (Context, h, 1);
789               if (idx[idxlen]->content != NULL)
790                 update_idx (menu, idx, idxlen++);
791               else
792               {
793                 mutt_error _("Unable to attach!");
794                 FREE (&idx[idxlen]);
795               }
796             }
797           }
798           menu->redraw |= REDRAW_FULL;
799
800           if (close == OP_QUIT) 
801             mx_close_mailbox (Context, NULL);
802           else
803             mx_fastclose_mailbox (Context);
804           FREE (&Context);
805
806           /* go back to the folder we started from */
807           Context = this;
808           /* Restore old $sort and $sort_aux */
809           Sort = oldSort;
810           SortAux = oldSortAux;
811         }
812         mutt_message_hook (NULL, msg, M_SEND2HOOK);
813         break;
814
815       case OP_DELETE:
816         CHECK_COUNT;
817         if (idx[menu->current]->unowned)
818           idx[menu->current]->content->unlink = 0;
819         if (delete_attachment (menu, &idxlen, menu->current) == -1)
820           break;
821         mutt_update_tree (idx, idxlen);
822         if (idxlen)
823         {
824           if (menu->current > idxlen - 1)
825             menu->current = idxlen - 1;
826         }
827         else
828           menu->current = 0;
829
830         if (menu->current == 0)
831           msg->content = idx[0]->content;
832
833         menu->redraw |= REDRAW_STATUS;
834         mutt_message_hook (NULL, msg, M_SEND2HOOK);
835         break;
836
837 #define CURRENT idx[menu->current]->content
838       
839       case OP_COMPOSE_TOGGLE_RECODE:
840       {      
841         CHECK_COUNT;
842         if (!mutt_is_text_part (CURRENT))
843         {
844           mutt_error (_("Recoding only affects text attachments."));
845           break;
846         }
847         CURRENT->noconv = !CURRENT->noconv;
848         if (CURRENT->noconv)
849           mutt_message (_("The current attachment won't be converted."));
850         else
851           mutt_message (_("The current attachment will be converted."));
852         menu->redraw = REDRAW_CURRENT;
853         mutt_message_hook (NULL, msg, M_SEND2HOOK);
854         break;
855       }
856 #undef CURRENT
857
858       case OP_COMPOSE_EDIT_DESCRIPTION:
859         CHECK_COUNT;
860         strfcpy (buf,
861                  idx[menu->current]->content->description ?
862                  idx[menu->current]->content->description : "",
863                  sizeof (buf));
864         /* header names should not be translated */
865         if (mutt_get_field ("Description: ", buf, sizeof (buf), 0) == 0)
866         {
867           mutt_str_replace (&idx[menu->current]->content->description, buf);
868           menu->redraw = REDRAW_CURRENT;
869         }
870         mutt_message_hook (NULL, msg, M_SEND2HOOK);
871         break;
872
873       case OP_COMPOSE_UPDATE_ENCODING:
874         CHECK_COUNT;
875         if (menu->tagprefix)
876         {
877           BODY *top;
878           for (top = msg->content; top; top = top->next)
879           {
880             if (top->tagged)
881               mutt_update_encoding (top);
882           }
883           menu->redraw = REDRAW_FULL;
884         }
885         else
886         {
887           mutt_update_encoding(idx[menu->current]->content);
888           menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
889         }
890         mutt_message_hook (NULL, msg, M_SEND2HOOK);
891         break;
892       
893       case OP_COMPOSE_TOGGLE_DISPOSITION:
894         /* toggle the content-disposition between inline/attachment */
895         idx[menu->current]->content->disposition = (idx[menu->current]->content->disposition == DISPINLINE) ? DISPATTACH : DISPINLINE;
896         menu->redraw = REDRAW_CURRENT;
897         break;
898
899       case OP_EDIT_TYPE:
900         CHECK_COUNT;
901         {
902           mutt_edit_content_type (NULL, idx[menu->current]->content, NULL);
903
904           /* this may have been a change to text/something */
905           mutt_update_encoding (idx[menu->current]->content);
906
907           menu->redraw = REDRAW_CURRENT;
908         }
909         mutt_message_hook (NULL, msg, M_SEND2HOOK);
910         break;
911
912       case OP_COMPOSE_EDIT_ENCODING:
913         CHECK_COUNT;
914         strfcpy (buf, ENCODING (idx[menu->current]->content->encoding),
915                                                               sizeof (buf));
916         if (mutt_get_field ("Content-Transfer-Encoding: ", buf,
917                                             sizeof (buf), 0) == 0 && buf[0])
918         {
919           if ((i = mutt_check_encoding (buf)) != ENCOTHER && i != ENCUUENCODED)
920           {
921             idx[menu->current]->content->encoding = i;
922             menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
923             mutt_clear_error();
924           }
925           else
926             mutt_error _("Invalid encoding.");
927         }
928         mutt_message_hook (NULL, msg, M_SEND2HOOK);
929         break;
930
931       case OP_COMPOSE_SEND_MESSAGE:
932
933         /* Note: We don't invoke send2-hook here, since we want to leave
934          * users an opportunity to change settings from the ":" prompt.
935          */
936       
937         if(check_attachments(idx, idxlen) != 0)
938         {
939           menu->redraw = REDRAW_FULL;
940           break;
941         }
942
943       
944 #ifdef MIXMASTER
945         if (msg->chain && mix_check_message (msg) != 0)
946           break;
947 #endif
948       
949         if (!fccSet && *fcc)
950         {
951           if ((i = query_quadoption (OPT_COPY,
952                                 _("Save a copy of this message?"))) == -1)
953             break;
954           else if (i == M_NO)
955             *fcc = 0;
956         }
957
958         loop = 0;
959         r = 0;
960         break;
961
962       case OP_COMPOSE_EDIT_FILE:
963         CHECK_COUNT;
964         mutt_edit_file (NONULL(Editor), idx[menu->current]->content->filename);
965         mutt_update_encoding (idx[menu->current]->content);
966         menu->redraw = REDRAW_CURRENT | REDRAW_STATUS;
967         mutt_message_hook (NULL, msg, M_SEND2HOOK);
968         break;
969
970       case OP_COMPOSE_TOGGLE_UNLINK:
971         CHECK_COUNT;
972         idx[menu->current]->content->unlink = !idx[menu->current]->content->unlink;
973
974 #if 0
975         /* OPTRESOLVE is otherwise ignored on this menu.
976          * Where's the bug?
977          */
978
979         if (option (OPTRESOLVE) && menu->current + 1 < menu->max)
980           menu->current++;
981 # endif
982         menu->redraw = REDRAW_INDEX;
983         /* No send2hook since this doesn't change the message. */
984         break;
985
986       case OP_COMPOSE_GET_ATTACHMENT:
987         CHECK_COUNT;
988         if(menu->tagprefix)
989         {
990           BODY *top;
991           for(top = msg->content; top; top = top->next)
992           {
993             if(top->tagged)
994               mutt_get_tmp_attachment(top);
995           }
996           menu->redraw = REDRAW_FULL;
997         }
998         else if (mutt_get_tmp_attachment(idx[menu->current]->content) == 0)
999           menu->redraw = REDRAW_CURRENT;
1000
1001         /* No send2hook since this doesn't change the message. */
1002         break;
1003       
1004       case OP_COMPOSE_RENAME_FILE:
1005         CHECK_COUNT;
1006         strfcpy (fname, idx[menu->current]->content->filename, sizeof (fname));
1007         mutt_pretty_mailbox (fname, sizeof (fname));
1008         if (mutt_get_field (_("Rename to: "), fname, sizeof (fname), M_FILE)
1009                                                         == 0 && fname[0])
1010         {
1011           if (stat(idx[menu->current]->content->filename, &st) == -1)
1012           {
1013             mutt_error (_("Can't stat %s: %s"), fname, strerror (errno));
1014             break;
1015           }
1016
1017           mutt_expand_path (fname, sizeof (fname));
1018           if(mutt_rename_file (idx[menu->current]->content->filename, fname))
1019             break;
1020           
1021           mutt_str_replace (&idx[menu->current]->content->filename, fname);
1022           menu->redraw = REDRAW_CURRENT;
1023
1024           if(idx[menu->current]->content->stamp >= st.st_mtime)
1025             mutt_stamp_attachment(idx[menu->current]->content);
1026           
1027         }
1028         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1029         break;
1030
1031       case OP_COMPOSE_NEW_MIME:
1032         {
1033           char type[STRING];
1034           char *p;
1035           int itype;
1036           FILE *fp;
1037
1038           CLEARLINE (LINES-1);
1039           fname[0] = 0;
1040           if (mutt_get_field (_("New file: "), fname, sizeof (fname), M_FILE)
1041               != 0 || !fname[0])
1042             continue;
1043           mutt_expand_path (fname, sizeof (fname));
1044
1045           /* Call to lookup_mime_type () ?  maybe later */
1046           type[0] = 0;
1047           if (mutt_get_field ("Content-Type: ", type, sizeof (type), 0) != 0 
1048               || !type[0])
1049             continue;
1050
1051           if (!(p = strchr (type, '/')))
1052           {
1053             mutt_error _("Content-Type is of the form base/sub");
1054             continue;
1055           }
1056           *p++ = 0;
1057           if ((itype = mutt_check_mime_type (type)) == TYPEOTHER)
1058           {
1059             mutt_error (_("Unknown Content-Type %s"), type);
1060             continue;
1061           }
1062           if (idxlen == idxmax)
1063           {
1064             safe_realloc (&idx, sizeof (ATTACHPTR *) * (idxmax += 5));
1065             menu->data = idx;
1066           }
1067
1068           idx[idxlen] = (ATTACHPTR *) safe_calloc (1, sizeof (ATTACHPTR));
1069           /* Touch the file */
1070           if (!(fp = safe_fopen (fname, "w")))
1071           {
1072             mutt_error (_("Can't create file %s"), fname);
1073             FREE (&idx[idxlen]);
1074             continue;
1075           }
1076           safe_fclose (&fp);
1077
1078           if ((idx[idxlen]->content = mutt_make_file_attach (fname)) == NULL)
1079           {
1080             mutt_error _("What we have here is a failure to make an attachment");
1081             continue;
1082           }
1083           update_idx (menu, idx, idxlen++);
1084
1085           idx[menu->current]->content->type = itype;
1086           mutt_str_replace (&idx[menu->current]->content->subtype, p);
1087           idx[menu->current]->content->unlink = 1;
1088           menu->redraw |= REDRAW_INDEX | REDRAW_STATUS;
1089
1090           if (mutt_compose_attachment (idx[menu->current]->content))
1091           {
1092             mutt_update_encoding (idx[menu->current]->content);
1093             menu->redraw = REDRAW_FULL;
1094           }
1095         }
1096         mutt_message_hook (NULL, msg, M_SEND2HOOK);    
1097         break;
1098
1099       case OP_COMPOSE_EDIT_MIME:
1100         CHECK_COUNT;
1101         if (mutt_edit_attachment (idx[menu->current]->content))
1102         {
1103           mutt_update_encoding (idx[menu->current]->content);
1104           menu->redraw = REDRAW_FULL;
1105         }
1106         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1107         break;
1108
1109       case OP_VIEW_ATTACH:
1110       case OP_DISPLAY_HEADERS:
1111         CHECK_COUNT;
1112         mutt_attach_display_loop (menu, op, NULL, NULL, NULL, &idx, &idxlen, NULL, 0);
1113         menu->redraw = REDRAW_FULL;
1114         /* no send2hook, since this doesn't modify the message */
1115         break;
1116
1117       case OP_SAVE:
1118         CHECK_COUNT;
1119         mutt_save_attachment_list (NULL, menu->tagprefix, menu->tagprefix ?  msg->content : idx[menu->current]->content, NULL, menu);
1120         MAYBE_REDRAW (menu->redraw);
1121         /* no send2hook, since this doesn't modify the message */
1122         break;
1123
1124       case OP_PRINT:
1125         CHECK_COUNT;
1126         mutt_print_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content);
1127         /* no send2hook, since this doesn't modify the message */
1128         break;
1129
1130       case OP_PIPE:
1131       case OP_FILTER:
1132         CHECK_COUNT;
1133         mutt_pipe_attachment_list (NULL, menu->tagprefix, menu->tagprefix ? msg->content : idx[menu->current]->content, op == OP_FILTER);
1134         if (op == OP_FILTER) /* cte might have changed */
1135           menu->redraw = menu->tagprefix ? REDRAW_FULL : REDRAW_CURRENT;
1136         menu->redraw |= REDRAW_STATUS;
1137         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1138         break;
1139
1140       case OP_EXIT:
1141         if ((i = query_quadoption (OPT_POSTPONE, _("Postpone this message?"))) == M_NO)
1142         {
1143           while (idxlen-- > 0)
1144           {
1145             /* avoid freeing other attachments */
1146             idx[idxlen]->content->next = NULL;
1147             idx[idxlen]->content->parts = NULL;
1148             if (idx[idxlen]->unowned)
1149               idx[idxlen]->content->unlink = 0;
1150             mutt_free_body (&idx[idxlen]->content);
1151             FREE (&idx[idxlen]->tree);
1152             FREE (&idx[idxlen]);
1153           }
1154           FREE (&idx);
1155           idxlen = 0;
1156           idxmax = 0;
1157           r = -1;
1158           loop = 0;
1159           break;
1160         }
1161         else if (i == -1)
1162           break; /* abort */
1163
1164         /* fall through to postpone! */
1165
1166       case OP_COMPOSE_POSTPONE_MESSAGE:
1167
1168         if(check_attachments(idx, idxlen) != 0)
1169         {
1170           menu->redraw = REDRAW_FULL;
1171           break;
1172         }
1173       
1174         loop = 0;
1175         r = 1;
1176         break;
1177
1178       case OP_COMPOSE_ISPELL:
1179         endwin ();
1180         snprintf (buf, sizeof (buf), "%s -x %s", NONULL(Ispell), msg->content->filename);
1181         if (mutt_system (buf) == -1)
1182           mutt_error (_("Error running \"%s\"!"), buf);
1183         else
1184         {
1185           mutt_update_encoding (msg->content);
1186           menu->redraw |= REDRAW_STATUS;
1187         }
1188         break;
1189
1190       case OP_COMPOSE_WRITE_MESSAGE:
1191
1192        fname[0] = '\0';
1193        if (Context)
1194        {
1195          strfcpy (fname, NONULL (Context->path), sizeof (fname));
1196          mutt_pretty_mailbox (fname, sizeof (fname));
1197        }
1198        if (idxlen)
1199          msg->content = idx[0]->content;
1200        if (mutt_enter_fname (_("Write message to mailbox"), fname, sizeof (fname),
1201                              &menu->redraw, 1) != -1 && fname[0])
1202        {
1203          mutt_message (_("Writing message to %s ..."), fname);
1204          mutt_expand_path (fname, sizeof (fname));
1205
1206          if (msg->content->next)
1207            msg->content = mutt_make_multipart (msg->content);
1208
1209          if (mutt_write_fcc (fname, msg, NULL, 1, NULL) < 0)
1210            msg->content = mutt_remove_multipart (msg->content);
1211          else
1212            mutt_message _("Message written.");
1213        }
1214        break;
1215
1216
1217
1218       case OP_COMPOSE_PGP_MENU:
1219         if (!(WithCrypto & APPLICATION_PGP))
1220           break;
1221         if ((WithCrypto & APPLICATION_SMIME)
1222             && msg->security & APPLICATION_SMIME)
1223         {
1224           if (mutt_yesorno (_("S/MIME already selected. Clear & continue ? "),
1225                              M_YES) != M_YES)
1226           {
1227             mutt_clear_error ();
1228             break;
1229           }
1230           msg->security = 0;
1231         }
1232         msg->security = crypt_pgp_send_menu (msg, &menu->redraw);
1233         redraw_crypt_lines (msg);
1234         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1235         break;
1236
1237
1238       case OP_FORGET_PASSPHRASE:
1239         crypt_forget_passphrase ();
1240         break;
1241
1242
1243       case OP_COMPOSE_SMIME_MENU:
1244         if (!(WithCrypto & APPLICATION_SMIME))
1245           break;
1246
1247         if ((WithCrypto & APPLICATION_PGP)
1248             && msg->security & APPLICATION_PGP)
1249         {
1250           if (mutt_yesorno (_("PGP already selected. Clear & continue ? "),
1251                               M_YES) != M_YES)
1252           {
1253              mutt_clear_error ();
1254              break;
1255           }
1256           msg->security = 0;
1257         }
1258         msg->security = crypt_smime_send_menu(msg, &menu->redraw);
1259         redraw_crypt_lines (msg);
1260         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1261         break;
1262
1263
1264 #ifdef MIXMASTER
1265       case OP_COMPOSE_MIX:
1266       
1267         mix_make_chain (&msg->chain, &menu->redraw);
1268         mutt_message_hook (NULL, msg, M_SEND2HOOK);
1269         break;
1270 #endif
1271
1272     }
1273
1274     /* Draw formated compose status line */
1275     if (menu->redraw & REDRAW_STATUS) 
1276     {
1277         compose_status_line (buf, sizeof (buf), 0, menu, NONULL(ComposeFormat));
1278         CLEARLINE (option (OPTSTATUSONTOP) ? 0 : LINES-2);
1279         SETCOLOR (MT_COLOR_STATUS);
1280         BKGDSET (MT_COLOR_STATUS);
1281         mutt_paddstr (COLS, buf);
1282         SETCOLOR (MT_COLOR_NORMAL);
1283         BKGDSET (MT_COLOR_NORMAL);
1284         menu->redraw &= ~REDRAW_STATUS;
1285     }
1286   }
1287
1288   mutt_menuDestroy (&menu);
1289
1290   if (idxlen)
1291   {
1292     msg->content = idx[0]->content;
1293     for (i = 0; i < idxlen; i++)
1294     {
1295       idx[i]->content->aptr = NULL;
1296       FREE (&idx[i]);
1297     }
1298   }
1299   else
1300     msg->content = NULL;
1301
1302   FREE (&idx);
1303
1304   return (r);
1305 }
1306