commands.c

   1 /*
   2  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
   3  * Copyright (C) 2000-4,2006 Thomas Roessler <roessler@does-not-exist.org>
   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_menu.h"
  27 #include "mime.h"
  28 #include "sort.h"
  29 #include "mailbox.h"
  30 #include "copy.h"
  31 #include "mx.h"
  32 #include "pager.h"
  33 #include "mutt_crypt.h"
  34 #include "mutt_idna.h"
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38
  39 #ifdef USE_IMAP
  40 #include "imap.h"
  41 #endif
  42
  43 #include "buffy.h"
  44
  45 #include <errno.h>
  46 #include <unistd.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <sys/wait.h>
  50 #include <sys/stat.h>
  51 #include <sys/types.h>
  52 #include <utime.h>
  53
  54 static const char *ExtPagerProgress = "all";
  55
  56 /* The folder the user last saved to.  Used by ci_save_message() */
  57 static char LastSaveFolder[_POSIX_PATH_MAX] = "";
  58
  59 int mutt_display_message (HEADER *cur)
  60 {
  61   char tempfile[_POSIX_PATH_MAX], buf[LONG_STRING];
  62   int rc = 0, builtin = 0;
  63   int cmflags = M_CM_DECODE | M_CM_DISPLAY | M_CM_CHARCONV;
  64   FILE *fpout = NULL;
  65   FILE *fpfilterout = NULL;
  66   pid_t filterpid = -1;
  67   int res;
  68
  69   snprintf (buf, sizeof (buf), "%s/%s", TYPE (cur->content),
  70             cur->content->subtype);
  71
  72   mutt_parse_mime_message (Context, cur);
  73   mutt_message_hook (Context, cur, M_MESSAGEHOOK);
  74
  75   /* see if crypto is needed for this message.  if so, we should exit curses */
  76   if (WithCrypto && cur->security)
  77   {
  78     if (cur->security & ENCRYPT)
  79     {
  80       if (cur->security & APPLICATION_SMIME)
  81         crypt_smime_getkeys (cur->env);
  82       if(!crypt_valid_passphrase(cur->security))
  83         return 0;
  84
  85       cmflags |= M_CM_VERIFY;
  86     }
  87     else if (cur->security & SIGN)
  88     {
  89       /* find out whether or not the verify signature */
  90       if (query_quadoption (OPT_VERIFYSIG, _("Verify PGP signature?")) == M_YES)
  91       {
  92         cmflags |= M_CM_VERIFY;
  93       }
  94     }
  95   }
  96
  97   if (cmflags & M_CM_VERIFY || cur->security & ENCRYPT)
  98   {
  99     if (cur->security & APPLICATION_PGP)
 100     {
 101       if (cur->env->from)
 102         crypt_pgp_invoke_getkeys (cur->env->from);
 103
 104       crypt_invoke_message (APPLICATION_PGP);
 105     }
 106
 107     if (cur->security & APPLICATION_SMIME)
 108       crypt_invoke_message (APPLICATION_SMIME);
 109   }
 110
 111
 112   mutt_mktemp (tempfile, sizeof (tempfile));
 113   if ((fpout = safe_fopen (tempfile, "w")) == NULL)
 114   {
 115     mutt_error _("Could not create temporary file!");
 116     return (0);
 117   }
 118
 119   if (DisplayFilter && *DisplayFilter)
 120   {
 121     fpfilterout = fpout;
 122     fpout = NULL;
 123     /* mutt_endwin (NULL); */
 124     filterpid = mutt_create_filter_fd (DisplayFilter, &fpout, NULL, NULL,
 125                                        -1, fileno(fpfilterout), -1);
 126     if (filterpid < 0)
 127     {
 128       mutt_error (_("Cannot create display filter"));
 129       safe_fclose (&fpfilterout);
 130       unlink (tempfile);
 131       return 0;
 132     }
 133   }
 134
 135   if (!Pager || mutt_strcmp (Pager, "builtin") == 0)
 136     builtin = 1;
 137   else
 138   {
 139     struct hdr_format_info hfi;
 140     hfi.ctx = Context;
 141     hfi.pager_progress = ExtPagerProgress;
 142     hfi.hdr = cur;
 143     mutt_make_string_info (buf, sizeof (buf), NONULL(PagerFmt), &hfi, M_FORMAT_MAKEPRINT);
 144     fputs (buf, fpout);
 145     fputs ("\n\n", fpout);
 146   }
 147
 148   res = mutt_copy_message (fpout, Context, cur, cmflags,
 149         (option (OPTWEED) ? (CH_WEED | CH_REORDER) : 0) | CH_DECODE | CH_FROM | CH_DISPLAY);
 150   if ((safe_fclose (&fpout) != 0 && errno != EPIPE) || res < 0)
 151   {
 152     mutt_error (_("Could not copy message"));
 153     if (fpfilterout != NULL)
 154     {
 155       mutt_wait_filter (filterpid);
 156       safe_fclose (&fpfilterout);
 157     }
 158     mutt_unlink (tempfile);
 159     return 0;
 160   }
 161
 162   if (fpfilterout != NULL && mutt_wait_filter (filterpid) != 0)
 163     mutt_any_key_to_continue (NULL);
 164
 165   safe_fclose (&fpfilterout);   /* XXX - check result? */
 166
 167
 168   if (WithCrypto)
 169   {
 170     /* update crypto information for this message */
 171     cur->security &= ~(GOODSIGN|BADSIGN);
 172     cur->security |= crypt_query (cur->content);
 173
 174     /* Remove color cache for this message, in case there
 175        are color patterns for both ~g and ~V */
 176     cur->pair = 0;
 177   }
 178
 179   if (builtin)
 180   {
 181     pager_t info;
 182
 183     if (WithCrypto
 184         && (cur->security & APPLICATION_SMIME) && (cmflags & M_CM_VERIFY))
 185     {
 186       if (cur->security & GOODSIGN)
 187       {
 188         if (!crypt_smime_verify_sender(cur))
 189           mutt_message ( _("S/MIME signature successfully verified."));
 190         else
 191           mutt_error ( _("S/MIME certificate owner does not match sender."));
 192       }
 193       else if (cur->security & PARTSIGN)
 194         mutt_message (_("Warning: Part of this message has not been signed."));
 195       else if (cur->security & SIGN || cur->security & BADSIGN)
 196         mutt_error ( _("S/MIME signature could NOT be verified."));
 197     }
 198
 199     if (WithCrypto
 200         && (cur->security & APPLICATION_PGP) && (cmflags & M_CM_VERIFY))
 201     {
 202       if (cur->security & GOODSIGN)
 203         mutt_message (_("PGP signature successfully verified."));
 204       else if (cur->security & PARTSIGN)
 205         mutt_message (_("Warning: Part of this message has not been signed."));
 206       else if (cur->security & SIGN)
 207         mutt_message (_("PGP signature could NOT be verified."));
 208     }
 209
 210     /* Invoke the builtin pager */
 211     memset (&info, 0, sizeof (pager_t));
 212     info.hdr = cur;
 213     info.ctx = Context;
 214     rc = mutt_pager (NULL, tempfile, M_PAGER_MESSAGE, &info);
 215   }
 216   else
 217   {
 218     int r;
 219
 220     mutt_endwin (NULL);
 221     snprintf (buf, sizeof (buf), "%s %s", NONULL(Pager), tempfile);
 222     if ((r = mutt_system (buf)) == -1)
 223       mutt_error (_("Error running \"%s\"!"), buf);
 224     unlink (tempfile);
 225     if (!option (OPTNOCURSES))
 226       keypad (stdscr, TRUE);
 227     if (r != -1)
 228       mutt_set_flag (Context, cur, M_READ, 1);
 229     if (r != -1 && option (OPTPROMPTAFTER))
 230     {
 231       mutt_ungetch (mutt_any_key_to_continue _("Command: "), 0);
 232       rc = km_dokey (MENU_PAGER);
 233     }
 234     else
 235       rc = 0;
 236   }
 237
 238   return rc;
 239 }
 240
 241 void ci_bounce_message (HEADER *h, int *redraw)
 242 {
 243   char prompt[SHORT_STRING];
 244   char scratch[SHORT_STRING];
 245   char buf[HUGE_STRING] = { 0 };
 246   ADDRESS *adr = NULL;
 247   char *err = NULL;
 248   int rc;
 249
 250  /* RfC 5322 mandates a From: header, so warn before bouncing
 251   * messages without one */
 252   if (h)
 253   {
 254     if (!h->env->from)
 255     {
 256       mutt_error _("Warning: message has no From: header");
 257       mutt_sleep (2);
 258     }
 259   }
 260   else if (Context)
 261   {
 262     for (rc = 0; rc < Context->msgcount; rc++)
 263     {
 264       if (Context->hdrs[rc]->tagged && !Context->hdrs[rc]->env->from)
 265       {
 266         mutt_error ("Warning: message has no From: header");
 267         mutt_sleep (2);
 268         break;
 269       }
 270     }
 271   }
 272
 273   if(h)
 274     strfcpy(prompt, _("Bounce message to: "), sizeof(prompt));
 275   else
 276     strfcpy(prompt, _("Bounce tagged messages to: "), sizeof(prompt));
 277
 278   rc = mutt_get_field (prompt, buf, sizeof (buf), M_ALIAS);
 279
 280   if (option (OPTNEEDREDRAW))
 281   {
 282     unset_option (OPTNEEDREDRAW);
 283     *redraw = REDRAW_FULL;
 284   }
 285
 286   if (rc || !buf[0])
 287     return;
 288
 289   if (!(adr = rfc822_parse_adrlist (adr, buf)))
 290   {
 291     mutt_error _("Error parsing address!");
 292     return;
 293   }
 294
 295   adr = mutt_expand_aliases (adr);
 296
 297   if (mutt_addrlist_to_idna (adr, &err) < 0)
 298   {
 299     mutt_error (_("Bad IDN: '%s'"), err);
 300     FREE (&err);
 301     rfc822_free_address (&adr);
 302     return;
 303   }
 304
 305   buf[0] = 0;
 306   rfc822_write_address (buf, sizeof (buf), adr, 1);
 307
 308 #define extra_space (15 + 7 + 2)
 309   snprintf (scratch, sizeof (scratch),
 310            (h ? _("Bounce message to %s") : _("Bounce messages to %s")), buf);
 311
 312   if (mutt_strwidth (prompt) > COLS - extra_space)
 313   {
 314     mutt_format_string (prompt, sizeof (prompt),
 315                         0, COLS-extra_space, FMT_LEFT, 0,
 316                         scratch, sizeof (scratch), 0);
 317     safe_strcat (prompt, sizeof (prompt), "...?");
 318   }
 319   else
 320     snprintf (prompt, sizeof (prompt), "%s?", scratch);
 321
 322   if (query_quadoption (OPT_BOUNCE, prompt) != M_YES)
 323   {
 324     rfc822_free_address (&adr);
 325     CLEARLINE (LINES - 1);
 326     mutt_message (h ? _("Message not bounced.") : _("Messages not bounced."));
 327     return;
 328   }
 329
 330   CLEARLINE (LINES - 1);
 331
 332   rc = mutt_bounce_message (NULL, h, adr);
 333   rfc822_free_address (&adr);
 334   /* If no error, or background, display message. */
 335   if ((rc == 0) || (rc == S_BKG))
 336     mutt_message (h ? _("Message bounced.") : _("Messages bounced."));
 337 }
 338
 339 static void pipe_set_flags (int decode, int print, int *cmflags, int *chflags)
 340 {
 341   if (decode)
 342   {
 343     *cmflags |= M_CM_DECODE | M_CM_CHARCONV;
 344     *chflags |= CH_DECODE | CH_REORDER;
 345
 346     if (option (OPTWEED))
 347     {
 348       *chflags |= CH_WEED;
 349       *cmflags |= M_CM_WEED;
 350     }
 351   }
 352
 353   if (print)
 354     *cmflags |= M_CM_PRINTING;
 355
 356 }
 357
 358 static void pipe_msg (HEADER *h, FILE *fp, int decode, int print)
 359 {
 360   int cmflags = 0;
 361   int chflags = CH_FROM;
 362
 363   pipe_set_flags (decode, print, &cmflags, &chflags);
 364
 365   if (WithCrypto && decode && h->security & ENCRYPT)
 366   {
 367     if(!crypt_valid_passphrase(h->security))
 368       return;
 369     endwin ();
 370   }
 371
 372   if (decode)
 373     mutt_parse_mime_message (Context, h);
 374
 375   mutt_copy_message (fp, Context, h, cmflags, chflags);
 376 }
 377
 378
 379 /* the following code is shared between printing and piping */
 380
 381 static int _mutt_pipe_message (HEADER *h, char *cmd,
 382                                int decode,
 383                                int print,
 384                                int split,
 385                                char *sep)
 386 {
 387
 388   int i, rc = 0;
 389   pid_t thepid;
 390   FILE *fpout;
 391
 392 /*   mutt_endwin (NULL);
 393
 394      is this really needed here ?
 395      it makes the screen flicker on pgp and s/mime messages,
 396      before asking for a passphrase...
 397                                      Oliver Ehli */
 398   if (h)
 399   {
 400
 401     mutt_message_hook (Context, h, M_MESSAGEHOOK);
 402
 403     if (WithCrypto && decode)
 404     {
 405       mutt_parse_mime_message (Context, h);
 406       if(h->security & ENCRYPT && !crypt_valid_passphrase(h->security))
 407         return 1;
 408     }
 409     mutt_endwin (NULL);
 410
 411     if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
 412     {
 413       mutt_perror _("Can't create filter process");
 414       return 1;
 415     }
 416
 417     pipe_msg (h, fpout, decode, print);
 418     safe_fclose (&fpout);
 419     rc = mutt_wait_filter (thepid);
 420   }
 421   else
 422   { /* handle tagged messages */
 423
 424     if (WithCrypto && decode)
 425     {
 426       for (i = 0; i < Context->vcount; i++)
 427         if(Context->hdrs[Context->v2r[i]]->tagged)
 428         {
 429           mutt_message_hook (Context, Context->hdrs[Context->v2r[i]], M_MESSAGEHOOK);
 430           mutt_parse_mime_message(Context, Context->hdrs[Context->v2r[i]]);
 431           if (Context->hdrs[Context->v2r[i]]->security & ENCRYPT &&
 432               !crypt_valid_passphrase(Context->hdrs[Context->v2r[i]]->security))
 433             return 1;
 434         }
 435     }
 436
 437     if (split)
 438     {
 439       for (i = 0; i < Context->vcount; i++)
 440       {
 441         if (Context->hdrs[Context->v2r[i]]->tagged)
 442         {
 443           mutt_message_hook (Context, Context->hdrs[Context->v2r[i]], M_MESSAGEHOOK);
 444           mutt_endwin (NULL);
 445           if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
 446           {
 447             mutt_perror _("Can't create filter process");
 448             return 1;
 449           }
 450           pipe_msg (Context->hdrs[Context->v2r[i]], fpout, decode, print);
 451           /* add the message separator */
 452           if (sep)  fputs (sep, fpout);
 453           safe_fclose (&fpout);
 454           if (mutt_wait_filter (thepid) != 0)
 455             rc = 1;
 456         }
 457       }
 458     }
 459     else
 460     {
 461       mutt_endwin (NULL);
 462       if ((thepid = mutt_create_filter (cmd, &fpout, NULL, NULL)) < 0)
 463       {
 464         mutt_perror _("Can't create filter process");
 465         return 1;
 466       }
 467       for (i = 0; i < Context->vcount; i++)
 468       {
 469         if (Context->hdrs[Context->v2r[i]]->tagged)
 470         {
 471           mutt_message_hook (Context, Context->hdrs[Context->v2r[i]], M_MESSAGEHOOK);
 472           pipe_msg (Context->hdrs[Context->v2r[i]], fpout, decode, print);
 473           /* add the message separator */
 474           if (sep) fputs (sep, fpout);
 475         }
 476       }
 477       safe_fclose (&fpout);
 478       if (mutt_wait_filter (thepid) != 0)
 479         rc = 1;
 480     }
 481   }
 482
 483   if (rc || option (OPTWAITKEY))
 484     mutt_any_key_to_continue (NULL);
 485   return rc;
 486 }
 487
 488 void mutt_pipe_message (HEADER *h)
 489 {
 490   char buffer[LONG_STRING];
 491
 492   buffer[0] = 0;
 493   if (mutt_get_field (_("Pipe to command: "), buffer, sizeof (buffer), M_CMD)
 494       != 0 || !buffer[0])
 495     return;
 496
 497   mutt_expand_path (buffer, sizeof (buffer));
 498   _mutt_pipe_message (h, buffer,
 499                       option (OPTPIPEDECODE),
 500                       0,
 501                       option (OPTPIPESPLIT),
 502                       PipeSep);
 503 }
 504
 505 void mutt_print_message (HEADER *h)
 506 {
 507
 508   if (quadoption (OPT_PRINT) && (!PrintCmd || !*PrintCmd))
 509   {
 510     mutt_message (_("No printing command has been defined."));
 511     return;
 512   }
 513
 514   if (query_quadoption (OPT_PRINT,
 515                         h ? _("Print message?") : _("Print tagged messages?"))
 516                         != M_YES)
 517     return;
 518
 519   if (_mutt_pipe_message (h, PrintCmd,
 520                           option (OPTPRINTDECODE),
 521                           1,
 522                           option (OPTPRINTSPLIT),
 523                           "\f") == 0)
 524     mutt_message (h ? _("Message printed") : _("Messages printed"));
 525   else
 526     mutt_message (h ? _("Message could not be printed") :
 527                   _("Messages could not be printed"));
 528 }
 529
 530
 531 int mutt_select_sort (int reverse)
 532 {
 533   int method = Sort; /* save the current method in case of abort */
 534
 535   switch (mutt_multi_choice (reverse ?
 536                              _("Rev-Sort (d)ate/(f)rm/(r)ecv/(s)ubj/t(o)/(t)hread/(u)nsort/si(z)e/s(c)ore/s(p)am?: ") :
 537                              _("Sort (d)ate/(f)rm/(r)ecv/(s)ubj/t(o)/(t)hread/(u)nsort/si(z)e/s(c)ore/s(p)am?: "),
 538                              _("dfrsotuzcp")))
 539   {
 540   case -1: /* abort - don't resort */
 541     return -1;
 542
 543   case 1: /* (d)ate */
 544     Sort = SORT_DATE;
 545     break;
 546
 547   case 2: /* (f)rm */
 548     Sort = SORT_FROM;
 549     break;
 550
 551   case 3: /* (r)ecv */
 552     Sort = SORT_RECEIVED;
 553     break;
 554
 555   case 4: /* (s)ubj */
 556     Sort = SORT_SUBJECT;
 557     break;
 558
 559   case 5: /* t(o) */
 560     Sort = SORT_TO;
 561     break;
 562
 563   case 6: /* (t)hread */
 564     Sort = SORT_THREADS;
 565     break;
 566
 567   case 7: /* (u)nsort */
 568     Sort = SORT_ORDER;
 569     break;
 570
 571   case 8: /* si(z)e */
 572     Sort = SORT_SIZE;
 573     break;
 574
 575   case 9: /* s(c)ore */
 576     Sort = SORT_SCORE;
 577     break;
 578
 579   case 10: /* s(p)am */
 580     Sort = SORT_SPAM;
 581     break;
 582   }
 583   if (reverse)
 584     Sort |= SORT_REVERSE;
 585
 586   return (Sort != method ? 0 : -1); /* no need to resort if it's the same */
 587 }
 588
 589 /* invoke a command in a subshell */
 590 void mutt_shell_escape (void)
 591 {
 592   char buf[LONG_STRING];
 593
 594   buf[0] = 0;
 595   if (mutt_get_field (_("Shell command: "), buf, sizeof (buf), M_CMD) == 0)
 596   {
 597     if (!buf[0] && Shell)
 598       strfcpy (buf, Shell, sizeof (buf));
 599     if(buf[0])
 600     {
 601       CLEARLINE (LINES-1);
 602       mutt_endwin (NULL);
 603       fflush (stdout);
 604       if (mutt_system (buf) != 0 || option (OPTWAITKEY))
 605         mutt_any_key_to_continue (NULL);
 606     }
 607   }
 608 }
 609
 610 /* enter a mutt command */
 611 void mutt_enter_command (void)
 612 {
 613   BUFFER err, token;
 614   char buffer[LONG_STRING], errbuf[LONG_STRING];
 615   int r;
 616
 617   buffer[0] = 0;
 618   if (mutt_get_field (":", buffer, sizeof (buffer), M_COMMAND) != 0 || !buffer[0])
 619     return;
 620   err.data = errbuf;
 621   err.dsize = sizeof (errbuf);
 622   memset (&token, 0, sizeof (token));
 623   r = mutt_parse_rc_line (buffer, &token, &err);
 624   FREE (&token.data);
 625   if (errbuf[0])
 626   {
 627     /* since errbuf could potentially contain printf() sequences in it,
 628        we must call mutt_error() in this fashion so that vsprintf()
 629        doesn't expect more arguments that we passed */
 630     if (r == 0)
 631       mutt_message ("%s", errbuf);
 632     else
 633       mutt_error ("%s", errbuf);
 634   }
 635 }
 636
 637 void mutt_display_address (ENVELOPE *env)
 638 {
 639   char *pfx = NULL;
 640   char buf[SHORT_STRING];
 641   ADDRESS *adr = NULL;
 642
 643   adr = mutt_get_address (env, &pfx);
 644
 645   if (!adr) return;
 646
 647   /*
 648    * Note: We don't convert IDNA to local representation this time.
 649    * That is intentional, so the user has an opportunity to copy &
 650    * paste the on-the-wire form of the address to other, IDN-unable
 651    * software.
 652    */
 653
 654   buf[0] = 0;
 655   rfc822_write_address (buf, sizeof (buf), adr, 0);
 656   mutt_message ("%s: %s", pfx, buf);
 657 }
 658
 659 static void set_copy_flags (HEADER *hdr, int decode, int decrypt, int *cmflags, int *chflags)
 660 {
 661   *cmflags = 0;
 662   *chflags = CH_UPDATE_LEN;
 663
 664   if (WithCrypto && !decode && decrypt && (hdr->security & ENCRYPT))
 665   {
 666     if ((WithCrypto & APPLICATION_PGP)
 667         && mutt_is_multipart_encrypted(hdr->content))
 668     {
 669       *chflags = CH_NONEWLINE | CH_XMIT | CH_MIME;
 670       *cmflags = M_CM_DECODE_PGP;
 671     }
 672     else if ((WithCrypto & APPLICATION_PGP)
 673               && mutt_is_application_pgp (hdr->content) & ENCRYPT)
 674       decode = 1;
 675     else if ((WithCrypto & APPLICATION_SMIME)
 676              && mutt_is_application_smime(hdr->content) & ENCRYPT)
 677     {
 678       *chflags = CH_NONEWLINE | CH_XMIT | CH_MIME;
 679       *cmflags = M_CM_DECODE_SMIME;
 680     }
 681   }
 682
 683   if (decode)
 684   {
 685     *chflags = CH_XMIT | CH_MIME | CH_TXTPLAIN;
 686     *cmflags = M_CM_DECODE | M_CM_CHARCONV;
 687
 688     if (!decrypt)       /* If decode doesn't kick in for decrypt, */
 689     {
 690       *chflags |= CH_DECODE;    /* then decode RFC 2047 headers, */
 691
 692       if (option (OPTWEED))
 693       {
 694         *chflags |= CH_WEED;    /* and respect $weed. */
 695         *cmflags |= M_CM_WEED;
 696       }
 697     }
 698   }
 699 }
 700
 701 int _mutt_save_message (HEADER *h, CONTEXT *ctx, int delete, int decode, int decrypt)
 702 {
 703   int cmflags, chflags;
 704   int rc;
 705
 706   set_copy_flags (h, decode, decrypt, &cmflags, &chflags);
 707
 708   if (decode || decrypt)
 709     mutt_parse_mime_message (Context, h);
 710
 711   if ((rc = mutt_append_message (ctx, Context, h, cmflags, chflags)) != 0)
 712     return rc;
 713
 714   if (delete)
 715   {
 716     mutt_set_flag (Context, h, M_DELETE, 1);
 717     if (option (OPTDELETEUNTAG))
 718       mutt_set_flag (Context, h, M_TAG, 0);
 719   }
 720
 721   return 0;
 722 }
 723
 724 /* returns 0 if the copy/save was successful, or -1 on error/abort */
 725 int mutt_save_message (HEADER *h, int delete,
 726                        int decode, int decrypt, int *redraw)
 727 {
 728   int i, need_buffy_cleanup;
 729   int need_passphrase = 0, app=0;
 730   char prompt[SHORT_STRING], buf[_POSIX_PATH_MAX];
 731   CONTEXT ctx;
 732   struct stat st;
 733
 734   *redraw = 0;
 735
 736
 737   snprintf (prompt, sizeof (prompt),
 738             decode  ? (delete ? _("Decode-save%s to mailbox") :
 739                        _("Decode-copy%s to mailbox")) :
 740             (decrypt ? (delete ? _("Decrypt-save%s to mailbox") :
 741                         _("Decrypt-copy%s to mailbox")) :
 742              (delete ? _("Save%s to mailbox") : _("Copy%s to mailbox"))),
 743             h ? "" : _(" tagged"));
 744
 745
 746   if (h)
 747   {
 748     if (WithCrypto)
 749     {
 750       need_passphrase = h->security & ENCRYPT;
 751       app = h->security;
 752     }
 753     mutt_message_hook (Context, h, M_MESSAGEHOOK);
 754     mutt_default_save (buf, sizeof (buf), h);
 755   }
 756   else
 757   {
 758     /* look for the first tagged message */
 759
 760     for (i = 0; i < Context->vcount; i++)
 761     {
 762       if (Context->hdrs[Context->v2r[i]]->tagged)
 763       {
 764         h = Context->hdrs[Context->v2r[i]];
 765         break;
 766       }
 767     }
 768
 769
 770     if (h)
 771     {
 772       mutt_message_hook (Context, h, M_MESSAGEHOOK);
 773       mutt_default_save (buf, sizeof (buf), h);
 774       if (WithCrypto)
 775       {
 776         need_passphrase = h->security & ENCRYPT;
 777         app = h->security;
 778       }
 779       h = NULL;
 780     }
 781   }
 782
 783   mutt_pretty_mailbox (buf, sizeof (buf));
 784   if (mutt_enter_fname (prompt, buf, sizeof (buf), redraw, 0) == -1)
 785     return (-1);
 786
 787   if (*redraw != REDRAW_FULL)
 788   {
 789     if (!h)
 790       *redraw = REDRAW_INDEX | REDRAW_STATUS;
 791     else
 792       *redraw = REDRAW_STATUS;
 793   }
 794
 795   if (!buf[0])
 796     return (-1);
 797
 798   /* This is an undocumented feature of ELM pointed out to me by Felix von
 799    * Leitner <leitner@prz.fu-berlin.de>
 800    */
 801   if (mutt_strcmp (buf, ".") == 0)
 802     strfcpy (buf, LastSaveFolder, sizeof (buf));
 803   else
 804     strfcpy (LastSaveFolder, buf, sizeof (LastSaveFolder));
 805
 806   mutt_expand_path (buf, sizeof (buf));
 807
 808   /* check to make sure that this file is really the one the user wants */
 809   if (mutt_save_confirm (buf, &st) != 0)
 810     return -1;
 811
 812   if (WithCrypto && need_passphrase && (decode || decrypt)
 813       && !crypt_valid_passphrase(app))
 814     return -1;
 815
 816   mutt_message (_("Copying to %s..."), buf);
 817
 818 #ifdef USE_IMAP
 819   if (Context->magic == M_IMAP &&
 820       !(decode || decrypt) && mx_is_imap (buf))
 821   {
 822     switch (imap_copy_messages (Context, h, buf, delete))
 823     {
 824       /* success */
 825       case 0: mutt_clear_error (); return 0;
 826       /* non-fatal error: fall through to fetch/append */
 827       case 1: break;
 828       /* fatal error, abort */
 829       case -1: return -1;
 830     }
 831   }
 832 #endif
 833
 834   if (mx_open_mailbox (buf, M_APPEND, &ctx) != NULL)
 835   {
 836     if (h)
 837     {
 838       if (_mutt_save_message(h, &ctx, delete, decode, decrypt) != 0)
 839       {
 840         mx_close_mailbox (&ctx, NULL);
 841         return -1;
 842       }
 843     }
 844     else
 845     {
 846       for (i = 0; i < Context->vcount; i++)
 847       {
 848         if (Context->hdrs[Context->v2r[i]]->tagged)
 849         {
 850           mutt_message_hook (Context, Context->hdrs[Context->v2r[i]], M_MESSAGEHOOK);
 851           if (_mutt_save_message(Context->hdrs[Context->v2r[i]],
 852                              &ctx, delete, decode, decrypt) != 0)
 853           {
 854             mx_close_mailbox (&ctx, NULL);
 855             return -1;
 856           }
 857         }
 858       }
 859     }
 860
 861     need_buffy_cleanup = (ctx.magic == M_MBOX || ctx.magic == M_MMDF);
 862
 863     mx_close_mailbox (&ctx, NULL);
 864
 865     if (need_buffy_cleanup)
 866       mutt_buffy_cleanup (buf, &st);
 867
 868     mutt_clear_error ();
 869     return (0);
 870   }
 871
 872   return -1;
 873 }
 874
 875
 876 void mutt_version (void)
 877 {
 878   mutt_message ("Mutt %s (%s)", MUTT_VERSION, ReleaseDate);
 879 }
 880
 881 void mutt_edit_content_type (HEADER *h, BODY *b, FILE *fp)
 882 {
 883   char buf[LONG_STRING];
 884   char obuf[LONG_STRING];
 885   char tmp[STRING];
 886   PARAMETER *p;
 887
 888   char charset[STRING];
 889   char *cp;
 890
 891   short charset_changed = 0;
 892   short type_changed = 0;
 893
 894   cp = mutt_get_parameter ("charset", b->parameter);
 895   strfcpy (charset, NONULL (cp), sizeof (charset));
 896
 897   snprintf (buf, sizeof (buf), "%s/%s", TYPE (b), b->subtype);
 898   strfcpy (obuf, buf, sizeof (obuf));
 899   if (b->parameter)
 900   {
 901     size_t l;
 902
 903     for (p = b->parameter; p; p = p->next)
 904     {
 905       l = strlen (buf);
 906
 907       rfc822_cat (tmp, sizeof (tmp), p->value, MimeSpecials);
 908       snprintf (buf + l, sizeof (buf) - l, "; %s=%s", p->attribute, tmp);
 909     }
 910   }
 911
 912   if (mutt_get_field ("Content-Type: ", buf, sizeof (buf), 0) != 0 ||
 913       buf[0] == 0)
 914     return;
 915
 916   /* clean up previous junk */
 917   mutt_free_parameter (&b->parameter);
 918   FREE (&b->subtype);
 919
 920   mutt_parse_content_type (buf, b);
 921
 922
 923   snprintf (tmp, sizeof (tmp), "%s/%s", TYPE (b), NONULL (b->subtype));
 924   type_changed = ascii_strcasecmp (tmp, obuf);
 925   charset_changed = ascii_strcasecmp (charset, mutt_get_parameter ("charset", b->parameter));
 926
 927   /* if in send mode, check for conversion - current setting is default. */
 928
 929   if (!h && b->type == TYPETEXT && charset_changed)
 930   {
 931     int r;
 932     snprintf (tmp, sizeof (tmp), _("Convert to %s upon sending?"),
 933               mutt_get_parameter ("charset", b->parameter));
 934     if ((r = mutt_yesorno (tmp, !b->noconv)) != -1)
 935       b->noconv = (r == M_NO);
 936   }
 937
 938   /* inform the user */
 939
 940   snprintf (tmp, sizeof (tmp), "%s/%s", TYPE (b), NONULL (b->subtype));
 941   if (type_changed)
 942     mutt_message (_("Content-Type changed to %s."), tmp);
 943   if (b->type == TYPETEXT && charset_changed)
 944   {
 945     if (type_changed)
 946       mutt_sleep (1);
 947     mutt_message (_("Character set changed to %s; %s."),
 948                   mutt_get_parameter ("charset", b->parameter),
 949                   b->noconv ? _("not converting") : _("converting"));
 950   }
 951
 952   b->force_charset |= charset_changed ? 1 : 0;
 953
 954   if (!is_multipart (b) && b->parts)
 955     mutt_free_body (&b->parts);
 956   if (!mutt_is_message_type (b->type, b->subtype) && b->hdr)
 957   {
 958     b->hdr->content = NULL;
 959     mutt_free_header (&b->hdr);
 960   }
 961
 962   if (fp && (is_multipart (b) || mutt_is_message_type (b->type, b->subtype)))
 963     mutt_parse_part (fp, b);
 964
 965   if (WithCrypto && h)
 966   {
 967     if (h->content == b)
 968       h->security  = 0;
 969
 970     h->security |= crypt_query (b);
 971   }
 972 }
 973
 974
 975 static int _mutt_check_traditional_pgp (HEADER *h, int *redraw)
 976 {
 977   MESSAGE *msg;
 978   int rv = 0;
 979
 980   h->security |= PGP_TRADITIONAL_CHECKED;
 981
 982   mutt_parse_mime_message (Context, h);
 983   if ((msg = mx_open_message (Context, h->msgno)) == NULL)
 984     return 0;
 985   if (crypt_pgp_check_traditional (msg->fp, h->content, 0))
 986   {
 987     h->security = crypt_query (h->content);
 988     *redraw |= REDRAW_FULL;
 989     rv = 1;
 990   }
 991
 992   h->security |= PGP_TRADITIONAL_CHECKED;
 993   mx_close_message (&msg);
 994   return rv;
 995 }
 996
 997 int mutt_check_traditional_pgp (HEADER *h, int *redraw)
 998 {
 999   int i;
1000   int rv = 0;
1001   if (h && !(h->security & PGP_TRADITIONAL_CHECKED))
1002     rv = _mutt_check_traditional_pgp (h, redraw);
1003   else
1004   {
1005     for (i = 0; i < Context->vcount; i++)
1006       if (Context->hdrs[Context->v2r[i]]->tagged &&
1007           !(Context->hdrs[Context->v2r[i]]->security & PGP_TRADITIONAL_CHECKED))
1008         rv = _mutt_check_traditional_pgp (Context->hdrs[Context->v2r[i]], redraw)
1009           || rv;
1010   }
1011   return rv;
1012 }
1013
1014