postpone.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1996-2002 Michael R. Elkins <me@mutt.org>
   4  * Copyright (C) 1999-2000 Thomas Roessler <roessler@does-not-exist.org>
   5  *
   6  * This file is part of mutt-ng, see http://www.muttng.org/.
   7  * It's licensed under the GNU General Public License,
   8  * please see the file GPL in the top level source directory.
   9  */
  10
  11 #include <lib-lib/lib-lib.h>
  12
  13 #include <lib-mime/mime.h>
  14
  15 #include <lib-ui/lib-ui.h>
  16 #include <lib-ui/menu.h>
  17 #include <lib-mx/mx.h>
  18
  19 #include <lib-sys/unix.h>
  20
  21 #include "mutt.h"
  22 #include "handler.h"
  23 #include "sort.h"
  24 #include "thread.h"
  25 #include "crypt.h"
  26
  27 #include <imap/imap.h>
  28
  29 static short PostCount = 0;
  30 static CONTEXT *PostContext = NULL;
  31 static short UpdateNumPostponed = 0;
  32
  33 /* Return the number of postponed messages.
  34  * if force is 0, use a cached value if it is costly to get a fresh
  35  * count (IMAP) - else check.
  36  */
  37 int mutt_num_postponed (int force)
  38 {
  39   struct stat st;
  40   CONTEXT ctx;
  41
  42   static time_t LastModify = 0;
  43   static char *OldPostponed = NULL;
  44
  45   if (UpdateNumPostponed) {
  46     UpdateNumPostponed = 0;
  47     force = 1;
  48   }
  49
  50   if (Postponed != OldPostponed) {
  51     OldPostponed = Postponed;
  52     LastModify = 0;
  53     force = 1;
  54   }
  55
  56   if (!Postponed)
  57     return 0;
  58
  59   /* LastModify is useless for IMAP */
  60   if (imap_mx.mx_is_magic (Postponed, NULL) == M_IMAP) {
  61     if (force) {
  62       short newpc;
  63
  64       newpc = imap_mailbox_check (Postponed, 0);
  65       if (newpc >= 0) {
  66         PostCount = newpc;
  67       }
  68     }
  69     return PostCount;
  70   }
  71
  72   if (stat (Postponed, &st) == -1) {
  73     PostCount = 0;
  74     LastModify = 0;
  75     return 0;
  76   }
  77
  78   if (S_ISDIR (st.st_mode)) {
  79     /* if we have a maildir mailbox, we need to stat the "new" dir */
  80
  81     char buf[_POSIX_PATH_MAX];
  82
  83     snprintf (buf, sizeof (buf), "%s/new", Postponed);
  84     if (access (buf, F_OK) == 0 && stat (buf, &st) == -1) {
  85       PostCount = 0;
  86       LastModify = 0;
  87       return 0;
  88     }
  89   }
  90
  91   if (LastModify < st.st_mtime) {
  92     LastModify = st.st_mtime;
  93
  94     if (access (Postponed, R_OK | F_OK) != 0)
  95       return PostCount = 0;
  96     if (mx_open_mailbox (Postponed, M_NOSORT | M_QUIET, &ctx) == NULL)
  97       PostCount = 0;
  98     else
  99       PostCount = ctx.msgcount;
 100     mx_fastclose_mailbox (&ctx);
 101   }
 102
 103   return PostCount;
 104 }
 105
 106 void mutt_update_num_postponed (void)
 107 {
 108   UpdateNumPostponed = 1;
 109 }
 110
 111 static void post_entry (char *s, ssize_t slen, MUTTMENU * menu, int entry)
 112 {
 113   CONTEXT *ctx = (CONTEXT *)menu->data;
 114   _mutt_make_string(s, slen, NONULL (HdrFmt), ctx, ctx->hdrs[entry], 0);
 115 }
 116
 117 static HEADER *select_msg (void)
 118 {
 119   MUTTMENU *menu;
 120   int i, done = 0, r = -1;
 121   short orig_sort;
 122
 123   menu = mutt_new_menu ();
 124   menu->make_entry = post_entry;
 125   menu->menu = MENU_POST;
 126   menu->max = PostContext->msgcount;
 127   menu->title = _("Postponed Messages");
 128   menu->data = PostContext;
 129
 130   /* The postponed mailbox is setup to have sorting disabled, but the global
 131    * Sort variable may indicate something different.   Sorting has to be
 132    * disabled while the postpone menu is being displayed. */
 133   orig_sort = Sort;
 134   Sort = SORT_ORDER;
 135
 136   while (!done) {
 137     switch (i = mutt_menuLoop (menu)) {
 138     case OP_DELETE:
 139     case OP_UNDELETE:
 140       mutt_set_flag (PostContext, PostContext->hdrs[menu->current], M_DELETE,
 141                      (i == OP_DELETE) ? 1 : 0);
 142       PostCount = PostContext->msgcount - PostContext->deleted;
 143       if (option (OPTRESOLVE) && menu->current < menu->max - 1) {
 144         menu->oldcurrent = menu->current;
 145         menu->current++;
 146         if (menu->current >= menu->top + menu->pagelen) {
 147           menu->top = menu->current;
 148           menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
 149         }
 150         else
 151           menu->redraw |= REDRAW_MOTION_RESYNCH;
 152       }
 153       else
 154         menu->redraw = REDRAW_CURRENT;
 155       break;
 156
 157     case OP_GENERIC_SELECT_ENTRY:
 158       r = menu->current;
 159       done = 1;
 160       break;
 161
 162     case OP_EXIT:
 163       done = 1;
 164       break;
 165     }
 166   }
 167
 168   Sort = orig_sort;
 169   mutt_menuDestroy (&menu);
 170   return r > -1 ? PostContext->hdrs[r] : NULL;
 171 }
 172
 173 /* args:
 174  *      ctx     Context info, used when recalling a message to which
 175  *              we reply.
 176  *      hdr     envelope/attachment info for recalled message
 177  *      cur     if message was a reply, `cur' is set to the message which
 178  *              `hdr' is in reply to
 179  *      fcc     fcc for the recalled message
 180  *      fcclen  max length of fcc
 181  *
 182  * return vals:
 183  *      -1              error/no messages
 184  *      0               normal exit
 185  *      SENDREPLY       recalled message is a reply
 186  */
 187 int mutt_get_postponed (CONTEXT * ctx, HEADER * hdr, HEADER ** cur, char *fcc,
 188                         ssize_t fcclen)
 189 {
 190   HEADER *h;
 191   int code = SENDPOSTPONED;
 192   string_list_t *tmp;
 193   string_list_t *last = NULL;
 194   string_list_t *next;
 195   char *p;
 196   int opt_delete;
 197
 198   if (!Postponed)
 199     return -1;
 200
 201   if ((PostContext = mx_open_mailbox (Postponed, M_NOSORT, NULL)) == NULL) {
 202     PostCount = 0;
 203     mutt_error _("No postponed messages.");
 204
 205     return -1;
 206   }
 207
 208   if (!PostContext->msgcount) {
 209     PostCount = 0;
 210     mx_close_mailbox (PostContext, NULL);
 211     p_delete(&PostContext);
 212     mutt_error _("No postponed messages.");
 213
 214     return -1;
 215   }
 216
 217   if (PostContext->msgcount == 1) {
 218     /* only one message, so just use that one. */
 219     h = PostContext->hdrs[0];
 220   }
 221   else if ((h = select_msg ()) == NULL) {
 222     mx_close_mailbox (PostContext, NULL);
 223     p_delete(&PostContext);
 224     return -1;
 225   }
 226
 227   if (mutt_prepare_template (NULL, PostContext, hdr, h, 0) < 0) {
 228     mx_fastclose_mailbox (PostContext);
 229     p_delete(&PostContext);
 230     return -1;
 231   }
 232
 233   /* finished with this message, so delete it. */
 234   mutt_set_flag (PostContext, h, M_DELETE, 1);
 235
 236   /* and consider it saved, so that it won't be moved to the trash folder */
 237   mutt_set_flag (PostContext, h, M_APPENDED, 1);
 238
 239   /* update the count for the status display */
 240   PostCount = PostContext->msgcount - PostContext->deleted;
 241
 242   /* avoid the "purge deleted messages" prompt */
 243   opt_delete = quadoption (OPT_DELETE);
 244   set_quadoption (OPT_DELETE, M_YES);
 245   mx_close_mailbox (PostContext, NULL);
 246   set_quadoption (OPT_DELETE, opt_delete);
 247
 248   p_delete(&PostContext);
 249
 250   for (tmp = hdr->env->userhdrs; tmp;) {
 251     if (ascii_strncasecmp ("X-Mutt-References:", tmp->data, 18) == 0) {
 252       if (ctx) {
 253         /* if a mailbox is currently open, look to see if the orignal message
 254            the user attempted to reply to is in this mailbox */
 255         p = vskipspaces(tmp->data + 18);
 256         if (!ctx->id_hash)
 257           ctx->id_hash = mutt_make_id_hash (ctx);
 258         *cur = hash_find (ctx->id_hash, p);
 259       }
 260
 261       /* Remove the X-Mutt-References: header field. */
 262       next = tmp->next;
 263       if (last)
 264         last->next = tmp->next;
 265       else
 266         hdr->env->userhdrs = tmp->next;
 267       tmp->next = NULL;
 268       string_list_wipe(&tmp);
 269       tmp = next;
 270       if (*cur)
 271         code |= SENDREPLY;
 272     }
 273     else if (ascii_strncasecmp ("X-Mutt-Fcc:", tmp->data, 11) == 0) {
 274       p = vskipspaces(tmp->data + 11);
 275       m_strcpy(fcc, fcclen, p);
 276       mutt_pretty_mailbox (fcc);
 277
 278       /* remove the X-Mutt-Fcc: header field */
 279       next = tmp->next;
 280       if (last)
 281         last->next = tmp->next;
 282       else
 283         hdr->env->userhdrs = tmp->next;
 284       tmp->next = NULL;
 285       string_list_wipe(&tmp);
 286       tmp = next;
 287     }
 288     else if (m_strncmp("X-Mutt-PGP:", tmp->data, 11) == 0) {
 289       hdr->security = mutt_parse_crypt_hdr (strchr (tmp->data, ':') + 1, 1);
 290       hdr->security |= APPLICATION_PGP;
 291
 292       /* remove the pgp field */
 293       next = tmp->next;
 294       if (last)
 295         last->next = tmp->next;
 296       else
 297         hdr->env->userhdrs = tmp->next;
 298       tmp->next = NULL;
 299       string_list_wipe(&tmp);
 300       tmp = next;
 301     }
 302     else if (m_strncmp("X-Mutt-SMIME:", tmp->data, 13) == 0) {
 303       hdr->security = mutt_parse_crypt_hdr (strchr (tmp->data, ':') + 1, 1);
 304       hdr->security |= APPLICATION_SMIME;
 305
 306       /* remove the smime field */
 307       next = tmp->next;
 308       if (last)
 309         last->next = tmp->next;
 310       else
 311         hdr->env->userhdrs = tmp->next;
 312       tmp->next = NULL;
 313       string_list_wipe(&tmp);
 314       tmp = next;
 315     }
 316     else {
 317       last = tmp;
 318       tmp = tmp->next;
 319     }
 320   }
 321   return code;
 322 }
 323
 324 int mutt_parse_crypt_hdr (char *p, int set_signas)
 325 {
 326   int pgp = 0;
 327   char pgp_sign_as[LONG_STRING] = "\0", *q;
 328   char smime_cryptalg[LONG_STRING] = "\0";
 329
 330   for (p = vskipspaces(p); *p; p++) {
 331     switch (*p) {
 332     case 'e':
 333     case 'E':
 334       pgp |= ENCRYPT;
 335       break;
 336
 337     case 's':
 338     case 'S':
 339       pgp |= SIGN;
 340       q = pgp_sign_as;
 341
 342       if (*(p + 1) == '<') {
 343         for (p += 2;
 344              *p && *p != '>' && q < pgp_sign_as + sizeof (pgp_sign_as) - 1;
 345              *q++ = *p++);
 346
 347         if (*p != '>') {
 348           mutt_error _("Illegal PGP header");
 349
 350           return 0;
 351         }
 352       }
 353
 354       *q = '\0';
 355       break;
 356
 357       /* This used to be the micalg parameter.
 358        *
 359        * It's no longer needed, so we just skip the parameter in order
 360        * to be able to recall old messages.
 361        */
 362     case 'm':
 363     case 'M':
 364       if (*(p + 1) == '<') {
 365         for (p += 2; *p && *p != '>'; p++);
 366         if (*p != '>') {
 367           mutt_error _("Illegal PGP header");
 368
 369           return 0;
 370         }
 371       }
 372
 373       break;
 374
 375
 376     case 'c':
 377     case 'C':
 378       q = smime_cryptalg;
 379
 380       if (*(p + 1) == '<') {
 381         for (p += 2;
 382              *p && *p != '>'
 383              && q < smime_cryptalg + sizeof (smime_cryptalg) - 1;
 384              *q++ = *p++);
 385
 386         if (*p != '>') {
 387           mutt_error _("Illegal S/MIME header");
 388
 389           return 0;
 390         }
 391       }
 392
 393       *q = '\0';
 394       break;
 395
 396     case 'i':
 397     case 'I':
 398       pgp |= INLINE;
 399       break;
 400
 401     default:
 402       mutt_error _("Illegal PGP header");
 403       return 0;
 404     }
 405
 406   }
 407
 408   /* the cryptalg field must not be empty */
 409   if (*smime_cryptalg)
 410     m_strreplace(&SmimeCryptAlg, smime_cryptalg);
 411
 412   if (set_signas || *pgp_sign_as)
 413     m_strreplace(&PgpSignAs, pgp_sign_as);
 414
 415   return pgp;
 416 }
 417
 418
 419
 420 int mutt_prepare_template (FILE * fp, CONTEXT * ctx, HEADER * newhdr,
 421                            HEADER * hdr, short weed)
 422 {
 423   MESSAGE *msg = NULL;
 424   char file[_POSIX_PATH_MAX];
 425   BODY *b;
 426   FILE *bfp;
 427
 428   int rv = -1;
 429   STATE s;
 430
 431   p_clear(&s, 1);
 432
 433   if (!fp && (msg = mx_open_message (ctx, hdr->msgno)) == NULL)
 434     return -1;
 435
 436   if (!fp)
 437     fp = msg->fp;
 438
 439   bfp = fp;
 440
 441   /* parse the message header and MIME structure */
 442
 443   fseeko (fp, hdr->offset, 0);
 444   newhdr->offset = hdr->offset;
 445   newhdr->env = mutt_read_rfc822_header (fp, newhdr, 1, weed);
 446   newhdr->content->length = hdr->content->length;
 447   mutt_parse_part (fp, newhdr->content);
 448
 449   p_delete(&newhdr->env->message_id);
 450   p_delete(&newhdr->env->mail_followup_to);        /* really? */
 451
 452   /* decrypt pgp/mime encoded messages */
 453
 454   if ((APPLICATION_PGP | APPLICATION_SMIME) & hdr->security
 455       && mutt_is_multipart_encrypted (newhdr->content))
 456   {
 457     int ccap = (APPLICATION_PGP | APPLICATION_SMIME) & hdr->security;
 458     newhdr->security |= ENCRYPT | ccap;
 459     mutt_message _("Decrypting message...");
 460
 461     if (((ccap & APPLICATION_PGP)
 462          && crypt_pgp_decrypt_mime (fp, &bfp, newhdr->content, &b) == -1)
 463         || ((ccap & APPLICATION_SMIME)
 464             && crypt_smime_decrypt_mime (fp, &bfp, newhdr->content, &b) == -1)
 465         || b == NULL)
 466     {
 467       mx_close_message (&msg);
 468       envelope_delete(&newhdr->env);
 469       body_list_wipe(&newhdr->content);
 470       mutt_error _("Decryption failed.");
 471
 472       return -1;
 473     }
 474
 475     body_list_wipe(&newhdr->content);
 476     newhdr->content = b;
 477
 478     mutt_clear_error ();
 479   }
 480
 481   /*
 482    * remove a potential multipart/signed layer - useful when
 483    * resending messages
 484    */
 485
 486   if (mutt_is_multipart_signed (newhdr->content)) {
 487     newhdr->security |= SIGN;
 488     if (ascii_strcasecmp(parameter_getval(newhdr->content->parameter, "protocol"),
 489                          "application/pgp-signature") == 0)
 490       newhdr->security |= APPLICATION_PGP;
 491     else
 492       newhdr->security |= APPLICATION_SMIME;
 493
 494     /* destroy the signature */
 495     body_list_wipe(&newhdr->content->parts->next);
 496     newhdr->content = mutt_remove_multipart (newhdr->content);
 497   }
 498
 499
 500   /*
 501    * We don't need no primary multipart.
 502    * Note: We _do_ preserve messages!
 503    *
 504    * XXX - we don't handle multipart/alternative in any
 505    * smart way when sending messages.  However, one may
 506    * consider this a feature.
 507    *
 508    */
 509
 510   if (newhdr->content->type == TYPEMULTIPART)
 511     newhdr->content = mutt_remove_multipart (newhdr->content);
 512
 513   s.fpin = bfp;
 514
 515   /* create temporary files for all attachments */
 516   for (b = newhdr->content; b; b = b->next) {
 517
 518     /* what follows is roughly a receive-mode variant of
 519      * mutt_get_tmp_attachment () from muttlib.c
 520      */
 521
 522     file[0] = '\0';
 523     if (b->filename) {
 524       m_strcpy(file, sizeof(file), b->filename);
 525       b->d_filename = m_strdup(b->filename);
 526     }
 527     else {
 528       /* avoid Content-Disposition: header with temporary filename */
 529       b->use_disp = 0;
 530     }
 531
 532     /* set up state flags */
 533
 534     s.flags = 0;
 535
 536     if (b->type == TYPETEXT) {
 537       b->noconv = !ascii_strcasecmp("yes", parameter_getval(b->parameter,
 538                                                             "x-mutt-noconv"));
 539       if (b->noconv)
 540         s.flags |= M_CHARCONV;
 541
 542       parameter_delval(&b->parameter, "x-mutt-noconv");
 543     }
 544
 545     s.fpout = m_tempfile(file, sizeof(file), NONULL(mod_core.tmpdir), file);
 546     if (!s.fpout)
 547       goto bail;
 548
 549     if (mutt_is_application_pgp (b) & (ENCRYPT | SIGN)) {
 550
 551       mutt_body_handler (b, &s);
 552
 553       newhdr->security |= mutt_is_application_pgp (newhdr->content);
 554
 555       b->type = TYPETEXT;
 556       m_strreplace(&b->subtype, "plain");
 557       parameter_delval(&b->parameter, "x-action");
 558     }
 559     else
 560       mutt_decode_attachment (b, &s);
 561
 562     if (m_fclose(&s.fpout) != 0)
 563       goto bail;
 564
 565     m_strreplace(&b->filename, file);
 566     b->unlink = 1;
 567
 568     mutt_stamp_attachment (b);
 569
 570     body_list_wipe(&b->parts);
 571     if (b->hdr)
 572       b->hdr->content = NULL;   /* avoid dangling pointer */
 573   }
 574
 575   /* Fix encryption flags. */
 576
 577   /* No inline if multipart. */
 578   if ((newhdr->security & INLINE) && newhdr->content->next)
 579     newhdr->security &= ~INLINE;
 580
 581   /* Theoretically, both could be set. Take the one the user wants to set by default. */
 582   if ((newhdr->security & APPLICATION_PGP)
 583       && (newhdr->security & APPLICATION_SMIME)) {
 584     if (mod_crypt.smime_is_default)
 585       newhdr->security &= ~APPLICATION_PGP;
 586     else
 587       newhdr->security &= ~APPLICATION_SMIME;
 588   }
 589
 590   rv = 0;
 591
 592 bail:
 593
 594   /* that's it. */
 595   if (bfp != fp)
 596     m_fclose(&bfp);
 597   if (msg)
 598     mx_close_message (&msg);
 599
 600   if (rv == -1) {
 601     envelope_delete(&newhdr->env);
 602     body_list_wipe(&newhdr->content);
 603   }
 604
 605   return rv;
 606 }