x-comment-to is useless in mutt, we can Cc: things as it's a *mailer*.
[apps/madmutt.git] / lib-mx / mbox.c
1 /*
2  * Copyright notice from original mutt:
3  * Copyright (C) 1996-2002 Michael R. Elkins <me@mutt.org>
4  *
5  * This file is part of mutt-ng, see http://www.muttng.org/.
6  * It's licensed under the GNU General Public License,
7  * please see the file GPL in the top level source directory.
8  */
9
10 /* This file contains code to parse ``mbox'' style mailboxes */
11
12 #include <lib-lib/lib-lib.h>
13
14 #include <lib-ui/curses.h>
15 #include <lib-sys/mutt_signal.h>
16
17 #include "mutt.h"
18 #include "mx.h"
19 #include "buffy.h"
20 #include "mbox.h"
21 #include "sort.h"
22 #include "thread.h"
23 #include "copy.h"
24 #include "compress.h"
25
26 /* struct used by mutt_sync_mailbox() to store new offsets */
27 struct m_update_t {
28     short valid;
29     off_t hdr;
30     off_t body;
31     long lines;
32     off_t length;
33 };
34
35 static int mbox_open_new_message(MESSAGE *msg, CONTEXT *dest, HEADER *hdr)
36 {
37     msg->fp = dest->fp;
38     return 0;
39 }
40
41 /* prototypes */
42 static int mbox_reopen_mailbox (CONTEXT*, int*);
43
44 /* parameters:
45  * ctx - context to lock
46  * excl - exclusive lock?
47  * retry - should retry if unable to lock?
48  */
49 int mbox_lock_mailbox(CONTEXT *ctx, int excl, int retry)
50 {
51   int r;
52
53   if ((r = mx_lock_file(ctx->path, fileno(ctx->fp), excl, 1, retry)) == 0)
54     ctx->locked = 1;
55   else if (retry && !excl) {
56     ctx->readonly = 1;
57     return 0;
58   }
59
60   return (r);
61 }
62
63 static void mbox_unlock_mailbox (CONTEXT * ctx)
64 {
65   if (ctx->locked) {
66     fflush (ctx->fp);
67
68     mx_unlock_file (ctx->path, fileno (ctx->fp), 1);
69     ctx->locked = 0;
70   }
71 }
72
73 /* Note that this function is also called when new mail is appended to the
74  * currently open folder, and NOT just when the mailbox is initially read.
75  *
76  * NOTE: it is assumed that the mailbox being read has been locked before
77  * this routine gets called.  Strange things could happen if it's not!
78  */
79 static int mbox_parse_mailbox (CONTEXT * ctx)
80 {
81   struct stat sb;
82   char buf[HUGE_STRING], return_path[STRING];
83   HEADER *curhdr;
84   time_t t, tz;
85   int count = 0, lines = 0;
86   off_t loc;
87
88   /* Save information about the folder at the time we opened it. */
89   if (stat (ctx->path, &sb) == -1) {
90     mutt_perror (ctx->path);
91     return (-1);
92   }
93
94   ctx->size = sb.st_size;
95   ctx->mtime = sb.st_mtime;
96
97   if (!ctx->readonly)
98     ctx->readonly = access (ctx->path, W_OK) ? 1 : 0;
99
100   /* precompute the local timezone to speed up calculation of the
101      date received */
102   tz = mutt_local_tz (0);
103
104   loc = ftello (ctx->fp);
105   while (fgets (buf, sizeof (buf), ctx->fp) != NULL) {
106     if (is_from (buf, return_path, sizeof (return_path), &t)) {
107       /* Save the Content-Length of the previous message */
108       if (count > 0) {
109 #define PREV ctx->hdrs[ctx->msgcount-1]
110
111         if (PREV->content->length < 0) {
112           PREV->content->length = loc - PREV->content->offset - 1;
113           if (PREV->content->length < 0)
114             PREV->content->length = 0;
115         }
116         if (!PREV->lines)
117           PREV->lines = lines ? lines - 1 : 0;
118       }
119
120       count++;
121
122       if (!ctx->quiet && ReadInc && ((count % ReadInc == 0) || count == 1))
123         mutt_message (_("Reading %s... %d (%d%%)"), ctx->path, count,
124                       (int) (ftello (ctx->fp) / (ctx->size / 100 + 1)));
125
126       if (ctx->msgcount == ctx->hdrmax)
127         mx_alloc_memory (ctx);
128
129       curhdr = ctx->hdrs[ctx->msgcount] = header_new();
130       curhdr->received = t - tz;
131       curhdr->offset = loc;
132       curhdr->index = ctx->msgcount;
133
134       curhdr->env = mutt_read_rfc822_header (ctx->fp, curhdr, 0, 0);
135
136       /* if we know how long this message is, either just skip over the body,
137        * or if we don't know how many lines there are, count them now (this will
138        * save time by not having to search for the next message marker).
139        */
140       if (curhdr->content->length > 0) {
141         off_t tmploc;
142
143         loc = ftello (ctx->fp);
144         tmploc = loc + curhdr->content->length + 1;
145
146         if (0 < tmploc && tmploc < ctx->size) {
147           /*
148            * check to see if the content-length looks valid.  we expect to
149            * to see a valid message separator at this point in the stream
150            */
151           if (fseeko (ctx->fp, tmploc, SEEK_SET) != 0 ||
152               fgets (buf, sizeof (buf), ctx->fp) == NULL ||
153               m_strncmp("From ", buf, 5) != 0) {
154             fseeko (ctx->fp, loc, SEEK_SET); /* nope, return the previous position */
155             curhdr->content->length = -1;
156           }
157         }
158         else if (tmploc != ctx->size) {
159           /* content-length would put us past the end of the file, so it
160            * must be wrong
161            */
162           curhdr->content->length = -1;
163         }
164
165         if (curhdr->content->length != -1) {
166           /* good content-length.  check to see if we know how many lines
167            * are in this message.
168            */
169           if (curhdr->lines == 0) {
170             int cl = curhdr->content->length;
171
172             /* count the number of lines in this message */
173             fseeko (ctx->fp, loc, SEEK_SET);
174             while (cl-- > 0) {
175               if (fgetc (ctx->fp) == '\n')
176                 curhdr->lines++;
177             }
178           }
179
180           /* return to the offset of the next message separator */
181           fseeko(ctx->fp, tmploc, SEEK_SET);
182         }
183       }
184
185       ctx->msgcount++;
186
187       if (!curhdr->env->return_path && return_path[0])
188         curhdr->env->return_path =
189           rfc822_parse_adrlist (curhdr->env->return_path, return_path);
190
191       if (!curhdr->env->from)
192         curhdr->env->from = address_list_dup (curhdr->env->return_path);
193
194       lines = 0;
195     }
196     else
197       lines++;
198
199     loc = ftello (ctx->fp);
200   }
201
202   /*
203    * Only set the content-length of the previous message if we have read more
204    * than one message during _this_ invocation.  If this routine is called
205    * when new mail is received, we need to make sure not to clobber what
206    * previously was the last message since the headers may be sorted.
207    */
208   if (count > 0) {
209     if (PREV->content->length < 0) {
210       PREV->content->length = ftello (ctx->fp) - PREV->content->offset - 1;
211       if (PREV->content->length < 0)
212         PREV->content->length = 0;
213     }
214
215     if (!PREV->lines)
216       PREV->lines = lines ? lines - 1 : 0;
217
218     mx_update_context (ctx, count);
219   }
220
221   return (0);
222 }
223
224 #undef PREV
225
226 /* open a mbox style mailbox */
227 static int mbox_open_mailbox (CONTEXT * ctx)
228 {
229     int rc;
230
231     if (!(ctx->fp = fopen(ctx->path, "r"))) {
232         mutt_perror(ctx->path);
233         return -1;
234     }
235
236     mutt_block_signals();
237     if (mbox_lock_mailbox(ctx, 0, 1) < 0) {
238         mutt_unblock_signals();
239         return -1;
240     }
241
242     rc = ctx->magic == M_MBOX ? mbox_parse_mailbox(ctx) : -1;
243
244     mbox_unlock_mailbox(ctx);
245     mutt_unblock_signals();
246     return rc;
247 }
248
249 /* check to see if the mailbox has changed on disk.
250  *
251  * return values:
252  *      M_REOPENED      mailbox has been reopened
253  *      M_NEW_MAIL      new mail has arrived!
254  *      M_LOCKED        couldn't lock the file
255  *      0               no change
256  *      -1              error
257  */
258 static int _mbox_check_mailbox (CONTEXT * ctx, int *index_hint)
259 {
260   struct stat st;
261   char buffer[LONG_STRING];
262   int unlock = 0;
263   int modified = 0;
264
265   if (stat (ctx->path, &st) == 0) {
266     if (st.st_mtime == ctx->mtime && st.st_size == ctx->size)
267       return (0);
268
269     if (st.st_size == ctx->size) {
270       /* the file was touched, but it is still the same length, so just exit */
271       ctx->mtime = st.st_mtime;
272       return (0);
273     }
274
275     if (st.st_size > ctx->size) {
276       /* lock the file if it isn't already */
277       if (!ctx->locked) {
278         mutt_block_signals ();
279         if (mbox_lock_mailbox (ctx, 0, 0) == -1) {
280           mutt_unblock_signals ();
281           /* we couldn't lock the mailbox, but nothing serious happened:
282            * probably the new mail arrived: no reason to wait till we can
283            * parse it: we'll get it on the next pass
284            */
285           return (M_LOCKED);
286         }
287         unlock = 1;
288       }
289
290       /*
291        * Check to make sure that the only change to the mailbox is that 
292        * message(s) were appended to this file.  My heuristic is that we should
293        * see the message separator at *exactly* what used to be the end of the
294        * folder.
295        */
296       fseeko (ctx->fp, ctx->size, SEEK_SET);
297       if (fgets (buffer, sizeof (buffer), ctx->fp) != NULL) {
298         if (ctx->magic == M_MBOX && m_strncmp("From ", buffer, 5) == 0) {
299           fseeko (ctx->fp, ctx->size, SEEK_SET);
300           mbox_parse_mailbox (ctx);
301
302           /* Only unlock the folder if it was locked inside of this routine.
303            * It may have been locked elsewhere, like in
304            * mutt_checkpoint_mailbox().
305            */
306
307           if (unlock) {
308             mbox_unlock_mailbox (ctx);
309             mutt_unblock_signals ();
310           }
311
312           return (M_NEW_MAIL);  /* signal that new mail arrived */
313         }
314         else
315           modified = 1;
316       } else {
317         modified = 1;
318       }
319     } else {
320       modified = 1;
321     }
322   }
323
324   if (modified) {
325     if (mbox_reopen_mailbox (ctx, index_hint) != -1) {
326       if (unlock) {
327         mbox_unlock_mailbox (ctx);
328         mutt_unblock_signals ();
329       }
330       return (M_REOPENED);
331     }
332   }
333
334   /* fatal error */
335
336   mbox_unlock_mailbox (ctx);
337   mx_fastclose_mailbox (ctx);
338   mutt_unblock_signals ();
339   mutt_error _("Mailbox was corrupted!");
340
341   return (-1);
342 }
343
344 static int mbox_check_mailbox(CONTEXT *ctx, int *index_hint, int lock)
345 {
346     int rc = 0;
347
348     if (lock) {
349         mutt_block_signals();
350         if (mbox_lock_mailbox(ctx, 0, 0) < 0) {
351             mutt_unblock_signals();
352             return M_LOCKED;
353         }
354     }
355
356     rc = _mbox_check_mailbox(ctx, index_hint);
357
358     if (lock) {
359         mutt_unblock_signals ();
360         mbox_unlock_mailbox (ctx);
361     }
362     return rc;
363 }
364
365 /* return values:
366  *      0       success
367  *      -1      failure
368  */
369 static int mbox_sync_mailbox (CONTEXT * ctx, int unused __attribute__ ((unused)), int *index_hint)
370 {
371   char tempfile[_POSIX_PATH_MAX];
372   char buf[32];
373   int i, j, save_sort = SORT_ORDER;
374   int rc = -1;
375   int need_sort = 0;            /* flag to resort mailbox if new mail arrives */
376   int first = -1;               /* first message to be written */
377   off_t offset;                /* location in mailbox to write changed messages */
378   struct stat statbuf;
379   struct utimbuf utimebuf;
380   struct m_update_t *newOffset = NULL;
381   struct m_update_t *oldOffset = NULL;
382   FILE *fp = NULL;
383
384   /* sort message by their position in the mailbox on disk */
385   if (Sort != SORT_ORDER) {
386     save_sort = Sort;
387     Sort = SORT_ORDER;
388     mutt_sort_headers (ctx, 0);
389     Sort = save_sort;
390     need_sort = 1;
391   }
392
393   /* need to open the file for writing in such a way that it does not truncate
394    * the file, so use read-write mode.
395    */
396   if ((ctx->fp = freopen (ctx->path, "r+", ctx->fp)) == NULL) {
397     mx_fastclose_mailbox (ctx);
398     mutt_error _("Fatal error!  Could not reopen mailbox!");
399
400     return (-1);
401   }
402
403   mutt_block_signals ();
404
405   if (mbox_lock_mailbox (ctx, 1, 1) == -1) {
406     mutt_unblock_signals ();
407     mutt_error _("Unable to lock mailbox!");
408
409     goto bail;
410   }
411
412   /* Check to make sure that the file hasn't changed on disk */
413   if ((i = _mbox_check_mailbox (ctx, index_hint)) == M_NEW_MAIL
414       || i == M_REOPENED) {
415     /* new mail arrived, or mailbox reopened */
416     need_sort = i;
417     rc = i;
418     goto bail;
419   }
420   else if (i < 0)
421     /* fatal error */
422     return (-1);
423
424   /* Create a temporary file to write the new version of the mailbox in. */
425   fp = m_tempfile(tempfile, _POSIX_PATH_MAX, NONULL(mod_core.tmpdir), NULL);
426   if (fp == NULL) {
427     mutt_error _("Could not create temporary file!");
428     mutt_sleep (5);
429     goto bail;
430   }
431
432   /* find the first deleted/changed message.  we save a lot of time by only
433    * rewriting the mailbox from the point where it has actually changed.
434    */
435   for (i = 0; i < ctx->msgcount && !ctx->hdrs[i]->deleted &&
436        !ctx->hdrs[i]->changed && !ctx->hdrs[i]->attach_del; i++);
437   if (i == ctx->msgcount) {
438     /* this means ctx->changed or ctx->deleted was set, but no
439      * messages were found to be changed or deleted.  This should
440      * never happen, is we presume it is a bug in mutt.
441      */
442     mutt_error
443       _("sync: mbox modified, but no modified messages! (report this bug)");
444     mutt_sleep (5);             /* the mutt_error /will/ get cleared! */
445     unlink (tempfile);
446     goto bail;
447   }
448
449   /* save the index of the first changed/deleted message */
450   first = i;
451   /* where to start overwriting */
452   offset = ctx->hdrs[i]->offset;
453
454   /* allocate space for the new offsets */
455   newOffset = p_new(struct m_update_t, ctx->msgcount - first);
456   oldOffset = p_new(struct m_update_t, ctx->msgcount - first);
457
458   for (i = first, j = 0; i < ctx->msgcount; i++) {
459     /*
460      * back up some information which is needed to restore offsets when
461      * something fails.
462      */
463
464     oldOffset[i - first].valid = 1;
465     oldOffset[i - first].hdr = ctx->hdrs[i]->offset;
466     oldOffset[i - first].body = ctx->hdrs[i]->content->offset;
467     oldOffset[i - first].lines = ctx->hdrs[i]->lines;
468     oldOffset[i - first].length = ctx->hdrs[i]->content->length;
469
470     if (!ctx->hdrs[i]->deleted) {
471       j++;
472       if (!ctx->quiet && WriteInc && ((i % WriteInc) == 0 || j == 1))
473         mutt_message (_("Writing messages... %d (%d%%)"), i,
474                       (int) (ftello (ctx->fp) / (ctx->size / 100 + 1)));
475
476       /* save the new offset for this message.  we add `offset' because the
477        * temporary file only contains saved message which are located after
478        * `offset' in the real mailbox
479        */
480       newOffset[i - first].hdr = ftello (fp) + offset;
481
482       if (mutt_copy_message
483           (fp, ctx, ctx->hdrs[i], M_CM_UPDATE,
484            CH_FROM | CH_UPDATE | CH_UPDATE_LEN) == -1) {
485         mutt_perror (_("Can't create temporary file"));
486         mutt_sleep (5);
487         unlink (tempfile);
488         goto bail;
489       }
490
491       /* Since messages could have been deleted, the offsets stored in memory
492        * will be wrong, so update what we can, which is the offset of this
493        * message, and the offset of the body.  If this is a multipart message,
494        * we just flush the in memory cache so that the message will be reparsed
495        * if the user accesses it later.
496        */
497       newOffset[i - first].body =
498         ftello (fp) - ctx->hdrs[i]->content->length + offset;
499       body_list_wipe(&ctx->hdrs[i]->content->parts);
500
501       if (fputs ("\n", fp) == EOF) {
502         mutt_perror (_("Can't create temporary file"));
503         mutt_sleep (5);
504         unlink (tempfile);
505         goto bail;
506       }
507     }
508   }
509
510   if (m_fclose(&fp) != 0) {
511     unlink (tempfile);
512     mutt_perror (_("Can't create temporary file"));
513     mutt_sleep (5);
514     goto bail;
515   }
516
517   /* Save the state of this folder. */
518   if (stat (ctx->path, &statbuf) == -1) {
519     mutt_perror (ctx->path);
520     mutt_sleep (5);
521     unlink (tempfile);
522     goto bail;
523   }
524
525   if ((fp = fopen (tempfile, "r")) == NULL) {
526     mutt_unblock_signals ();
527     mx_fastclose_mailbox (ctx);
528     mutt_perror (_("Can't create temporary file"));
529     mutt_sleep (5);
530     return (-1);
531   }
532
533   if (fseeko (ctx->fp, offset, SEEK_SET) != 0 /* seek the append location */
534       /* do a sanity check to make sure the mailbox looks ok */
535   ||  fgets (buf, sizeof (buf), ctx->fp) == NULL
536   ||  (ctx->magic == M_MBOX && m_strncmp("From ", buf, 5) != 0))
537   {
538     i = -1;
539   }
540   else {
541     if (fseeko (ctx->fp, offset, SEEK_SET) != 0) {       /* return to proper offset */
542       i = -1;
543     } else {
544       /* copy the temp mailbox back into place starting at the first
545        * change/deleted message
546        */
547       mutt_message _("Committing changes...");
548
549       i = mutt_copy_stream (fp, ctx->fp);
550
551       if (ferror (ctx->fp))
552         i = -1;
553     }
554     if (i == 0) {
555       ctx->size = ftello (ctx->fp);      /* update the size of the mailbox */
556       ftruncate (fileno (ctx->fp), ctx->size);
557     }
558   }
559
560   m_fclose(&fp);
561   mbox_unlock_mailbox (ctx);
562
563   if (m_fclose(&ctx->fp) != 0 || i == -1) {
564     /* error occured while writing the mailbox back, so keep the temp copy
565      * around
566      */
567
568     char savefile[_POSIX_PATH_MAX];
569
570     snprintf(savefile, sizeof (savefile), "%s/mutt.%s-%u",
571              NONULL(mod_core.tmpdir), NONULL(mod_core.username), (unsigned int)getpid());
572     rename (tempfile, savefile);
573     mutt_unblock_signals ();
574     mx_fastclose_mailbox (ctx);
575     mutt_pretty_mailbox (savefile);
576     mutt_error (_("Write failed!  Saved partial mailbox to %s"), savefile);
577     mutt_sleep (5);
578     return (-1);
579   }
580
581   /* Restore the previous access/modification times */
582   utimebuf.actime = statbuf.st_atime;
583   utimebuf.modtime = statbuf.st_mtime;
584   utime (ctx->path, &utimebuf);
585
586   /* reopen the mailbox in read-only mode */
587   if ((ctx->fp = fopen (ctx->path, "r")) == NULL) {
588     unlink (tempfile);
589     mutt_unblock_signals ();
590     mx_fastclose_mailbox (ctx);
591     mutt_error _("Fatal error!  Could not reopen mailbox!");
592     return (-1);
593   }
594
595   /* update the offsets of the rewritten messages */
596   for (i = first, j = first; i < ctx->msgcount; i++) {
597     if (!ctx->hdrs[i]->deleted) {
598       ctx->hdrs[i]->offset = newOffset[i - first].hdr;
599       ctx->hdrs[i]->content->hdr_offset = newOffset[i - first].hdr;
600       ctx->hdrs[i]->content->offset = newOffset[i - first].body;
601       ctx->hdrs[i]->index = j++;
602     }
603   }
604   p_delete(&newOffset);
605   p_delete(&oldOffset);
606   unlink (tempfile);            /* remove partial copy of the mailbox */
607   mutt_unblock_signals ();
608
609   return (0);                   /* signal success */
610
611 bail:                          /* Come here in case of disaster */
612
613   m_fclose(&fp);
614
615   /* restore offsets, as far as they are valid */
616   if (first >= 0 && oldOffset) {
617     for (i = first; i < ctx->msgcount && oldOffset[i - first].valid; i++) {
618       ctx->hdrs[i]->offset = oldOffset[i - first].hdr;
619       ctx->hdrs[i]->content->hdr_offset = oldOffset[i - first].hdr;
620       ctx->hdrs[i]->content->offset = oldOffset[i - first].body;
621       ctx->hdrs[i]->lines = oldOffset[i - first].lines;
622       ctx->hdrs[i]->content->length = oldOffset[i - first].length;
623     }
624   }
625
626   /* this is ok to call even if we haven't locked anything */
627   mbox_unlock_mailbox (ctx);
628
629   mutt_unblock_signals ();
630   p_delete(&newOffset);
631   p_delete(&oldOffset);
632
633   if ((ctx->fp = freopen (ctx->path, "r", ctx->fp)) == NULL) {
634     mutt_error _("Could not reopen mailbox!");
635
636     mx_fastclose_mailbox (ctx);
637     return (-1);
638   }
639
640   if (need_sort)
641     /* if the mailbox was reopened, the thread tree will be invalid so make
642      * sure to start threading from scratch.  */
643     mutt_sort_headers (ctx, (need_sort == M_REOPENED));
644
645   return rc;
646 }
647
648 /* close a mailbox opened in write-mode */
649 int mbox_close_mailbox (CONTEXT * ctx)
650 {
651   mx_unlock_file (ctx->path, fileno (ctx->fp), 1);
652
653   if (ctx->cinfo)
654     mutt_slow_close_compressed (ctx);
655
656   mutt_unblock_signals ();
657   mx_fastclose_mailbox (ctx);
658   return 0;
659 }
660
661 static int mbox_reopen_mailbox (CONTEXT * ctx, int *index_hint)
662 {
663   int (*cmp_headers) (const HEADER *, const HEADER *) = NULL;
664   HEADER **old_hdrs;
665   int old_msgcount;
666   int msg_mod = 0;
667   int index_hint_set;
668   int i, j;
669   int rc = -1;
670
671   /* silent operations */
672   ctx->quiet = 1;
673
674   mutt_message _("Reopening mailbox...");
675
676   /* our heuristics require the old mailbox to be unsorted */
677   if (Sort != SORT_ORDER) {
678     short old_sort;
679
680     old_sort = Sort;
681     Sort = SORT_ORDER;
682     mutt_sort_headers (ctx, 1);
683     Sort = old_sort;
684   }
685
686   old_hdrs = NULL;
687   old_msgcount = 0;
688
689   /* simulate a close */
690   if (ctx->id_hash)
691     hash_delete (&ctx->id_hash, NULL);
692   if (ctx->subj_hash)
693     hash_delete (&ctx->subj_hash, NULL);
694   mutt_clear_threads (ctx);
695   p_delete(&ctx->v2r);
696   if (ctx->readonly) {
697     for (i = 0; i < ctx->msgcount; i++)
698       header_delete(&(ctx->hdrs[i]));       /* nothing to do! */
699     p_delete(&ctx->hdrs);
700   }
701   else {
702     /* save the old headers */
703     old_msgcount = ctx->msgcount;
704     old_hdrs = ctx->hdrs;
705     ctx->hdrs = NULL;
706   }
707
708   ctx->hdrmax = 0;              /* force allocation of new headers */
709   ctx->msgcount = 0;
710   ctx->vcount = 0;
711   ctx->tagged = 0;
712   ctx->deleted = 0;
713   ctx->new = 0;
714   ctx->unread = 0;
715   ctx->flagged = 0;
716   ctx->changed = 0;
717   ctx->id_hash = NULL;
718   ctx->subj_hash = NULL;
719
720   if (ctx->magic == M_MBOX && !fseeko(ctx->fp, 0, SEEK_SET)) {
721     cmp_headers = mutt_cmp_header;
722     rc = mbox_parse_mailbox (ctx);
723   } else {
724     rc = -1;
725   }
726
727   if (rc == -1) {
728     /* free the old headers */
729     for (j = 0; j < old_msgcount; j++)
730       header_delete(&(old_hdrs[j]));
731     p_delete(&old_hdrs);
732
733     ctx->quiet = 0;
734     return (-1);
735   }
736
737   /* now try to recover the old flags */
738
739   index_hint_set = (index_hint == NULL);
740
741   if (!ctx->readonly) {
742     for (i = 0; i < ctx->msgcount; i++) {
743       int found = 0;
744
745       /* some messages have been deleted, and new  messages have been
746        * appended at the end; the heuristic is that old messages have then
747        * "advanced" towards the beginning of the folder, so we begin the
748        * search at index "i"
749        */
750       for (j = i; j < old_msgcount; j++) {
751         if (old_hdrs[j] == NULL)
752           continue;
753         if (cmp_headers (ctx->hdrs[i], old_hdrs[j])) {
754           found = 1;
755           break;
756         }
757       }
758       if (!found) {
759         for (j = 0; j < i && j < old_msgcount; j++) {
760           if (old_hdrs[j] == NULL)
761             continue;
762           if (cmp_headers (ctx->hdrs[i], old_hdrs[j])) {
763             found = 1;
764             break;
765           }
766         }
767       }
768
769       if (found) {
770         /* this is best done here */
771         if (!index_hint_set && *index_hint == j)
772           *index_hint = i;
773
774         if (old_hdrs[j]->changed) {
775           /* Only update the flags if the old header was changed;
776            * otherwise, the header may have been modified externally,
777            * and we don't want to lose _those_ changes
778            */
779           mutt_set_flag (ctx, ctx->hdrs[i], M_FLAG, old_hdrs[j]->flagged);
780           mutt_set_flag (ctx, ctx->hdrs[i], M_REPLIED, old_hdrs[j]->replied);
781           mutt_set_flag (ctx, ctx->hdrs[i], M_OLD, old_hdrs[j]->old);
782           mutt_set_flag (ctx, ctx->hdrs[i], M_READ, old_hdrs[j]->read);
783         }
784         mutt_set_flag (ctx, ctx->hdrs[i], M_DELETE, old_hdrs[j]->deleted);
785         mutt_set_flag (ctx, ctx->hdrs[i], M_TAG, old_hdrs[j]->tagged);
786
787         /* we don't need this header any more */
788         header_delete(&(old_hdrs[j]));
789       }
790     }
791
792     /* free the remaining old headers */
793     for (j = 0; j < old_msgcount; j++) {
794       if (old_hdrs[j]) {
795         header_delete(&(old_hdrs[j]));
796         msg_mod = 1;
797       }
798     }
799     p_delete(&old_hdrs);
800   }
801
802   ctx->quiet = 0;
803
804   return ((ctx->changed || msg_mod) ? M_REOPENED : M_NEW_MAIL);
805 }
806
807 /*
808  * Returns:
809  * 1 if the mailbox is not empty
810  * 0 if the mailbox is empty
811  * -1 on error
812  */
813 int mbox_check_empty (const char *path)
814 {
815   struct stat st;
816
817   if (stat (path, &st) == -1)
818     return -1;
819
820   return ((st.st_size == 0));
821 }
822
823 int mbox_is_magic (const char* path, struct stat* st)
824 {
825   int magic = -1;
826   FILE* f;
827   char tmp[_POSIX_PATH_MAX];
828
829   if (S_ISDIR(st->st_mode))
830     return (-1);
831
832   if (st->st_size == 0) {
833     return M_MBOX;
834   }
835   else if ((f = fopen (path, "r")) != NULL) {
836     struct utimbuf times;
837
838     fgets (tmp, sizeof (tmp), f);
839     if (m_strncmp("From ", tmp, 5) == 0)
840       magic = M_MBOX;
841     m_fclose(&f);
842
843     /* need to restore the times here, the file was not really accessed,
844      * only the type was accessed.  This is important, because detection
845      * of "new mail" depends on those times set correctly.
846      */
847     times.actime = st->st_atime;
848     times.modtime = st->st_mtime;
849     utime (path, &times);
850   } else {
851     mutt_perror (path);
852     return (-1);         /* fopen failed */
853   }
854
855   if (magic == -1 && mutt_can_read_compressed (path))
856     return (M_COMPRESSED);
857   return (magic);
858 }
859
860 static int mbox_commit_message (MESSAGE* msg, CONTEXT* ctx) {
861   if (fputc ('\n', msg->fp) == EOF)
862     return -1;
863   if ((fflush (msg->fp) == EOF || fsync (fileno (msg->fp)) == -1)) {
864     mutt_perror (_("Can't write message"));
865     return -1;
866   }
867   return 0;
868 }
869
870 mx_t const mbox_mx = {
871     M_MBOX,
872     1,
873     mbox_is_magic,
874     mbox_check_empty,
875     access,
876     mbox_open_mailbox,
877     mbox_open_new_message,
878     NULL,
879     mbox_check_mailbox,
880     NULL,
881     mbox_sync_mailbox,
882     mbox_commit_message,
883 };