lib-mx/mx.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-lua/lib-lua.h>
  14 #include <lib-sys/unix.h>
  15 #include <lib-mime/mime.h>
  16 #include <lib-ui/sidebar.h>
  17
  18 #include "mutt.h"
  19 #include "crypt.h"
  20 #include "pattern.h"
  21 #include "mx.h"
  22 #include "mbox.h"
  23 #include "mh.h"
  24 #include "sort.h"
  25 #include "thread.h"
  26 #include "copy.h"
  27 #include "keymap.h"
  28 #include "compress.h"
  29 #include "score.h"
  30 #include "dotlock.h"
  31
  32 #include <imap/imap.h>
  33 #include "pop.h"
  34 #ifdef USE_NNTP
  35 #include <nntp/nntp.h>
  36 #endif
  37
  38 static mx_t const *mxfmts[] = {
  39     &mbox_mx,
  40     &mh_mx,
  41     &maildir_mx,
  42     &imap_mx,
  43     &pop_mx,
  44 #ifdef USE_NNTP
  45     &nntp_mx,
  46 #endif
  47     &compress_mx,
  48 };
  49
  50 #define MX_IDX(idx)          (idx >= 0 && idx < countof(mxfmts))
  51 #define mutt_is_spool(s)     (m_strcmp(Spoolfile, s) == 0)
  52
  53 /* parameters:
  54  * path - file to lock
  55  * retry - should retry if unable to lock?
  56  */
  57 static int invoke_dotlock (const char *path, int flags, int retry)
  58 {
  59   char cmd[LONG_STRING + _POSIX_PATH_MAX];
  60   char f[STRING + _POSIX_PATH_MAX];
  61   char r[STRING];
  62
  63   if (flags & DL_FL_RETRY)
  64     snprintf (r, sizeof (r), "-r %d ", retry ? MAXLOCKATTEMPT : 0);
  65
  66   mutt_quote_filename (f, sizeof (f), path);
  67
  68   snprintf(cmd, sizeof(cmd), "%s %s%s%s%s%s%s%s",
  69            mod_core.dotlock,
  70            flags & DL_FL_TRY ? "-t " : "",
  71            flags & DL_FL_UNLOCK ? "-u " : "",
  72            flags & DL_FL_USEPRIV ? "-p " : "",
  73            flags & DL_FL_FORCE ? "-f " : "",
  74            flags & DL_FL_UNLINK ? "-d " : "",
  75            flags & DL_FL_RETRY ? r : "", f);
  76
  77   return mutt_system (cmd);
  78 }
  79
  80 static int dotlock_file (const char *path, int retry)
  81 {
  82   int r;
  83   int flags = DL_FL_USEPRIV | DL_FL_RETRY;
  84
  85   if (retry)
  86     retry = 1;
  87
  88 retry_lock:
  89   if ((r = invoke_dotlock (path, flags, retry)) == DL_EX_EXIST) {
  90     if (!option (OPTNOCURSES)) {
  91       char msg[LONG_STRING];
  92
  93       snprintf (msg, sizeof (msg),
  94                 _("Lock count exceeded, remove lock for %s?"), path);
  95       if (retry && mutt_yesorno (msg, M_YES) == M_YES) {
  96         flags |= DL_FL_FORCE;
  97         retry--;
  98         mutt_clear_error ();
  99         goto retry_lock;
 100       }
 101     }
 102     else {
 103       mutt_error (_("Can't dotlock %s.\n"), path);
 104     }
 105   }
 106   return (r == DL_EX_OK ? 0 : -1);
 107 }
 108
 109 static int undotlock_file (const char *path)
 110 {
 111   return (invoke_dotlock (path,  DL_FL_USEPRIV | DL_FL_UNLOCK, 0) ==
 112           DL_EX_OK ? 0 : -1);
 113 }
 114
 115 /* looks up index of type for path in mxfmts */
 116 static int mx_get_idx (const char* path) {
 117     int i = 0, t = 0;
 118     struct stat st;
 119
 120     /* first, test all non-local folders to avoid stat() call */
 121     for (i = 0; i < countof(mxfmts); i++) {
 122         if (!mxfmts[i]->local)
 123             t = mxfmts[i]->mx_is_magic(path, NULL);
 124         if (t >= 1)
 125             return (t-1);
 126     }
 127     if (stat (path, &st) == 0) {
 128         /* if stat() succeeded, keep testing until success and
 129          * pass stat() info so that we only need to do it once */
 130         for (i = 0; i < countof(mxfmts); i++) {
 131             if (mxfmts[i]->local)
 132                 t = mxfmts[i]->mx_is_magic(path, &st);
 133             if (t >= 1)
 134                 return (t-1);
 135         }
 136     }
 137     return (-1);
 138 }
 139
 140 /* Args:
 141  *      excl            if excl != 0, request an exclusive lock
 142  *      dot             if dot != 0, try to dotlock the file
 143  *      time_out        should retry locking?
 144  */
 145 int mx_lock_file (const char *path, int fd, int excl, int dot, int time_out)
 146 {
 147 #if defined (USE_FCNTL) || defined (USE_FLOCK)
 148     int count;
 149     int attempt;
 150     struct stat prev_sb;
 151 #endif
 152     int r = 0;
 153
 154 #ifdef USE_FCNTL
 155     struct flock lck;
 156
 157
 158     p_clear(&lck, 1);
 159     lck.l_type = excl ? F_WRLCK : F_RDLCK;
 160     lck.l_whence = SEEK_SET;
 161
 162     count = 0;
 163     attempt = 0;
 164     prev_sb.st_size = 0;
 165     while (fcntl (fd, F_SETLK, &lck) == -1) {
 166         struct stat sb;
 167
 168         if (errno != EAGAIN && errno != EACCES) {
 169             mutt_perror ("fcntl");
 170             return (-1);
 171         }
 172
 173         if (fstat (fd, &sb) != 0)
 174             sb.st_size = 0;
 175
 176         if (count == 0)
 177             prev_sb = sb;
 178
 179         /* only unlock file if it is unchanged */
 180         if (prev_sb.st_size == sb.st_size
 181             && ++count >= (time_out ? MAXLOCKATTEMPT : 0)) {
 182             if (time_out)
 183                 mutt_error _("Timeout exceeded while attempting fcntl lock!");
 184
 185             return (-1);
 186         }
 187
 188         prev_sb = sb;
 189
 190         mutt_message (_("Waiting for fcntl lock... %d"), ++attempt);
 191         sleep (1);
 192     }
 193 #endif /* USE_FCNTL */
 194
 195 #ifdef USE_FLOCK
 196     count = 0;
 197     attempt = 0;
 198     while (flock (fd, (excl ? LOCK_EX : LOCK_SH) | LOCK_NB) == -1) {
 199         struct stat sb;
 200
 201         if (errno != EWOULDBLOCK) {
 202             mutt_perror ("flock");
 203             r = -1;
 204             break;
 205         }
 206
 207         if (fstat (fd, &sb) != 0)
 208             sb.st_size = 0;
 209
 210         if (count == 0)
 211             prev_sb = sb;
 212
 213         /* only unlock file if it is unchanged */
 214         if (prev_sb.st_size == sb.st_size
 215             && ++count >= (time_out ? MAXLOCKATTEMPT : 0)) {
 216             if (time_out)
 217                 mutt_error _("Timeout exceeded while attempting flock lock!");
 218
 219             r = -1;
 220             break;
 221         }
 222
 223         prev_sb = sb;
 224
 225         mutt_message (_("Waiting for flock attempt... %d"), ++attempt);
 226         sleep (1);
 227     }
 228 #endif /* USE_FLOCK */
 229
 230     if (r == 0 && dot)
 231         r = dotlock_file (path, time_out);
 232
 233     if (r == -1) {
 234         /* release any other locks obtained in this routine */
 235
 236 #ifdef USE_FCNTL
 237         lck.l_type = F_UNLCK;
 238         fcntl (fd, F_SETLK, &lck);
 239 #endif /* USE_FCNTL */
 240
 241 #ifdef USE_FLOCK
 242         flock (fd, LOCK_UN);
 243 #endif /* USE_FLOCK */
 244
 245         return (-1);
 246     }
 247
 248     return 0;
 249 }
 250
 251 int mx_unlock_file (const char *path, int fd, int dot)
 252 {
 253 #ifdef USE_FCNTL
 254     struct flock unlockit;
 255
 256     p_clear(&unlockit, 1);
 257     unlockit.l_type = F_UNLCK;
 258     unlockit.l_whence = SEEK_SET;
 259     fcntl (fd, F_SETLK, &unlockit);
 260 #endif
 261
 262 #ifdef USE_FLOCK
 263     flock (fd, LOCK_UN);
 264 #endif
 265
 266     if (dot)
 267         undotlock_file (path);
 268
 269     return 0;
 270 }
 271
 272 /* try to figure out what type of mailbox ``path'' is */
 273 int mx_get_magic (const char *path) {
 274   int i = 0;
 275
 276   if (m_strlen(path) == 0)
 277     return (-1);
 278   if ((i = mx_get_idx (path)) >= 0)
 279     return (mxfmts[i]->type);
 280   return (-1);
 281 }
 282
 283 int mx_is_local (int m) {
 284   if (!MX_IDX(m))
 285     return (0);
 286   return (mxfmts[m]->local);
 287 }
 288
 289 /*
 290  * set DefaultMagic to the given value
 291  */
 292 int mx_set_magic (const char *s)
 293 {
 294   if (ascii_strcasecmp (s, "mbox") == 0)
 295     DefaultMagic = M_MBOX;
 296   else if (ascii_strcasecmp (s, "mh") == 0)
 297     DefaultMagic = M_MH;
 298   else if (ascii_strcasecmp (s, "maildir") == 0)
 299     DefaultMagic = M_MAILDIR;
 300   else
 301     return (-1);
 302
 303   return 0;
 304 }
 305
 306 /* mx_access: Wrapper for access, checks permissions on a given mailbox.
 307  *   We may be interested in using ACL-style flags at some point, currently
 308  *   we use the normal access() flags. */
 309 int mx_access (const char *path, int flags)
 310 {
 311   int i = 0;
 312
 313   if ((i = mx_get_idx (path)) >= 0 && mxfmts[i]->mx_access)
 314     return (mxfmts[i]->mx_access(path,flags));
 315   return (0);
 316 }
 317
 318 static int mx_open_mailbox_append (CONTEXT * ctx, int flags)
 319 {
 320   struct stat sb;
 321
 322   /* special case for appending to compressed folders -
 323    * even if we can not open them for reading */
 324   if (mutt_can_append_compressed (ctx->path))
 325     mutt_open_append_compressed (ctx);
 326
 327   ctx->append = 1;
 328
 329   if (mx_get_magic (ctx->path) == M_IMAP)
 330     return imap_open_mailbox_append (ctx);
 331
 332   if (stat (ctx->path, &sb) == 0) {
 333     ctx->magic = mx_get_magic (ctx->path);
 334
 335     switch (ctx->magic) {
 336     case 0:
 337       mutt_error (_("%s is not a mailbox."), ctx->path);
 338       /* fall through */
 339     case -1:
 340       return (-1);
 341     }
 342   }
 343   else if (errno == ENOENT) {
 344     ctx->magic = DefaultMagic;
 345
 346     if (ctx->magic == M_MH || ctx->magic == M_MAILDIR) {
 347       char tmp[_POSIX_PATH_MAX];
 348
 349       if (mkdir (ctx->path, S_IRWXU)) {
 350         mutt_perror (ctx->path);
 351         return (-1);
 352       }
 353
 354       if (ctx->magic == M_MAILDIR) {
 355         snprintf (tmp, sizeof (tmp), "%s/cur", ctx->path);
 356         if (mkdir (tmp, S_IRWXU)) {
 357           mutt_perror (tmp);
 358           rmdir (ctx->path);
 359           return (-1);
 360         }
 361
 362         snprintf (tmp, sizeof (tmp), "%s/new", ctx->path);
 363         if (mkdir (tmp, S_IRWXU)) {
 364           mutt_perror (tmp);
 365           snprintf (tmp, sizeof (tmp), "%s/cur", ctx->path);
 366           rmdir (tmp);
 367           rmdir (ctx->path);
 368           return (-1);
 369         }
 370         snprintf (tmp, sizeof (tmp), "%s/tmp", ctx->path);
 371         if (mkdir (tmp, S_IRWXU)) {
 372           mutt_perror (tmp);
 373           snprintf (tmp, sizeof (tmp), "%s/cur", ctx->path);
 374           rmdir (tmp);
 375           snprintf (tmp, sizeof (tmp), "%s/new", ctx->path);
 376           rmdir (tmp);
 377           rmdir (ctx->path);
 378           return (-1);
 379         }
 380       }
 381       else {
 382         int i;
 383
 384         snprintf (tmp, sizeof (tmp), "%s/.mh_sequences", ctx->path);
 385         if ((i = creat (tmp, S_IRWXU)) == -1) {
 386           mutt_perror (tmp);
 387           rmdir (ctx->path);
 388           return (-1);
 389         }
 390         close (i);
 391       }
 392     }
 393   }
 394   else {
 395     mutt_perror (ctx->path);
 396     return (-1);
 397   }
 398
 399   switch (ctx->magic) {
 400   case M_MBOX:
 401     if ((ctx->fp =
 402          safe_fopen (ctx->path, flags & M_NEWFOLDER ? "w" : "a")) == NULL
 403         || mbox_lock_mailbox (ctx, 1, 1) != 0) {
 404       if (!ctx->fp)
 405         mutt_perror (ctx->path);
 406       else {
 407         mutt_error (_("Couldn't lock %s\n"), ctx->path);
 408         m_fclose(&ctx->fp);
 409       }
 410       return (-1);
 411     }
 412     fseeko (ctx->fp, 0, 2);
 413     break;
 414
 415   case M_MH:
 416   case M_MAILDIR:
 417     /* nothing to do */
 418     break;
 419
 420   default:
 421     return (-1);
 422   }
 423
 424   return 0;
 425 }
 426
 427 /*
 428  * open a mailbox and parse it
 429  *
 430  * Args:
 431  *      flags   M_NOSORT        do not sort mailbox
 432  *              M_APPEND        open mailbox for appending
 433  *              M_READONLY      open mailbox in read-only mode
 434  *              M_QUIET         only print error messages
 435  *      ctx     if non-null, context struct to use
 436  */
 437 CONTEXT *mx_open_mailbox (const char *path, int flags, CONTEXT * pctx)
 438 {
 439   CONTEXT *ctx = pctx;
 440   int rc;
 441
 442   if (!ctx)
 443     ctx = p_new(CONTEXT, 1);
 444   p_clear(ctx, 1);
 445   ctx->path = m_strdup(path);
 446
 447   ctx->msgnotreadyet = -1;
 448   ctx->collapsed = 0;
 449
 450   if (flags & M_QUIET)
 451     ctx->quiet = 1;
 452   if (flags & M_READONLY)
 453     ctx->readonly = 1;
 454   if (flags & M_COUNT)
 455     ctx->counting = 1;
 456
 457   if (flags & (M_APPEND | M_NEWFOLDER)) {
 458     if (mx_open_mailbox_append (ctx, flags) != 0) {
 459       mx_fastclose_mailbox (ctx);
 460       if (!pctx)
 461         p_delete(&ctx);
 462       return NULL;
 463     }
 464     return ctx;
 465   }
 466
 467   if (!MX_IDX(ctx->magic-1))
 468     ctx->magic = mx_get_magic (path);
 469
 470   if (ctx->magic == M_COMPRESSED)
 471     mutt_open_read_compressed (ctx);
 472
 473   if (ctx->magic == 0)
 474     mutt_error (_("%s is not a mailbox."), path);
 475
 476   if (ctx->magic == -1)
 477     mutt_perror (path);
 478
 479   if (ctx->magic <= 0) {
 480     mx_fastclose_mailbox (ctx);
 481     if (!pctx)
 482       p_delete(&ctx);
 483     return (NULL);
 484   }
 485
 486   /* if the user has a `push' command in their .muttrc, or in a folder-hook,
 487    * it will cause the progress messages not to be displayed because
 488    * mutt_refresh() will think we are in the middle of a macro.  so set a
 489    * flag to indicate that we should really refresh the screen.
 490    */
 491   set_option (OPTFORCEREFRESH);
 492
 493   if (!ctx->quiet)
 494     mutt_message (_("Reading %s..."), ctx->path);
 495
 496   rc = mxfmts[ctx->magic-1]->mx_open_mailbox(ctx);
 497
 498   if (rc == 0) {
 499     if ((flags & M_NOSORT) == 0) {
 500       /* avoid unnecessary work since the mailbox is completely unthreaded
 501          to begin with */
 502       unset_option (OPTSORTSUBTHREADS);
 503       unset_option (OPTNEEDRESCORE);
 504       mutt_sort_headers (ctx, 1);
 505     }
 506     if (!ctx->quiet)
 507       mutt_clear_error ();
 508   }
 509   else {
 510     mx_fastclose_mailbox (ctx);
 511     if (!pctx)
 512       p_delete(&ctx);
 513   }
 514
 515   unset_option (OPTFORCEREFRESH);
 516   return (ctx);
 517 }
 518
 519 /* free up memory associated with the mailbox context */
 520 void mx_fastclose_mailbox (CONTEXT * ctx)
 521 {
 522   int i;
 523
 524   if (!ctx)
 525     return;
 526
 527   if (MX_IDX(ctx->magic-1) && mxfmts[ctx->magic-1]->mx_fastclose_mailbox)
 528     mxfmts[ctx->magic-1]->mx_fastclose_mailbox(ctx);
 529   if (ctx->subj_hash)
 530     hash_delete (&ctx->subj_hash, NULL);
 531   if (ctx->id_hash)
 532     hash_delete (&ctx->id_hash, NULL);
 533   mutt_clear_threads (ctx);
 534   for (i = 0; i < ctx->msgcount; i++)
 535     header_delete(&ctx->hdrs[i]);
 536   p_delete(&ctx->hdrs);
 537   p_delete(&ctx->v2r);
 538
 539   if (ctx->cinfo)
 540     mutt_fast_close_compressed (ctx);
 541
 542   p_delete(&ctx->path);
 543   p_delete(&ctx->pattern);
 544   pattern_list_wipe(&ctx->limit_pattern);
 545   m_fclose(&ctx->fp);
 546   p_clear(ctx, 1);
 547 }
 548
 549 /* save changes to disk */
 550 static int sync_mailbox (CONTEXT * ctx, int *index_hint)
 551 {
 552   int rc = -1;
 553
 554   if (!ctx->quiet)
 555     mutt_message (_("Writing %s..."), ctx->path);
 556
 557   if (MX_IDX(ctx->magic-1))
 558     /* the 1 is only of interest for IMAP and means EXPUNGE */
 559     rc = mxfmts[ctx->magic-1]->mx_sync_mailbox(ctx,1,index_hint);
 560
 561   if (rc == 0 && ctx->cinfo)
 562     return mutt_sync_compressed (ctx);
 563
 564   return rc;
 565 }
 566
 567 /* move deleted mails to the trash folder */
 568 static int trash_append (CONTEXT * ctx)
 569 {
 570   CONTEXT *ctx_trash;
 571   int i = 0;
 572   struct stat st, stc;
 573
 574   if (!TrashPath || !ctx->deleted ||
 575       (ctx->magic == M_MAILDIR && option (OPTMAILDIRTRASH)))
 576     return 0;
 577
 578   for (; i < ctx->msgcount && (!ctx->hdrs[i]->deleted ||
 579                                ctx->hdrs[i]->appended); i++);
 580   if (i == ctx->msgcount)
 581     return 0;                   /* nothing to be done */
 582
 583   if (mutt_save_confirm (TrashPath, &st) != 0) {
 584     mutt_error _("message(s) not deleted");
 585
 586     return -1;
 587   }
 588
 589   if (lstat (ctx->path, &stc) == 0 && stc.st_ino == st.st_ino
 590       && stc.st_dev == st.st_dev && stc.st_rdev == st.st_rdev)
 591     return 0;                   /* we are in the trash folder: simple sync */
 592
 593   if ((ctx_trash = mx_open_mailbox (TrashPath, M_APPEND, NULL)) != NULL) {
 594     for (i = 0; i < ctx->msgcount; i++)
 595       if (ctx->hdrs[i]->deleted && !ctx->hdrs[i]->appended
 596           && !ctx->hdrs[i]->purged
 597           && mutt_append_message (ctx_trash, ctx, ctx->hdrs[i], 0, 0) == -1) {
 598         mx_close_mailbox (ctx_trash, NULL);
 599         return -1;
 600       }
 601
 602     mx_close_mailbox (ctx_trash, NULL);
 603   }
 604   else {
 605     mutt_error _("Can't open trash folder");
 606
 607     return -1;
 608   }
 609
 610   return 0;
 611 }
 612
 613 /* save changes and close mailbox */
 614 static int _mx_close_mailbox (CONTEXT * ctx, int *index_hint)
 615 {
 616   int i, move_messages = 0, purge = 1, read_msgs = 0;
 617   int check;
 618   int isSpool = 0;
 619   CONTEXT f;
 620   char mbox[_POSIX_PATH_MAX];
 621   char buf[STRING];
 622
 623   if (!ctx)
 624     return 0;
 625
 626   ctx->closing = 1;
 627
 628 #ifdef USE_NNTP
 629   if (ctx->magic == M_NNTP) {
 630     int ret;
 631
 632     ret = nntp_close_mailbox (ctx);
 633     mx_fastclose_mailbox (ctx);
 634     return ret;
 635   }
 636 #endif
 637   if (ctx->readonly || ctx->dontwrite) {
 638     /* mailbox is readonly or we don't want to write */
 639     mx_fastclose_mailbox (ctx);
 640     return 0;
 641   }
 642
 643   if (ctx->append) {
 644     /* mailbox was opened in write-mode */
 645     if (ctx->magic == M_MBOX)
 646       mbox_close_mailbox (ctx);
 647     else
 648       mx_fastclose_mailbox (ctx);
 649     return 0;
 650   }
 651
 652   for (i = 0; i < ctx->msgcount; i++) {
 653     if (!ctx->hdrs[i]->deleted && ctx->hdrs[i]->read
 654         && !(ctx->hdrs[i]->flagged && option (OPTKEEPFLAGGED)))
 655       read_msgs++;
 656   }
 657
 658   if (read_msgs && quadoption (OPT_MOVE) != M_NO) {
 659     char *p;
 660
 661     if ((p = mutt_find_hook (M_MBOXHOOK, ctx->path))) {
 662       isSpool = 1;
 663       m_strcpy(mbox, sizeof(mbox), p);
 664     }
 665     else {
 666       m_strcpy(mbox, sizeof(mbox), NONULL(Inbox));
 667       isSpool = mutt_is_spool (ctx->path) && !mutt_is_spool (mbox);
 668     }
 669     mutt_expand_path (mbox, sizeof (mbox));
 670
 671     if (isSpool) {
 672       snprintf (buf, sizeof (buf), _("Move read messages to %s?"), mbox);
 673       if ((move_messages = query_quadoption (OPT_MOVE, buf)) == -1) {
 674         ctx->closing = 0;
 675         return (-1);
 676       }
 677     }
 678   }
 679
 680   /*
 681    * There is no point in asking whether or not to purge if we are
 682    * just marking messages as "trash".
 683    */
 684   if (ctx->deleted && !(ctx->magic == M_MAILDIR && option (OPTMAILDIRTRASH))) {
 685     snprintf (buf, sizeof (buf), ctx->deleted == 1
 686               ? _("Purge %d deleted message?") :
 687               _("Purge %d deleted messages?"), ctx->deleted);
 688     if ((purge = query_quadoption (OPT_DELETE, buf)) < 0) {
 689       ctx->closing = 0;
 690       return (-1);
 691     }
 692   }
 693
 694   /* IMAP servers manage the OLD flag themselves */
 695   if (ctx->magic != M_IMAP)
 696     if (option (OPTMARKOLD)) {
 697       for (i = 0; i < ctx->msgcount; i++) {
 698         if (!ctx->hdrs[i]->deleted && !ctx->hdrs[i]->old)
 699           mutt_set_flag (ctx, ctx->hdrs[i], M_OLD, 1);
 700       }
 701     }
 702
 703   if (move_messages) {
 704     mutt_message (_("Moving read messages to %s..."), mbox);
 705
 706     /* try to use server-side copy first */
 707     i = 1;
 708
 709     if (ctx->magic == M_IMAP && imap_is_magic (mbox, NULL) == M_IMAP) {
 710       /* tag messages for moving, and clear old tags, if any */
 711       for (i = 0; i < ctx->msgcount; i++)
 712         if (ctx->hdrs[i]->read && !ctx->hdrs[i]->deleted
 713             && !(ctx->hdrs[i]->flagged && option (OPTKEEPFLAGGED)))
 714           ctx->hdrs[i]->tagged = 1;
 715         else
 716           ctx->hdrs[i]->tagged = 0;
 717
 718       i = imap_copy_messages (ctx, NULL, mbox, 1);
 719     }
 720
 721     if (i == 0)                 /* success */
 722       mutt_clear_error ();
 723     else if (i == -1) {         /* horrible error, bail */
 724       ctx->closing = 0;
 725       return -1;
 726     }
 727     else                        /* use regular append-copy mode */
 728     {
 729       if (mx_open_mailbox (mbox, M_APPEND, &f) == NULL) {
 730         ctx->closing = 0;
 731         return -1;
 732       }
 733
 734       for (i = 0; i < ctx->msgcount; i++) {
 735         if (ctx->hdrs[i]->read && !ctx->hdrs[i]->deleted
 736             && !(ctx->hdrs[i]->flagged && option (OPTKEEPFLAGGED))) {
 737           if (mutt_append_message (&f, ctx, ctx->hdrs[i], 0, CH_UPDATE_LEN) ==
 738               0) {
 739             mutt_set_flag (ctx, ctx->hdrs[i], M_DELETE, 1);
 740             mutt_set_flag (ctx, ctx->hdrs[i], M_APPENDED, 1);
 741           }
 742           else {
 743             mx_close_mailbox (&f, NULL);
 744             ctx->closing = 0;
 745             return -1;
 746           }
 747         }
 748       }
 749
 750       mx_close_mailbox (&f, NULL);
 751     }
 752
 753   }
 754   else if (!ctx->changed && ctx->deleted == 0) {
 755     mutt_message _("Mailbox is unchanged.");
 756
 757     mx_fastclose_mailbox (ctx);
 758     return 0;
 759   }
 760
 761   /* copy mails to the trash before expunging */
 762   if (purge && ctx->deleted)
 763     if (trash_append (ctx) != 0) {
 764       ctx->closing = 0;
 765       return -1;
 766     }
 767
 768   /* allow IMAP to preserve the deleted flag across sessions */
 769   if (ctx->magic == M_IMAP) {
 770     if ((check = imap_sync_mailbox (ctx, purge, index_hint)) != 0) {
 771       ctx->closing = 0;
 772       return check;
 773     }
 774   }
 775   else
 776   {
 777     if (!purge) {
 778       for (i = 0; i < ctx->msgcount; i++)
 779         ctx->hdrs[i]->deleted = 0;
 780       ctx->deleted = 0;
 781     }
 782
 783     if (ctx->changed || ctx->deleted) {
 784       if ((check = sync_mailbox (ctx, index_hint)) != 0) {
 785         ctx->closing = 0;
 786         return check;
 787       }
 788     }
 789   }
 790
 791   if (move_messages)
 792     mutt_message (_("%d kept, %d moved, %d deleted."),
 793                   ctx->msgcount - ctx->deleted, read_msgs, ctx->deleted);
 794   else
 795     mutt_message (_("%d kept, %d deleted."),
 796                   ctx->msgcount - ctx->deleted, ctx->deleted);
 797
 798   if (ctx->cinfo && mutt_slow_close_compressed (ctx))
 799     return (-1);
 800
 801   mx_fastclose_mailbox (ctx);
 802
 803   return 0;
 804 }
 805
 806 int mx_close_mailbox (CONTEXT * ctx, int *index_hint) {
 807   int ret = 0;
 808   if (!ctx)
 809     return (0);
 810   ret = _mx_close_mailbox (ctx, index_hint);
 811   sidebar_set_buffystats (ctx);
 812   return (ret);
 813 }
 814
 815 /* update a Context structure's internal tables. */
 816
 817 void mx_update_tables (CONTEXT * ctx, int committing)
 818 {
 819   int i, j;
 820
 821   /* update memory to reflect the new state of the mailbox */
 822   ctx->vcount = 0;
 823   ctx->vsize = 0;
 824   ctx->tagged = 0;
 825   ctx->deleted = 0;
 826   ctx->new = 0;
 827   ctx->unread = 0;
 828   ctx->changed = 0;
 829   ctx->flagged = 0;
 830 #define this_body ctx->hdrs[j]->content
 831   for (i = 0, j = 0; i < ctx->msgcount; i++) {
 832     if ((committing && (!ctx->hdrs[i]->deleted ||
 833                         (ctx->magic == M_MAILDIR
 834                          && option (OPTMAILDIRTRASH)))) || (!committing
 835                                                             && ctx->hdrs[i]->
 836                                                             active)) {
 837       if (i != j) {
 838         ctx->hdrs[j] = ctx->hdrs[i];
 839         ctx->hdrs[i] = NULL;
 840       }
 841       ctx->hdrs[j]->msgno = j;
 842       if (ctx->hdrs[j]->virtual != -1) {
 843         ctx->v2r[ctx->vcount] = j;
 844         ctx->hdrs[j]->virtual = ctx->vcount++;
 845         ctx->vsize += this_body->length + this_body->offset -
 846           this_body->hdr_offset;
 847       }
 848
 849       if (committing)
 850         ctx->hdrs[j]->changed = 0;
 851       else if (ctx->hdrs[j]->changed)
 852         ctx->changed++;
 853
 854       if (!committing
 855           || (ctx->magic == M_MAILDIR && option (OPTMAILDIRTRASH))) {
 856         if (ctx->hdrs[j]->deleted)
 857           ctx->deleted++;
 858       }
 859
 860       if (ctx->hdrs[j]->tagged)
 861         ctx->tagged++;
 862       if (ctx->hdrs[j]->flagged)
 863         ctx->flagged++;
 864       if (!ctx->hdrs[j]->read) {
 865         ctx->unread++;
 866         if (!ctx->hdrs[j]->old)
 867           ctx->new++;
 868       }
 869
 870       j++;
 871     }
 872     else {
 873       if (ctx->magic == M_MH || ctx->magic == M_MAILDIR)
 874         ctx->size -= (ctx->hdrs[i]->content->length +
 875                       ctx->hdrs[i]->content->offset -
 876                       ctx->hdrs[i]->content->hdr_offset);
 877       /* remove message from the hash tables */
 878       if (ctx->subj_hash && ctx->hdrs[i]->env->real_subj)
 879         hash_remove (ctx->subj_hash, ctx->hdrs[i]->env->real_subj,
 880                      ctx->hdrs[i], NULL);
 881       if (ctx->id_hash && ctx->hdrs[i]->env->message_id)
 882         hash_remove (ctx->id_hash, ctx->hdrs[i]->env->message_id,
 883                      ctx->hdrs[i], NULL);
 884       header_delete(&ctx->hdrs[i]);
 885     }
 886   }
 887 #undef this_body
 888   ctx->msgcount = j;
 889
 890   /* update sidebar count */
 891   sidebar_set_buffystats (ctx);
 892 }
 893
 894
 895 /* save changes to mailbox
 896  *
 897  * return values:
 898  *      0               success
 899  *      -1              error
 900  */
 901 static int _mx_sync_mailbox (CONTEXT * ctx, int *index_hint)
 902 {
 903   int rc, i;
 904   int purge = 1;
 905   int msgcount, deleted;
 906
 907   if (ctx->dontwrite) {
 908     char buf[STRING], tmp[STRING];
 909
 910     if (km_expand_key (buf, sizeof (buf),
 911                        km_find_func (MENU_MAIN, OP_TOGGLE_WRITE)))
 912       snprintf (tmp, sizeof (tmp), _(" Press '%s' to toggle write"), buf);
 913     else
 914       m_strcpy(tmp, sizeof(tmp), _("Use 'toggle-write' to re-enable write!"));
 915
 916     mutt_error (_("Mailbox is marked unwritable. %s"), tmp);
 917     return -1;
 918   }
 919   else if (ctx->readonly) {
 920     mutt_error _("Mailbox is read-only.");
 921
 922     return -1;
 923   }
 924
 925   if (!ctx->changed && !ctx->deleted) {
 926     mutt_message _("Mailbox is unchanged.");
 927
 928     return (0);
 929   }
 930
 931   if (ctx->deleted) {
 932     char buf[STRING];
 933
 934     snprintf (buf, sizeof (buf), ctx->deleted == 1
 935               ? _("Purge %d deleted message?") :
 936               _("Purge %d deleted messages?"), ctx->deleted);
 937     if ((purge = query_quadoption (OPT_DELETE, buf)) < 0)
 938       return (-1);
 939     else if (purge == M_NO) {
 940       if (!ctx->changed)
 941         return 0;               /* nothing to do! */
 942       /* let IMAP servers hold on to D flags */
 943       if (ctx->magic != M_IMAP)
 944       {
 945         for (i = 0; i < ctx->msgcount; i++)
 946           ctx->hdrs[i]->deleted = 0;
 947         ctx->deleted = 0;
 948       }
 949     }
 950     else if (ctx->last_tag && ctx->last_tag->deleted)
 951       ctx->last_tag = NULL;     /* reset last tagged msg now useless */
 952   }
 953
 954   /* really only for IMAP - imap_sync_mailbox results in a call to
 955    * mx_update_tables, so ctx->deleted is 0 when it comes back */
 956   msgcount = ctx->msgcount;
 957   deleted = ctx->deleted;
 958
 959   if (purge && ctx->deleted) {
 960     if (trash_append (ctx) == -1)
 961       return -1;
 962   }
 963
 964   if (ctx->magic == M_IMAP)
 965     rc = imap_sync_mailbox (ctx, purge, index_hint);
 966   else
 967     rc = sync_mailbox (ctx, index_hint);
 968   if (rc == 0) {
 969     if (ctx->magic == M_IMAP && !purge)
 970       mutt_message (_("Mailbox checkpointed."));
 971     else
 972       mutt_message (_("%d kept, %d deleted."), msgcount - deleted, deleted);
 973
 974     mutt_sleep (0);
 975
 976     /* if we haven't deleted any messages, we don't need to resort */
 977     /* ... except for certain folder formats which need "unsorted"
 978      * sort order in order to synchronize folders.
 979      *
 980      * MH and maildir are safe.  mbox-style seems to need re-sorting,
 981      * at least with the new threading code.
 982      */
 983     if (purge || (ctx->magic != M_MAILDIR && ctx->magic != M_MH)) {
 984       /* IMAP does this automatically after handling EXPUNGE */
 985       if (ctx->magic != M_IMAP)
 986       {
 987         mx_update_tables (ctx, 1);
 988         mutt_sort_headers (ctx, 1);     /* rethread from scratch */
 989       }
 990     }
 991   }
 992
 993   return (rc);
 994 }
 995
 996 int mx_sync_mailbox (CONTEXT* ctx, int* index_hint) {
 997   int ret = _mx_sync_mailbox (ctx, index_hint);
 998   sidebar_set_buffystats (ctx);
 999   return (ret);
1000 }
1001
1002 /* args:
1003  *      dest    destintation mailbox
1004  *      hdr     message being copied (required for maildir support, because
1005  *              the filename depends on the message flags)
1006  */
1007 MESSAGE *mx_open_new_message (CONTEXT * dest, HEADER * hdr, int flags)
1008 {
1009   MESSAGE *msg;
1010   address_t *p = NULL;
1011
1012   if (!MX_IDX(dest->magic-1)) {
1013     return (NULL);
1014   }
1015
1016   msg = p_new(MESSAGE, 1);
1017   msg->magic = dest->magic;
1018   msg->write = 1;
1019
1020   if (hdr) {
1021     msg->flags.flagged = hdr->flagged;
1022     msg->flags.replied = hdr->replied;
1023     msg->flags.read = hdr->read;
1024     msg->received = hdr->received;
1025   }
1026
1027   if (msg->received == 0)
1028     time (&msg->received);
1029
1030   if (mxfmts[dest->magic-1]->mx_open_new_message(msg, dest, hdr) == 0) {
1031     if (msg->magic == M_MBOX && flags & M_ADD_FROM) {
1032       if (hdr) {
1033         if (hdr->env->return_path)
1034           p = hdr->env->return_path;
1035         else if (hdr->env->sender)
1036           p = hdr->env->sender;
1037         else
1038           p = hdr->env->from;
1039       }
1040
1041       fprintf (msg->fp, "From %s %s", p ? p->mailbox : NONULL(mod_core.username),
1042                ctime (&msg->received));
1043     }
1044   }
1045   else
1046     p_delete(&msg);
1047
1048   return msg;
1049 }
1050
1051 /* check for new mail */
1052 int mx_check_mailbox (CONTEXT * ctx, int *index_hint, int lock) {
1053   if (ctx->cinfo)
1054     return mutt_check_mailbox_compressed (ctx);
1055
1056   if (ctx) {
1057     if (ctx->locked)
1058       lock = 0;
1059     if (MX_IDX(ctx->magic-1) && mxfmts[ctx->magic-1]->mx_check_mailbox)
1060       return (mxfmts[ctx->magic-1]->mx_check_mailbox(ctx, index_hint, lock));
1061   }
1062
1063   return (-1);
1064 }
1065
1066 /* return a stream pointer for a message */
1067 MESSAGE *mx_open_message (CONTEXT * ctx, int msgno)
1068 {
1069   MESSAGE *msg;
1070
1071   msg = p_new(MESSAGE, 1);
1072   switch (msg->magic = ctx->magic) {
1073   case M_MBOX:
1074     msg->fp = ctx->fp;
1075     break;
1076
1077   case M_MH:
1078   case M_MAILDIR:
1079     {
1080       HEADER *cur = ctx->hdrs[msgno];
1081       char path[_POSIX_PATH_MAX];
1082
1083       snprintf (path, sizeof (path), "%s/%s", ctx->path, cur->path);
1084
1085       if ((msg->fp = fopen (path, "r")) == NULL && errno == ENOENT &&
1086           ctx->magic == M_MAILDIR)
1087         msg->fp = maildir_open_find_message (ctx->path, cur->path);
1088
1089       if (msg->fp == NULL) {
1090         mutt_perror (path);
1091         p_delete(&msg);
1092       }
1093     }
1094     break;
1095
1096   case M_IMAP:
1097     {
1098       if (imap_fetch_message (msg, ctx, msgno) != 0)
1099         p_delete(&msg);
1100       break;
1101     }
1102
1103   case M_POP:
1104     {
1105       if (pop_fetch_message (msg, ctx, msgno) != 0)
1106         p_delete(&msg);
1107       break;
1108     }
1109
1110 #ifdef USE_NNTP
1111   case M_NNTP:
1112     {
1113       if (nntp_fetch_message (msg, ctx, msgno) != 0)
1114         p_delete(&msg);
1115       break;
1116     }
1117 #endif /* USE_NNTP */
1118
1119   default:
1120     p_delete(&msg);
1121     break;
1122   }
1123   return (msg);
1124 }
1125
1126 /* commit a message to a folder */
1127
1128 int mx_commit_message (MESSAGE * msg, CONTEXT * ctx) {
1129   if (!(msg->write && ctx->append)) {
1130     return -1;
1131   }
1132   if (!ctx || !MX_IDX(ctx->magic-1) || !mxfmts[ctx->magic-1]->mx_commit_message)
1133     return (-1);
1134   return (mxfmts[ctx->magic-1]->mx_commit_message (msg, ctx));
1135 }
1136
1137 /* close a pointer to a message */
1138 int mx_close_message (MESSAGE ** msg)
1139 {
1140   int r = 0;
1141
1142   if ((*msg)->magic == M_MH || (*msg)->magic == M_MAILDIR
1143       || (*msg)->magic == M_IMAP
1144       || (*msg)->magic == M_POP
1145 #ifdef USE_NNTP
1146       || (*msg)->magic == M_NNTP
1147 #endif
1148     ) {
1149     r = m_fclose(&(*msg)->fp);
1150   }
1151   else
1152     (*msg)->fp = NULL;
1153
1154   if ((*msg)->path) {
1155     unlink ((*msg)->path);
1156     p_delete(&(*msg)->path);
1157   }
1158
1159   p_delete(msg);
1160   return (r);
1161 }
1162
1163 void mx_alloc_memory (CONTEXT * ctx)
1164 {
1165     ctx->hdrmax += 32;
1166
1167     p_realloc(&ctx->hdrs, ctx->hdrmax);
1168     p_realloc(&ctx->v2r, ctx->hdrmax);
1169     p_clear(ctx->hdrs + ctx->msgcount, ctx->hdrmax - ctx->msgcount);
1170     p_clear(ctx->v2r + ctx->msgcount, ctx->hdrmax - ctx->msgcount);
1171 }
1172
1173 /* this routine is called to update the counts in the context structure for
1174  * the last message header parsed.
1175  */
1176 void mx_update_context (CONTEXT * ctx, int new_messages)
1177 {
1178   HEADER *h;
1179   int msgno;
1180
1181   for (msgno = ctx->msgcount - new_messages; msgno < ctx->msgcount; msgno++) {
1182     h = ctx->hdrs[msgno];
1183
1184     /* NOTE: this _must_ be done before the check for mailcap! */
1185     h->security = crypt_query (h->content);
1186
1187     if (!ctx->pattern) {
1188       ctx->v2r[ctx->vcount] = msgno;
1189       h->virtual = ctx->vcount++;
1190     }
1191     else
1192       h->virtual = -1;
1193     h->msgno = msgno;
1194
1195     if (h->env->supersedes) {
1196       HEADER *h2;
1197
1198       if (!ctx->id_hash)
1199         ctx->id_hash = mutt_make_id_hash (ctx);
1200
1201       h2 = hash_find (ctx->id_hash, h->env->supersedes);
1202
1203       /* p_delete(&h->env->supersedes); should I ? */
1204       if (h2) {
1205         h2->superseded = 1;
1206         if (!ctx->counting && mod_score.enable)
1207           mutt_score_message (ctx, h2, 1);
1208       }
1209     }
1210
1211     /* add this message to the hash tables */
1212     if (ctx->id_hash && h->env->message_id)
1213       hash_insert (ctx->id_hash, h->env->message_id, h);
1214     if (!ctx->counting) {
1215       if (ctx->subj_hash && h->env->real_subj)
1216         hash_insert (ctx->subj_hash, h->env->real_subj, h);
1217
1218       if (mod_score.enable)
1219         mutt_score_message (ctx, h, 0);
1220     }
1221
1222     if (h->changed)
1223       ctx->changed = 1;
1224     if (h->flagged)
1225       ctx->flagged++;
1226     if (h->deleted)
1227       ctx->deleted++;
1228     if (!h->read) {
1229       ctx->unread++;
1230       if (!h->old)
1231         ctx->new++;
1232     }
1233   }
1234   /* update sidebar count */
1235   sidebar_set_buffystats (ctx);
1236 }
1237
1238 /*
1239  * Return:
1240  * 1 if the specified mailbox contains 0 messages.
1241  * 0 if the mailbox contains messages
1242  * -1 on error
1243  */
1244 int mx_check_empty (const char *path)
1245 {
1246   int i = 0;
1247   if ((i = mx_get_idx (path)) >= 0 && mxfmts[i]->mx_check_empty)
1248     return (mxfmts[i]->mx_check_empty(path));
1249   errno = EINVAL;
1250   return (-1);
1251 }
1252
1253 int mx_acl_check(CONTEXT *ctx, int flag)
1254 {
1255     if (!mxfmts[ctx->magic-1]->mx_acl_check)
1256         return 1;
1257     return mxfmts[ctx->magic-1]->mx_acl_check(ctx,flag);
1258 }
1259
1260 void mutt_parse_mime_message (CONTEXT * ctx, HEADER * cur)
1261 {
1262   MESSAGE *msg;
1263   int flags = 0;
1264
1265   do {
1266     if (cur->content->type != TYPEMESSAGE
1267         && cur->content->type != TYPEMULTIPART)
1268       break;                     /* nothing to do */
1269
1270     if (cur->content->parts)
1271       break;                     /* The message was parsed earlier. */
1272
1273     if ((msg = mx_open_message (ctx, cur->msgno))) {
1274       mutt_parse_part (msg->fp, cur->content);
1275
1276       cur->security = crypt_query (cur->content);
1277
1278       mx_close_message (&msg);
1279     }
1280   } while (0);
1281   mutt_count_body_parts (cur, flags | M_PARTS_RECOUNT);
1282 }