NeoMutt  2023-11-03-107-g582dc1
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
mh.c
Go to the documentation of this file.
1
34#include "config.h"
35#include <ctype.h>
36#include <dirent.h>
37#include <errno.h>
38#include <fcntl.h>
39#include <inttypes.h>
40#include <limits.h>
41#include <stdbool.h>
42#include <stdio.h>
43#include <string.h>
44#include <sys/stat.h>
45#include <unistd.h>
46#include "mutt/lib.h"
47#include "config/lib.h"
48#include "email/lib.h"
49#include "core/lib.h"
50#include "mutt.h"
51#include "progress/lib.h"
52#include "copy.h"
53#include "errno.h"
54#include "globals.h"
55#include "mdata.h"
56#include "mhemail.h"
57#include "mx.h"
58#include "protos.h"
59#include "sequence.h"
60#include "shared.h"
61#ifdef USE_INOTIFY
62#include "monitor.h"
63#endif
64#ifdef USE_HCACHE
65#include "hcache/lib.h"
66#else
67struct HeaderCache;
68#endif
69
70struct Progress;
71
80static int mh_already_notified(struct Mailbox *m, int msgno)
81{
82 char path[PATH_MAX] = { 0 };
83 struct stat st = { 0 };
84
85 if ((snprintf(path, sizeof(path), "%s/%d", mailbox_path(m), msgno) < sizeof(path)) &&
86 (stat(path, &st) == 0))
87 {
89 }
90 return -1;
91}
92
102static bool mh_valid_message(const char *s)
103{
104 for (; *s; s++)
105 {
106 if (!isdigit((unsigned char) *s))
107 return false;
108 }
109 return true;
110}
111
119int mh_check_empty(struct Buffer *path)
120{
121 struct dirent *de = NULL;
122 int rc = 1; /* assume empty until we find a message */
123
125 if (!dir)
126 return -1;
127 while ((de = readdir(dir)))
128 {
129 if (mh_valid_message(de->d_name))
130 {
131 rc = 0;
132 break;
133 }
134 }
135 closedir(dir);
136
137 return rc;
138}
139
143static enum MxStatus mh_mbox_check_stats(struct Mailbox *m, uint8_t flags)
144{
145 struct MhSequences mhs = { 0 };
146 DIR *dir = NULL;
147 struct dirent *de = NULL;
148
149 /* when $mail_check_recent is set and the .mh_sequences file hasn't changed
150 * since the last m visit, there is no "new mail" */
151 const bool c_mail_check_recent = cs_subset_bool(NeoMutt->sub, "mail_check_recent");
152 if (c_mail_check_recent && (mh_seq_changed(m) <= 0))
153 {
154 return MX_STATUS_OK;
155 }
156
157 if (mh_seq_read(&mhs, mailbox_path(m)) < 0)
158 return MX_STATUS_ERROR;
159
160 m->msg_count = 0;
161 m->msg_unread = 0;
162 m->msg_flagged = 0;
163
164 enum MxStatus rc = MX_STATUS_OK;
165 bool check_new = true;
166 for (int i = mhs.max; i > 0; i--)
167 {
168 if ((mh_seq_check(&mhs, i) & MH_SEQ_FLAGGED))
169 m->msg_flagged++;
170 if (mh_seq_check(&mhs, i) & MH_SEQ_UNSEEN)
171 {
172 m->msg_unread++;
173 if (check_new)
174 {
175 /* if the first unseen message we encounter was in the m during the
176 * last visit, don't notify about it */
177 if (!c_mail_check_recent || (mh_already_notified(m, i) == 0))
178 {
179 m->has_new = true;
181 }
182 /* Because we are traversing from high to low, we can stop
183 * checking for new mail after the first unseen message.
184 * Whether it resulted in "new mail" or not. */
185 check_new = false;
186 }
187 }
188 }
189
190 mh_seq_free(&mhs);
191
193 if (dir)
194 {
195 while ((de = readdir(dir)))
196 {
197 if (*de->d_name == '.')
198 continue;
199 if (mh_valid_message(de->d_name))
200 m->msg_count++;
201 }
202 closedir(dir);
203 }
204
205 return rc;
206}
207
213static void mh_update_emails(struct MhEmailArray *mha, struct MhSequences *mhs)
214{
215 struct MhEmail *md = NULL;
216 struct MhEmail **mdp = NULL;
217 ARRAY_FOREACH(mdp, mha)
218 {
219 md = *mdp;
220 char *p = strrchr(md->email->path, '/');
221 if (p)
222 p++;
223 else
224 p = md->email->path;
225
226 int i = 0;
227 if (!mutt_str_atoi_full(p, &i))
228 continue;
229 MhSeqFlags flags = mh_seq_check(mhs, i);
230
231 md->email->read = !(flags & MH_SEQ_UNSEEN);
232 md->email->flagged = (flags & MH_SEQ_FLAGGED);
233 md->email->replied = (flags & MH_SEQ_REPLIED);
234 }
235}
236
246static int mh_commit_msg(struct Mailbox *m, struct Message *msg, struct Email *e, bool updseq)
247{
248 struct dirent *de = NULL;
249 char *cp = NULL, *dep = NULL;
250 unsigned int n, hi = 0;
251 char path[PATH_MAX] = { 0 };
252 char tmp[16] = { 0 };
253
254 if (mutt_file_fsync_close(&msg->fp))
255 {
256 mutt_perror(_("Could not flush message to disk"));
257 return -1;
258 }
259
261 if (!dir)
262 {
263 mutt_perror("%s", mailbox_path(m));
264 return -1;
265 }
266
267 /* figure out what the next message number is */
268 while ((de = readdir(dir)))
269 {
270 dep = de->d_name;
271 if (*dep == ',')
272 dep++;
273 cp = dep;
274 while (*cp)
275 {
276 if (!isdigit((unsigned char) *cp))
277 break;
278 cp++;
279 }
280 if (*cp == '\0')
281 {
282 if (!mutt_str_atoui(dep, &n))
283 mutt_debug(LL_DEBUG2, "Invalid MH message number '%s'\n", dep);
284 if (n > hi)
285 hi = n;
286 }
287 }
288 closedir(dir);
289
290 /* Now try to rename the file to the proper name.
291 * Note: We may have to try multiple times, until we find a free slot. */
292
293 while (true)
294 {
295 hi++;
296 snprintf(tmp, sizeof(tmp), "%u", hi);
297 snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), tmp);
298 if (mutt_file_safe_rename(msg->path, path) == 0)
299 {
300 if (e)
301 mutt_str_replace(&e->path, tmp);
302 mutt_str_replace(&msg->committed_path, path);
303 FREE(&msg->path);
304 break;
305 }
306 else if (errno != EEXIST)
307 {
308 mutt_perror("%s", mailbox_path(m));
309 return -1;
310 }
311 }
312 if (updseq)
313 {
314 mh_seq_add_one(m, hi, !msg->flags.read, msg->flags.flagged, msg->flags.replied);
315 }
316 return 0;
317}
318
326static int mh_rewrite_message(struct Mailbox *m, struct Email *e)
327{
328 if (!m || !e)
329 return -1;
330
331 bool restore = true;
332
333 long old_body_offset = e->body->offset;
334 long old_body_length = e->body->length;
335 long old_hdr_lines = e->lines;
336
337 struct Message *src = mx_msg_open(m, e);
338 struct Message *dest = mx_msg_open_new(m, e, MUTT_MSG_NO_FLAGS);
339 if (!src || !dest)
340 return -1;
341
342 int rc = mutt_copy_message(dest->fp, e, src, MUTT_CM_UPDATE, CH_UPDATE | CH_UPDATE_LEN, 0);
343 if (rc == 0)
344 {
345 char oldpath[PATH_MAX] = { 0 };
346 char partpath[PATH_MAX] = { 0 };
347 snprintf(oldpath, sizeof(oldpath), "%s/%s", mailbox_path(m), e->path);
348 mutt_str_copy(partpath, e->path, sizeof(partpath));
349
350 rc = mh_commit_msg(m, dest, e, false);
351
352 if (rc == 0)
353 {
354 unlink(oldpath);
355 restore = false;
356 }
357
358 /* Try to move the new message to the old place.
359 * (MH only.)
360 *
361 * This is important when we are just updating flags.
362 *
363 * Note that there is a race condition against programs which
364 * use the first free slot instead of the maximum message
365 * number. NeoMutt does _not_ behave like this.
366 *
367 * Anyway, if this fails, the message is in the folder, so
368 * all what happens is that a concurrently running neomutt will
369 * lose flag modifications. */
370 if (rc == 0)
371 {
372 char newpath[PATH_MAX] = { 0 };
373 snprintf(newpath, sizeof(newpath), "%s/%s", mailbox_path(m), e->path);
374 rc = mutt_file_safe_rename(newpath, oldpath);
375 if (rc == 0)
376 mutt_str_replace(&e->path, partpath);
377 }
378 }
379 mx_msg_close(m, &src);
380 mx_msg_close(m, &dest);
381
382 if ((rc == -1) && restore)
383 {
384 e->body->offset = old_body_offset;
385 e->body->length = old_body_length;
386 e->lines = old_hdr_lines;
387 }
388
390 return rc;
391}
392
400static int mh_sync_message(struct Mailbox *m, struct Email *e)
401{
402 if (!m || !e)
403 return -1;
404
405 if (e->attach_del || e->env->changed)
406 {
407 if (mh_rewrite_message(m, e) != 0)
408 return -1;
409 e->env->changed = false;
410 }
411
412 return 0;
413}
414
419static void mh_update_mtime(struct Mailbox *m)
420{
421 char buf[PATH_MAX] = { 0 };
422 struct stat st = { 0 };
423 struct MhMboxData *mdata = mh_mdata_get(m);
424
425 snprintf(buf, sizeof(buf), "%s/.mh_sequences", mailbox_path(m));
426 if (stat(buf, &st) == 0)
428
429 mutt_str_copy(buf, mailbox_path(m), sizeof(buf));
430
431 if (stat(buf, &st) == 0)
433}
434
444static int mh_parse_dir(struct Mailbox *m, struct MhEmailArray *mha, struct Progress *progress)
445{
446 struct dirent *de = NULL;
447 int rc = 0;
448 struct MhEmail *entry = NULL;
449 struct Email *e = NULL;
450
451 struct Buffer *buf = buf_pool_get();
452 buf_strcpy(buf, mailbox_path(m));
453
455 if (!dir)
456 {
457 rc = -1;
458 goto cleanup;
459 }
460
461 while (((de = readdir(dir))) && !SigInt)
462 {
463 if (!mh_valid_message(de->d_name))
464 continue;
465
466 mutt_debug(LL_DEBUG2, "queueing %s\n", de->d_name);
467
468 e = email_new();
469
470 progress_update(progress, ARRAY_SIZE(mha) + 1, -1);
471
472 e->path = mutt_str_dup(de->d_name);
473
474 entry = mh_entry_new();
475 entry->email = e;
476 ARRAY_ADD(mha, entry);
477 }
478
479 closedir(dir);
480
481 if (SigInt)
482 {
483 SigInt = false;
484 return -2; /* action aborted */
485 }
486
487cleanup:
488 buf_pool_release(&buf);
489
490 return rc;
491}
492
496static int mh_sort_path(const void *a, const void *b, void *sdata)
497{
498 struct MhEmail const *pa = *(struct MhEmail const *const *) a;
499 struct MhEmail const *pb = *(struct MhEmail const *const *) b;
500 return mutt_str_cmp(pa->email->path, pb->email->path);
501}
502
512static struct Email *mh_parse_message(const char *fname, struct Email *e)
513{
514 FILE *fp = fopen(fname, "r");
515 if (!fp)
516 {
517 return NULL;
518 }
519
520 const long size = mutt_file_get_size_fp(fp);
521 if (size == 0)
522 {
523 mutt_file_fclose(&fp);
524 return NULL;
525 }
526
527 if (!e)
528 e = email_new();
529
530 e->env = mutt_rfc822_read_header(fp, e, false, false);
531
532 if (e->received != 0)
533 e->received = e->date_sent;
534
535 /* always update the length since we have fresh information available. */
536 e->body->length = size - e->body->offset;
537 e->index = -1;
538
539 mutt_file_fclose(&fp);
540 return e;
541}
542
549static void mh_delayed_parsing(struct Mailbox *m, struct MhEmailArray *mha,
550 struct Progress *progress)
551{
552 char fn[PATH_MAX] = { 0 };
553
554#ifdef USE_HCACHE
555 const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
556 struct HeaderCache *hc = hcache_open(c_header_cache, mailbox_path(m), NULL);
557#endif
558
559 struct MhEmail *md = NULL;
560 struct MhEmail **mdp = NULL;
561 ARRAY_FOREACH(mdp, mha)
562 {
563 md = *mdp;
564 if (!md || !md->email || md->header_parsed)
565 continue;
566
567 progress_update(progress, ARRAY_FOREACH_IDX, -1);
568
569#ifdef USE_HCACHE
570 const char *key = md->email->path;
571 size_t keylen = strlen(key);
572 struct HCacheEntry hce = hcache_fetch_email(hc, key, keylen, 0);
573
574 if (hce.email)
575 {
576 hce.email->old = md->email->old;
577 hce.email->path = mutt_str_dup(md->email->path);
578 email_free(&md->email);
579 md->email = hce.email;
580 }
581 else
582#endif
583 {
584 snprintf(fn, sizeof(fn), "%s/%s", mailbox_path(m), md->email->path);
585
586 if (mh_parse_message(fn, md->email))
587 {
588 md->header_parsed = true;
589#ifdef USE_HCACHE
590 key = md->email->path;
591 keylen = strlen(key);
592 hcache_store_email(hc, key, keylen, md->email, 0);
593#endif
594 }
595 else
596 {
597 email_free(&md->email);
598 }
599 }
600 }
601#ifdef USE_HCACHE
602 hcache_close(&hc);
603#endif
604
605 const enum SortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
606 if (m && mha && (ARRAY_SIZE(mha) > 0) && (c_sort == SORT_ORDER))
607 {
608 mutt_debug(LL_DEBUG3, "mh: sorting %s into natural order\n", mailbox_path(m));
609 ARRAY_SORT(mha, mh_sort_path, NULL);
610 }
611}
612
620static int mh_move_to_mailbox(struct Mailbox *m, const struct MhEmailArray *mha)
621{
622 if (!m)
623 return 0;
624
625 int oldmsgcount = m->msg_count;
626
627 struct MhEmail *md = NULL;
628 struct MhEmail **mdp = NULL;
629 ARRAY_FOREACH(mdp, mha)
630 {
631 md = *mdp;
632 mutt_debug(LL_DEBUG2, "Considering %s\n", NONULL(md->canon_fname));
633 if (!md->email)
634 continue;
635
636 mutt_debug(LL_DEBUG2, "Adding header structure. Flags: %s%s%s%s%s\n",
637 md->email->flagged ? "f" : "", md->email->deleted ? "D" : "",
638 md->email->replied ? "r" : "", md->email->old ? "O" : "",
639 md->email->read ? "R" : "");
641
642 m->emails[m->msg_count] = md->email;
643 m->emails[m->msg_count]->index = m->msg_count;
644 mailbox_size_add(m, md->email);
645
646 md->email = NULL;
647 m->msg_count++;
648 }
649
650 int num = 0;
651 if (m->msg_count > oldmsgcount)
652 num = m->msg_count - oldmsgcount;
653
654 return num;
655}
656
663static bool mh_read_dir(struct Mailbox *m)
664{
665 if (!m)
666 return false;
667
668 struct MhSequences mhs = { 0 };
669 struct Progress *progress = NULL;
670
671 if (m->verbose)
672 {
673 progress = progress_new(MUTT_PROGRESS_READ, 0);
674 progress_set_message(progress, _("Scanning %s..."), mailbox_path(m));
675 }
676
677 struct MhMboxData *mdata = mh_mdata_get(m);
678 if (!mdata)
679 {
681 m->mdata = mdata;
683 }
684
686
687 struct MhEmailArray mha = ARRAY_HEAD_INITIALIZER;
688 int rc = mh_parse_dir(m, &mha, progress);
689 progress_free(&progress);
690 if (rc < 0)
691 return false;
692
693 if (m->verbose)
694 {
695 progress = progress_new(MUTT_PROGRESS_READ, ARRAY_SIZE(&mha));
696 progress_set_message(progress, _("Reading %s..."), mailbox_path(m));
697 }
698 mh_delayed_parsing(m, &mha, progress);
699 progress_free(&progress);
700
701 if (mh_seq_read(&mhs, mailbox_path(m)) < 0)
702 {
703 mharray_clear(&mha);
704 return false;
705 }
706 mh_update_emails(&mha, &mhs);
707 mh_seq_free(&mhs);
708
709 mh_move_to_mailbox(m, &mha);
710 mharray_clear(&mha);
711
712 if (!mdata->umask)
713 mdata->umask = mh_umask(m);
714
715 return true;
716}
717
726int mh_sync_mailbox_message(struct Mailbox *m, struct Email *e, struct HeaderCache *hc)
727{
728 if (!m || !e)
729 return -1;
730
731 if (e->deleted)
732 {
733 char path[PATH_MAX] = { 0 };
734 snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
735 const bool c_mh_purge = cs_subset_bool(NeoMutt->sub, "mh_purge");
736 if (c_mh_purge)
737 {
738#ifdef USE_HCACHE
739 if (hc)
740 {
741 const char *key = e->path;
742 size_t keylen = strlen(key);
743 hcache_delete_email(hc, key, keylen);
744 }
745#endif
746 unlink(path);
747 }
748 else
749 {
750 /* MH just moves files out of the way when you delete them */
751 if (*e->path != ',')
752 {
753 char tmp[PATH_MAX] = { 0 };
754 snprintf(tmp, sizeof(tmp), "%s/,%s", mailbox_path(m), e->path);
755 unlink(tmp);
756 if (rename(path, tmp) != 0)
757 {
758 return -1;
759 }
760 }
761 }
762 }
763 else if (e->changed || e->attach_del)
764 {
765 if (mh_sync_message(m, e) == -1)
766 return -1;
767 }
768
769#ifdef USE_HCACHE
770 if (hc && e->changed)
771 {
772 const char *key = e->path;
773 size_t keylen = strlen(key);
774 hcache_store_email(hc, key, keylen, e, 0);
775 }
776#endif
777
778 return 0;
779}
780
784static int mh_msg_save_hcache(struct Mailbox *m, struct Email *e)
785{
786 int rc = 0;
787#ifdef USE_HCACHE
788 const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
789 struct HeaderCache *hc = hcache_open(c_header_cache, mailbox_path(m), NULL);
790 rc = hcache_store_email(hc, e->path, strlen(e->path), e, 0);
791 hcache_close(&hc);
792#endif
793 return rc;
794}
795
799static bool mh_ac_owns_path(struct Account *a, const char *path)
800{
801 return true;
802}
803
807static bool mh_ac_add(struct Account *a, struct Mailbox *m)
808{
809 return true;
810}
811
815static enum MxOpenReturns mh_mbox_open(struct Mailbox *m)
816{
818}
819
823static bool mh_mbox_open_append(struct Mailbox *m, OpenMailboxFlags flags)
824{
825 if (!(flags & (MUTT_APPENDNEW | MUTT_NEWFOLDER)))
826 return true;
827
828 if (mutt_file_mkdir(mailbox_path(m), S_IRWXU))
829 {
830 mutt_perror("%s", mailbox_path(m));
831 return false;
832 }
833
834 char tmp[PATH_MAX] = { 0 };
835 snprintf(tmp, sizeof(tmp), "%s/.mh_sequences", mailbox_path(m));
836 const int i = creat(tmp, S_IRWXU);
837 if (i == -1)
838 {
839 mutt_perror("%s", tmp);
840 rmdir(mailbox_path(m));
841 return false;
842 }
843 close(i);
844
845 return true;
846}
847
856static bool mh_update_flags(struct Mailbox *m, struct Email *e_old, struct Email *e_new)
857{
858 if (!m)
859 return false;
860
861 /* save the global state here so we can reset it at the
862 * end of list block if required. */
863 bool context_changed = m->changed;
864
865 /* user didn't modify this message. alter the flags to match the
866 * current state on disk. This may not actually do
867 * anything. mutt_set_flag() will just ignore the call if the status
868 * bits are already properly set, but it is still faster not to pass
869 * through it */
870 if (e_old->flagged != e_new->flagged)
871 mutt_set_flag(m, e_old, MUTT_FLAG, e_new->flagged, true);
872 if (e_old->replied != e_new->replied)
873 mutt_set_flag(m, e_old, MUTT_REPLIED, e_new->replied, true);
874 if (e_old->read != e_new->read)
875 mutt_set_flag(m, e_old, MUTT_READ, e_new->read, true);
876 if (e_old->old != e_new->old)
877 mutt_set_flag(m, e_old, MUTT_OLD, e_new->old, true);
878
879 /* mutt_set_flag() will set this, but we don't need to
880 * sync the changes we made because we just updated the
881 * context to match the current on-disk state of the
882 * message. */
883 bool header_changed = e_old->changed;
884 e_old->changed = false;
885
886 /* if the mailbox was not modified before we made these
887 * changes, unset the changed flag since nothing needs to
888 * be synchronized. */
889 if (!context_changed)
890 m->changed = false;
891
892 return header_changed;
893}
894
907static enum MxStatus mh_check(struct Mailbox *m)
908{
909 char buf[PATH_MAX] = { 0 };
910 struct stat st = { 0 };
911 struct stat st_cur = { 0 };
912 bool modified = false, occult = false, flags_changed = false;
913 int num_new = 0;
914 struct MhSequences mhs = { 0 };
915 struct HashTable *fnames = NULL;
916 struct MhMboxData *mdata = mh_mdata_get(m);
917
918 const bool c_check_new = cs_subset_bool(NeoMutt->sub, "check_new");
919 if (!c_check_new)
920 return MX_STATUS_OK;
921
922 mutt_str_copy(buf, mailbox_path(m), sizeof(buf));
923 if (stat(buf, &st) == -1)
924 return MX_STATUS_ERROR;
925
926 /* create .mh_sequences when there isn't one. */
927 snprintf(buf, sizeof(buf), "%s/.mh_sequences", mailbox_path(m));
928 int rc = stat(buf, &st_cur);
929 if ((rc == -1) && (errno == ENOENT))
930 {
931 char *tmp = NULL;
932 FILE *fp = NULL;
933
934 if (mh_mkstemp(m, &fp, &tmp))
935 {
936 mutt_file_fclose(&fp);
937 if (mutt_file_safe_rename(tmp, buf) == -1)
938 unlink(tmp);
939 FREE(&tmp);
940 }
941 }
942
943 if ((rc == -1) && (stat(buf, &st_cur) == -1))
944 modified = true;
945
946 if ((mutt_file_stat_timespec_compare(&st, MUTT_STAT_MTIME, &mdata->mtime) > 0) ||
947 (mutt_file_stat_timespec_compare(&st_cur, MUTT_STAT_MTIME, &mdata->mtime_seq) > 0))
948 {
949 modified = true;
950 }
951
952 if (!modified)
953 return MX_STATUS_OK;
954
955 /* Update the modification times on the mailbox.
956 *
957 * The monitor code notices changes in the open mailbox too quickly.
958 * In practice, this sometimes leads to all the new messages not being
959 * noticed during the SAME group of mtime stat updates. To work around
960 * the problem, don't update the stat times for a monitor caused check. */
961#ifdef USE_INOTIFY
963 {
964 MonitorContextChanged = false;
965 }
966 else
967#endif
968 {
971 }
972
973 struct MhEmailArray mha = ARRAY_HEAD_INITIALIZER;
974
975 mh_parse_dir(m, &mha, NULL);
976 mh_delayed_parsing(m, &mha, NULL);
977
978 if (mh_seq_read(&mhs, mailbox_path(m)) < 0)
979 return MX_STATUS_ERROR;
980 mh_update_emails(&mha, &mhs);
981 mh_seq_free(&mhs);
982
983 /* check for modifications and adjust flags */
985
986 struct MhEmail *md = NULL;
987 struct MhEmail **mdp = NULL;
988 ARRAY_FOREACH(mdp, &mha)
989 {
990 md = *mdp;
991 /* the hash key must survive past the header, which is freed below. */
993 mutt_hash_insert(fnames, md->canon_fname, md);
994 }
995
996 for (int i = 0; i < m->msg_count; i++)
997 {
998 struct Email *e = m->emails[i];
999 if (!e)
1000 break;
1001
1002 md = mutt_hash_find(fnames, e->path);
1003 if (md && md->email && email_cmp_strict(e, md->email))
1004 {
1005 /* found the right message */
1006 if (!e->changed)
1007 if (mh_update_flags(m, e, md->email))
1008 flags_changed = true;
1009
1010 email_free(&md->email);
1011 }
1012 else /* message has disappeared */
1013 {
1014 occult = true;
1015 }
1016 }
1017
1018 /* destroy the file name hash */
1019
1020 mutt_hash_free(&fnames);
1021
1022 /* If we didn't just get new mail, update the tables. */
1023 if (occult)
1025
1026 /* Incorporate new messages */
1027 num_new = mh_move_to_mailbox(m, &mha);
1028 mharray_clear(&mha);
1029
1030 if (num_new > 0)
1031 {
1033 m->changed = true;
1034 }
1035
1036 ARRAY_FREE(&mha);
1037 if (occult)
1038 return MX_STATUS_REOPENED;
1039 if (num_new > 0)
1040 return MX_STATUS_NEW_MAIL;
1041 if (flags_changed)
1042 return MX_STATUS_FLAGS;
1043 return MX_STATUS_OK;
1044}
1045
1049static enum MxStatus mh_mbox_check(struct Mailbox *m)
1050{
1051 return mh_check(m);
1052}
1053
1063static enum MxStatus mh_mbox_sync(struct Mailbox *m)
1064{
1065 enum MxStatus check = mh_check(m);
1066 if (check == MX_STATUS_ERROR)
1067 return check;
1068
1069 struct HeaderCache *hc = NULL;
1070#ifdef USE_HCACHE
1071 const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
1072 hc = hcache_open(c_header_cache, mailbox_path(m), NULL);
1073#endif
1074
1075 struct Progress *progress = NULL;
1076 if (m->verbose)
1077 {
1079 progress_set_message(progress, _("Writing %s..."), mailbox_path(m));
1080 }
1081
1082 for (int i = 0; i < m->msg_count; i++)
1083 {
1084 progress_update(progress, i, -1);
1085
1086 struct Email *e = m->emails[i];
1087 if (mh_sync_mailbox_message(m, e, hc) == -1)
1088 {
1089 progress_free(&progress);
1090 goto err;
1091 }
1092 }
1093 progress_free(&progress);
1094
1095#ifdef USE_HCACHE
1096 hcache_close(&hc);
1097#endif
1098
1099 mh_seq_update(m);
1100
1101 /* XXX race condition? */
1102
1103 mh_update_mtime(m);
1104
1105 /* adjust indices */
1106
1107 if (m->msg_deleted)
1108 {
1109 for (int i = 0, j = 0; i < m->msg_count; i++)
1110 {
1111 struct Email *e = m->emails[i];
1112 if (!e)
1113 break;
1114
1115 if (!e->deleted)
1116 e->index = j++;
1117 }
1118 }
1119
1120 return check;
1121
1122err:
1123#ifdef USE_HCACHE
1124 hcache_close(&hc);
1125#endif
1126 return MX_STATUS_ERROR;
1127}
1128
1133static enum MxStatus mh_mbox_close(struct Mailbox *m)
1134{
1135 return MX_STATUS_OK;
1136}
1137
1141static bool mh_msg_open(struct Mailbox *m, struct Message *msg, struct Email *e)
1142{
1143 char path[PATH_MAX] = { 0 };
1144
1145 snprintf(path, sizeof(path), "%s/%s", mailbox_path(m), e->path);
1146
1147 msg->fp = fopen(path, "r");
1148 if (!msg->fp)
1149 {
1150 mutt_perror("%s", path);
1151 mutt_debug(LL_DEBUG1, "fopen: %s: %s (errno %d)\n", path, strerror(errno), errno);
1152 return false;
1153 }
1154
1155 return true;
1156}
1157
1163static bool mh_msg_open_new(struct Mailbox *m, struct Message *msg, const struct Email *e)
1164{
1165 return mh_mkstemp(m, &msg->fp, &msg->path);
1166}
1167
1171static int mh_msg_commit(struct Mailbox *m, struct Message *msg)
1172{
1173 return mh_commit_msg(m, msg, NULL, true);
1174}
1175
1181static int mh_msg_close(struct Mailbox *m, struct Message *msg)
1182{
1183 return mutt_file_fclose(&msg->fp);
1184}
1185
1189static int mh_path_canon(struct Buffer *path)
1190{
1192 return 0;
1193}
1194
1198static enum MailboxType mh_path_probe(const char *path, const struct stat *st)
1199{
1200 if (!st || !S_ISDIR(st->st_mode))
1201 return MUTT_UNKNOWN;
1202
1203 char tmp[PATH_MAX] = { 0 };
1204
1205 snprintf(tmp, sizeof(tmp), "%s/.mh_sequences", path);
1206 if (access(tmp, F_OK) == 0)
1207 return MUTT_MH;
1208
1209 snprintf(tmp, sizeof(tmp), "%s/.xmhcache", path);
1210 if (access(tmp, F_OK) == 0)
1211 return MUTT_MH;
1212
1213 snprintf(tmp, sizeof(tmp), "%s/.mew_cache", path);
1214 if (access(tmp, F_OK) == 0)
1215 return MUTT_MH;
1216
1217 snprintf(tmp, sizeof(tmp), "%s/.mew-cache", path);
1218 if (access(tmp, F_OK) == 0)
1219 return MUTT_MH;
1220
1221 snprintf(tmp, sizeof(tmp), "%s/.sylpheed_cache", path);
1222 if (access(tmp, F_OK) == 0)
1223 return MUTT_MH;
1224
1225 /* ok, this isn't an mh folder, but mh mode can be used to read
1226 * Usenet news from the spool. */
1227
1228 snprintf(tmp, sizeof(tmp), "%s/.overview", path);
1229 if (access(tmp, F_OK) == 0)
1230 return MUTT_MH;
1231
1232 return MUTT_UNKNOWN;
1233}
1234
1238const struct MxOps MxMhOps = {
1239 // clang-format off
1240 .type = MUTT_MH,
1241 .name = "mh",
1242 .is_local = true,
1243 .ac_owns_path = mh_ac_owns_path,
1244 .ac_add = mh_ac_add,
1245 .mbox_open = mh_mbox_open,
1246 .mbox_open_append = mh_mbox_open_append,
1247 .mbox_check = mh_mbox_check,
1248 .mbox_check_stats = mh_mbox_check_stats,
1249 .mbox_sync = mh_mbox_sync,
1250 .mbox_close = mh_mbox_close,
1251 .msg_open = mh_msg_open,
1252 .msg_open_new = mh_msg_open_new,
1253 .msg_commit = mh_msg_commit,
1254 .msg_close = mh_msg_close,
1255 .msg_padding_size = NULL,
1256 .msg_save_hcache = mh_msg_save_hcache,
1257 .tags_edit = NULL,
1258 .tags_commit = NULL,
1259 .path_probe = mh_path_probe,
1260 .path_canon = mh_path_canon,
1261 .path_is_empty = mh_check_empty,
1262 // clang-format on
1263};
#define ARRAY_SORT(head, fn, sdata)
Sort an array.
Definition: array.h:278
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:155
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition: array.h:211
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:86
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:203
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:57
const char * mutt_str_atoui(const char *str, unsigned int *dst)
Convert ASCII string to an unsigned integer.
Definition: atoi.c:213
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:407
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:93
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
Definition: helpers.c:169
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
short cs_subset_sort(const struct ConfigSubset *sub, const char *name)
Get a sort config item by name.
Definition: helpers.c:267
Convenience wrapper for the config headers.
char * HomeDir
User's home directory.
Definition: globals.c:39
int mutt_copy_message(FILE *fp_out, struct Email *e, struct Message *msg, CopyMessageFlags cmflags, CopyHeaderFlags chflags, int wraplen)
Copy a message from a Mailbox.
Definition: copy.c:884
Duplicate the structure of an entire email.
#define MUTT_CM_UPDATE
Update structs on sync.
Definition: copy.h:40
#define CH_UPDATE
Update the status and x-status fields?
Definition: copy.h:52
#define CH_UPDATE_LEN
Update Lines: and Content-Length:
Definition: copy.h:62
Convenience wrapper for the core headers.
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:57
bool email_cmp_strict(const struct Email *e1, const struct Email *e2)
Strictly compare message emails.
Definition: email.c:100
struct Email * email_new(void)
Create a new Email.
Definition: email.c:78
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:44
Structs that make up an email.
struct Envelope * mutt_rfc822_read_header(FILE *fp, struct Email *e, bool user_hdrs, bool weed)
Parses an RFC822 header.
Definition: parse.c:1156
void mutt_file_get_stat_timespec(struct timespec *dest, struct stat *st, enum MuttStatType type)
Read the stat() time into a time value.
Definition: file.c:1620
int mutt_file_safe_rename(const char *src, const char *target)
NFS-safe renaming of files.
Definition: file.c:346
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:152
int mutt_file_mkdir(const char *path, mode_t mode)
Recursively create directories.
Definition: file.c:977
long mutt_file_get_size_fp(FILE *fp)
Get the size of a file.
Definition: file.c:1578
DIR * mutt_file_opendir(const char *path, enum MuttOpenDirMode mode)
Open a directory.
Definition: file.c:616
int mutt_file_stat_timespec_compare(struct stat *st, enum MuttStatType type, struct timespec *b)
Compare stat info with a time value.
Definition: file.c:1660
int mutt_file_fsync_close(FILE **fp)
Flush the data, before closing a file (and NULL the pointer)
Definition: file.c:168
@ MUTT_OPENDIR_NONE
Plain opendir()
Definition: file.h:73
@ MUTT_STAT_MTIME
File/dir's mtime - last modified time.
Definition: file.h:64
void mutt_set_flag(struct Mailbox *m, struct Email *e, enum MessageType flag, bool bf, bool upd_mbox)
Set a flag on an email.
Definition: flags.c:53
SIG_ATOMIC_VOLATILE_T SigInt
true after SIGINT is received
Definition: globals.c:59
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
#define mutt_perror(...)
Definition: logging2.h:93
void mh_mdata_free(void **ptr)
Free the private Mailbox data - Implements Mailbox::mdata_free() -.
Definition: mdata.c:37
static bool mh_ac_add(struct Account *a, struct Mailbox *m)
Add a Mailbox to an Account - Implements MxOps::ac_add() -.
Definition: mh.c:807
static bool mh_ac_owns_path(struct Account *a, const char *path)
Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
Definition: mh.c:799
const struct MxOps MxMhOps
MH Mailbox - Implements MxOps -.
Definition: mh.c:1238
static enum MxStatus mh_mbox_check_stats(struct Mailbox *m, uint8_t flags)
Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
Definition: mh.c:143
static enum MxStatus mh_mbox_check(struct Mailbox *m)
Check for new mail - Implements MxOps::mbox_check() -.
Definition: mh.c:1049
static enum MxStatus mh_mbox_close(struct Mailbox *m)
Close a Mailbox - Implements MxOps::mbox_close() -.
Definition: mh.c:1133
static bool mh_mbox_open_append(struct Mailbox *m, OpenMailboxFlags flags)
Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
Definition: mh.c:823
static enum MxOpenReturns mh_mbox_open(struct Mailbox *m)
Open a Mailbox - Implements MxOps::mbox_open() -.
Definition: mh.c:815
static enum MxStatus mh_mbox_sync(struct Mailbox *m)
Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
Definition: mh.c:1063
static int mh_msg_close(struct Mailbox *m, struct Message *msg)
Close an email - Implements MxOps::msg_close() -.
Definition: mh.c:1181
static int mh_msg_commit(struct Mailbox *m, struct Message *msg)
Save changes to an email - Implements MxOps::msg_commit() -.
Definition: mh.c:1171
static bool mh_msg_open_new(struct Mailbox *m, struct Message *msg, const struct Email *e)
Open a new message in a Mailbox - Implements MxOps::msg_open_new() -.
Definition: mh.c:1163
static bool mh_msg_open(struct Mailbox *m, struct Message *msg, struct Email *e)
Open an email message in a Mailbox - Implements MxOps::msg_open() -.
Definition: mh.c:1141
static int mh_msg_save_hcache(struct Mailbox *m, struct Email *e)
Save message to the header cache - Implements MxOps::msg_save_hcache() -.
Definition: mh.c:784
static int mh_path_canon(struct Buffer *path)
Canonicalise a Mailbox path - Implements MxOps::path_canon() -.
Definition: mh.c:1189
static enum MailboxType mh_path_probe(const char *path, const struct stat *st)
Is this an mh Mailbox? - Implements MxOps::path_probe() -.
Definition: mh.c:1198
static int mh_sort_path(const void *a, const void *b, void *sdata)
Compare two Mh Mailboxes by path - Implements sort_t -.
Definition: mh.c:496
struct HashElem * mutt_hash_insert(struct HashTable *table, const char *strkey, void *data)
Add a new element to the Hash Table (with string keys)
Definition: hash.c:335
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:362
struct HashTable * mutt_hash_new(size_t num_elems, HashFlags flags)
Create a new Hash Table (with string keys)
Definition: hash.c:259
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:457
#define MUTT_HASH_NO_FLAGS
No flags are set.
Definition: hash.h:110
Header cache multiplexor.
struct HeaderCache * hcache_open(const char *path, const char *folder, hcache_namer_t namer)
Multiplexor for StoreOps::open.
Definition: hcache.c:473
int hcache_delete_email(struct HeaderCache *hc, const char *key, size_t keylen)
Multiplexor for StoreOps::delete_record.
Definition: hcache.c:739
void hcache_close(struct HeaderCache **ptr)
Multiplexor for StoreOps::close.
Definition: hcache.c:542
struct HCacheEntry hcache_fetch_email(struct HeaderCache *hc, const char *key, size_t keylen, uint32_t uidvalidity)
Multiplexor for StoreOps::fetch.
Definition: hcache.c:562
int hcache_store_email(struct HeaderCache *hc, const char *key, size_t keylen, struct Email *e, uint32_t uidvalidity)
Multiplexor for StoreOps::store.
Definition: hcache.c:670
@ LL_DEBUG3
Log at debug level 3.
Definition: logging2.h:45
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
void mailbox_size_add(struct Mailbox *m, const struct Email *e)
Add an email's size to the total size of a Mailbox.
Definition: mailbox.c:242
void mailbox_changed(struct Mailbox *m, enum NotifyMailbox action)
Notify observers of a change to a Mailbox.
Definition: mailbox.c:226
@ NT_MAILBOX_RESORT
Email list needs resorting.
Definition: mailbox.h:177
@ NT_MAILBOX_INVALID
Email list was changed.
Definition: mailbox.h:176
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:210
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_MH
'MH' Mailbox type
Definition: mailbox.h:47
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
#define FREE(x)
Definition: memory.h:45
struct MhMboxData * mh_mdata_get(struct Mailbox *m)
Get the private data for this Mailbox.
Definition: mdata.c:60
struct MhMboxData * mh_mdata_new(void)
Create a new MhMboxData object.
Definition: mdata.c:49
static bool mh_update_flags(struct Mailbox *m, struct Email *e_old, struct Email *e_new)
Update the mailbox flags.
Definition: mh.c:856
static void mh_update_mtime(struct Mailbox *m)
Update our record of the mailbox modification time.
Definition: mh.c:419
int mh_check_empty(struct Buffer *path)
Is mailbox empty.
Definition: mh.c:119
static bool mh_valid_message(const char *s)
Is this a valid MH message filename.
Definition: mh.c:102
static int mh_parse_dir(struct Mailbox *m, struct MhEmailArray *mha, struct Progress *progress)
Read an Mh mailbox.
Definition: mh.c:444
static int mh_sync_message(struct Mailbox *m, struct Email *e)
Sync an email to an MH folder.
Definition: mh.c:400
static enum MxStatus mh_check(struct Mailbox *m)
Check for new mail.
Definition: mh.c:907
int mh_sync_mailbox_message(struct Mailbox *m, struct Email *e, struct HeaderCache *hc)
Save changes to the mailbox.
Definition: mh.c:726
static int mh_commit_msg(struct Mailbox *m, struct Message *msg, struct Email *e, bool updseq)
Commit a message to an MH folder.
Definition: mh.c:246
static int mh_already_notified(struct Mailbox *m, int msgno)
Has the message changed.
Definition: mh.c:80
static void mh_delayed_parsing(struct Mailbox *m, struct MhEmailArray *mha, struct Progress *progress)
This function does the second parsing pass.
Definition: mh.c:549
static void mh_update_emails(struct MhEmailArray *mha, struct MhSequences *mhs)
Update our record of flags.
Definition: mh.c:213
static bool mh_read_dir(struct Mailbox *m)
Read an MH mailbox.
Definition: mh.c:663
static int mh_move_to_mailbox(struct Mailbox *m, const struct MhEmailArray *mha)
Copy the Mh list to the Mailbox.
Definition: mh.c:620
static struct Email * mh_parse_message(const char *fname, struct Email *e)
Actually parse an MH message.
Definition: mh.c:512
static int mh_rewrite_message(struct Mailbox *m, struct Email *e)
Sync a message in an MH folder.
Definition: mh.c:326
struct MhEmail * mh_entry_new(void)
Create a new Mh entry.
Definition: mhemail.c:39
void mharray_clear(struct MhEmailArray *mha)
Free a Mh array.
Definition: mhemail.c:64
Mh Email helper.
bool MonitorContextChanged
Set to true when the current mailbox has changed.
Definition: monitor.c:51
Monitor files for changes.
Convenience wrapper for the library headers.
#define _(a)
Definition: message.h:28
bool mutt_path_canon(struct Buffer *path, const char *homedir, bool is_dir)
Create the canonical version of a path.
Definition: path.c:244
int mutt_str_cmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:471
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:653
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:327
Many unsorted constants and some structs.
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:72
@ MUTT_OLD
Old messages.
Definition: mutt.h:70
@ MUTT_FLAG
Flagged messages.
Definition: mutt.h:78
@ MUTT_REPLIED
Messages that have been replied to.
Definition: mutt.h:71
#define PATH_MAX
Definition: mutt.h:41
void mx_alloc_memory(struct Mailbox *m, int req_size)
Create storage for the emails.
Definition: mx.c:1211
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
Definition: mx.c:1185
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
Definition: mx.c:1139
struct Message * mx_msg_open_new(struct Mailbox *m, const struct Email *e, MsgOpenFlags flags)
Open a new message.
Definition: mx.c:1034
API for mailboxes.
#define MUTT_MSG_NO_FLAGS
No flags are set.
Definition: mx.h:39
uint8_t OpenMailboxFlags
Flags for mutt_open_mailbox(), e.g. MUTT_NOSORT.
Definition: mxapi.h:39
#define MUTT_NEWFOLDER
Create a new folder - same as MUTT_APPEND, but uses mutt_file_fopen() with mode "w" for mbox-style fo...
Definition: mxapi.h:45
MxOpenReturns
Return values for mbox_open()
Definition: mxapi.h:76
@ MX_OPEN_ERROR
Open failed with an error.
Definition: mxapi.h:78
@ MX_OPEN_OK
Open succeeded.
Definition: mxapi.h:77
#define MUTT_APPENDNEW
Set in mx_open_mailbox_append if the mailbox doesn't exist.
Definition: mxapi.h:49
MxStatus
Return values from mbox_check(), mbox_check_stats(), mbox_snc(), and mbox_close()
Definition: mxapi.h:63
@ MX_STATUS_ERROR
An error occurred.
Definition: mxapi.h:64
@ MX_STATUS_OK
No changes.
Definition: mxapi.h:65
@ MX_STATUS_FLAGS
Nondestructive flags change (IMAP)
Definition: mxapi.h:69
@ MX_STATUS_REOPENED
Mailbox was reopened.
Definition: mxapi.h:68
@ MX_STATUS_NEW_MAIL
New mail received in Mailbox.
Definition: mxapi.h:66
Notmuch-specific Mailbox data.
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
Progress Bar.
@ MUTT_PROGRESS_READ
Progress tracks elements, according to $read_inc
Definition: lib.h:82
@ MUTT_PROGRESS_WRITE
Progress tracks elements, according to $write_inc
Definition: lib.h:83
struct Progress * progress_new(enum ProgressType type, size_t size)
Create a new Progress Bar.
Definition: progress.c:140
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition: progress.c:111
void progress_set_message(struct Progress *progress, const char *fmt,...) __attribute__((__format__(__printf__
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Definition: progress.c:81
Prototypes for many functions.
void mh_seq_add_one(struct Mailbox *m, int n, bool unseen, bool flagged, bool replied)
Update the flags for one sequence.
Definition: sequence.c:107
MhSeqFlags mh_seq_check(struct MhSequences *mhs, int i)
Get the flags for a given sequence.
Definition: sequence.c:78
void mh_seq_free(struct MhSequences *mhs)
Free some sequences.
Definition: sequence.c:67
int mh_seq_changed(struct Mailbox *m)
Has the mailbox changed.
Definition: sequence.c:438
void mh_seq_update(struct Mailbox *m)
Update sequence numbers.
Definition: sequence.c:233
int mh_seq_read(struct MhSequences *mhs, const char *path)
Read a set of MH sequences.
Definition: sequence.c:377
MH Mailbox Sequences.
#define MH_SEQ_UNSEEN
Email hasn't been read.
Definition: sequence.h:33
#define MH_SEQ_REPLIED
Email has been replied to.
Definition: sequence.h:34
uint8_t MhSeqFlags
Flags, e.g. MH_SEQ_UNSEEN.
Definition: sequence.h:31
#define MH_SEQ_FLAGGED
Email is flagged.
Definition: sequence.h:35
bool mh_mkstemp(struct Mailbox *m, FILE **fp, char **tgt)
Create a temporary file.
Definition: shared.c:76
mode_t mh_umask(struct Mailbox *m)
Create a umask from the mailbox directory.
Definition: shared.c:52
MH shared functions.
SortType
Methods for sorting.
Definition: sort2.h:38
@ SORT_ORDER
Sort by the order the messages appear in the mailbox.
Definition: sort2.h:44
#define NONULL(x)
Definition: string2.h:37
A group of associated Mailboxes.
Definition: account.h:37
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:72
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
String manipulation buffer.
Definition: buffer.h:34
The envelope/body of an email.
Definition: email.h:37
bool read
Email is read.
Definition: email.h:48
struct Envelope * env
Envelope information.
Definition: email.h:66
int lines
How many lines in the body of this message?
Definition: email.h:60
struct Body * body
List of MIME parts.
Definition: email.h:67
bool old
Email is seen, but unread.
Definition: email.h:47
bool changed
Email has been edited.
Definition: email.h:75
bool attach_del
Has an attachment marked for deletion.
Definition: email.h:100
bool flagged
Marked important?
Definition: email.h:45
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:58
bool replied
Email has been replied to.
Definition: email.h:49
char * path
Path of Email (for local Mailboxes)
Definition: email.h:68
bool deleted
Email is deleted.
Definition: email.h:76
int index
The absolute (unsorted) message number.
Definition: email.h:111
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:59
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:90
Wrapper for Email retrieved from the header cache.
Definition: lib.h:101
struct Email * email
Retrieved email.
Definition: lib.h:104
A Hash Table.
Definition: hash.h:98
Header Cache.
Definition: lib.h:88
A mailbox.
Definition: mailbox.h:79
void(* mdata_free)(void **ptr)
Definition: mailbox.h:142
bool changed
Mailbox has been modified.
Definition: mailbox.h:109
bool has_new
Mailbox has new mail.
Definition: mailbox.h:85
int msg_count
Total number of messages.
Definition: mailbox.h:88
void * mdata
Driver specific data.
Definition: mailbox.h:131
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:93
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
struct timespec last_visited
Time of last exit from this mailbox.
Definition: mailbox.h:104
bool verbose
Display status messages?
Definition: mailbox.h:116
int msg_unread
Number of unread messages.
Definition: mailbox.h:89
A local copy of an email.
Definition: message.h:34
FILE * fp
pointer to the message data
Definition: message.h:35
char * path
path to temp file
Definition: message.h:36
bool replied
Message has been replied to.
Definition: message.h:43
char * committed_path
the final path generated by mx_msg_commit()
Definition: message.h:37
bool flagged
Message is flagged.
Definition: message.h:42
bool read
Message has been read.
Definition: message.h:41
struct Message::@0 flags
Flags for the Message.
A Mh Email helper.
Definition: mhemail.h:36
bool header_parsed
Has the Email header been parsed?
Definition: mhemail.h:39
struct Email * email
Temporary Email.
Definition: mhemail.h:37
char * canon_fname
Canonical filename for hashing.
Definition: mhemail.h:38
Mh-specific Mailbox data -.
Definition: mdata.h:35
mode_t umask
umask to use when creating files
Definition: mdata.h:38
Set of MH sequence numbers.
Definition: sequence.h:41
int max
Number of flags stored.
Definition: sequence.h:42
Definition: mxapi.h:91
enum MailboxType type
Mailbox type, e.g. MUTT_IMAP.
Definition: mxapi.h:92
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45