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