NeoMutt  2024-03-23-142-g2b2e76
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
message.c
Go to the documentation of this file.
1
36#include "config.h"
37#include <assert.h>
38#include <ctype.h>
39#include <limits.h>
40#include <stdbool.h>
41#include <stdint.h>
42#include <stdio.h>
43#include <string.h>
44#include <unistd.h>
45#include "private.h"
46#include "mutt/lib.h"
47#include "config/lib.h"
48#include "email/lib.h"
49#include "core/lib.h"
50#include "conn/lib.h"
51#include "gui/lib.h"
52#include "mutt.h"
53#include "message.h"
54#include "lib.h"
55#include "bcache/lib.h"
56#include "progress/lib.h"
57#include "question/lib.h"
58#include "adata.h"
59#include "edata.h"
60#include "external.h"
61#include "mdata.h"
62#include "msg_set.h"
63#include "msn.h"
64#include "mutt_logging.h"
65#include "mx.h"
66#include "protos.h"
67#ifdef ENABLE_NLS
68#include <libintl.h>
69#endif
70#ifdef USE_HCACHE
71#include "hcache/lib.h"
72#endif
73
74struct BodyCache;
75
82static struct BodyCache *imap_bcache_open(struct Mailbox *m)
83{
86
87 if (!adata || (adata->mailbox != m))
88 return NULL;
89
90 if (mdata->bcache)
91 return mdata->bcache;
92
93 struct Buffer *mailbox = buf_pool_get();
94 imap_cachepath(adata->delim, mdata->name, mailbox);
95
96 struct BodyCache *bc = mutt_bcache_open(&adata->conn->account, buf_string(mailbox));
97 buf_pool_release(&mailbox);
98
99 return bc;
100}
101
109static FILE *msg_cache_get(struct Mailbox *m, struct Email *e)
110{
112 struct ImapMboxData *mdata = imap_mdata_get(m);
113
114 if (!e || !adata || (adata->mailbox != m))
115 return NULL;
116
117 mdata->bcache = imap_bcache_open(m);
118 char id[64] = { 0 };
119 snprintf(id, sizeof(id), "%u-%u", mdata->uidvalidity, imap_edata_get(e)->uid);
120 return mutt_bcache_get(mdata->bcache, id);
121}
122
130static FILE *msg_cache_put(struct Mailbox *m, struct Email *e)
131{
133 struct ImapMboxData *mdata = imap_mdata_get(m);
134
135 if (!e || !adata || (adata->mailbox != m))
136 return NULL;
137
138 mdata->bcache = imap_bcache_open(m);
139 char id[64] = { 0 };
140 snprintf(id, sizeof(id), "%u-%u", mdata->uidvalidity, imap_edata_get(e)->uid);
141 return mutt_bcache_put(mdata->bcache, id);
142}
143
151static int msg_cache_commit(struct Mailbox *m, struct Email *e)
152{
154 struct ImapMboxData *mdata = imap_mdata_get(m);
155
156 if (!e || !adata || (adata->mailbox != m))
157 return -1;
158
159 mdata->bcache = imap_bcache_open(m);
160 char id[64] = { 0 };
161 snprintf(id, sizeof(id), "%u-%u", mdata->uidvalidity, imap_edata_get(e)->uid);
162
163 return mutt_bcache_commit(mdata->bcache, id);
164}
165
170static int imap_bcache_delete(const char *id, struct BodyCache *bcache, void *data)
171{
172 uint32_t uv;
173 unsigned int uid;
174 struct ImapMboxData *mdata = data;
175
176 if (sscanf(id, "%u-%u", &uv, &uid) != 2)
177 return 0;
178
179 /* bad UID */
180 if ((uv != mdata->uidvalidity) || !mutt_hash_int_find(mdata->uid_hash, uid))
182
183 return 0;
184}
185
193static char *msg_parse_flags(struct ImapHeader *h, char *s)
194{
195 struct ImapEmailData *edata = h->edata;
196
197 /* sanity-check string */
198 size_t plen = mutt_istr_startswith(s, "FLAGS");
199 if (plen == 0)
200 {
201 mutt_debug(LL_DEBUG1, "not a FLAGS response: %s\n", s);
202 return NULL;
203 }
204 s += plen;
205 SKIPWS(s);
206 if (*s != '(')
207 {
208 mutt_debug(LL_DEBUG1, "bogus FLAGS response: %s\n", s);
209 return NULL;
210 }
211 s++;
212
213 FREE(&edata->flags_system);
214 FREE(&edata->flags_remote);
215
216 edata->deleted = false;
217 edata->flagged = false;
218 edata->replied = false;
219 edata->read = false;
220 edata->old = false;
221
222 /* start parsing */
223 while (*s && (*s != ')'))
224 {
225 if ((plen = mutt_istr_startswith(s, "\\deleted")))
226 {
227 s += plen;
228 edata->deleted = true;
229 }
230 else if ((plen = mutt_istr_startswith(s, "\\flagged")))
231 {
232 s += plen;
233 edata->flagged = true;
234 }
235 else if ((plen = mutt_istr_startswith(s, "\\answered")))
236 {
237 s += plen;
238 edata->replied = true;
239 }
240 else if ((plen = mutt_istr_startswith(s, "\\seen")))
241 {
242 s += plen;
243 edata->read = true;
244 }
245 else if ((plen = mutt_istr_startswith(s, "\\recent")))
246 {
247 s += plen;
248 }
249 else if ((plen = mutt_istr_startswith(s, "old")))
250 {
251 s += plen;
252 edata->old = cs_subset_bool(NeoMutt->sub, "mark_old");
253 }
254 else
255 {
256 char ctmp;
257 char *flag_word = s;
258 bool is_system_keyword = mutt_istr_startswith(s, "\\");
259
260 while (*s && !isspace(*s) && (*s != ')'))
261 s++;
262
263 ctmp = *s;
264 *s = '\0';
265
266 struct Buffer *buf = buf_pool_get();
267 if (is_system_keyword)
268 {
269 /* store other system flags as well (mainly \\Draft) */
270 buf_addstr(buf, edata->flags_system);
271 buf_join_str(buf, flag_word, ' ');
272 edata->flags_system = buf_strdup(buf);
273 }
274 else
275 {
276 /* store custom flags as well */
277 buf_addstr(buf, edata->flags_remote);
278 buf_join_str(buf, flag_word, ' ');
279 edata->flags_remote = buf_strdup(buf);
280 }
281 buf_pool_release(&buf);
282
283 *s = ctmp;
284 }
285 SKIPWS(s);
286 }
287
288 /* wrap up, or note bad flags response */
289 if (*s == ')')
290 {
291 s++;
292 }
293 else
294 {
295 mutt_debug(LL_DEBUG1, "Unterminated FLAGS response: %s\n", s);
296 return NULL;
297 }
298
299 return s;
300}
301
310static int msg_parse_fetch(struct ImapHeader *h, char *s)
311{
312 if (!s)
313 return -1;
314
315 char tmp[128] = { 0 };
316 char *ptmp = NULL;
317 size_t plen = 0;
318
319 while (*s)
320 {
321 SKIPWS(s);
322
323 if (mutt_istr_startswith(s, "FLAGS"))
324 {
325 s = msg_parse_flags(h, s);
326 if (!s)
327 return -1;
328 }
329 else if ((plen = mutt_istr_startswith(s, "UID")))
330 {
331 s += plen;
332 SKIPWS(s);
333 if (!mutt_str_atoui(s, &h->edata->uid))
334 return -1;
335
336 s = imap_next_word(s);
337 }
338 else if ((plen = mutt_istr_startswith(s, "INTERNALDATE")))
339 {
340 s += plen;
341 SKIPWS(s);
342 if (*s != '\"')
343 {
344 mutt_debug(LL_DEBUG1, "bogus INTERNALDATE entry: %s\n", s);
345 return -1;
346 }
347 s++;
348 ptmp = tmp;
349 while (*s && (*s != '\"') && (ptmp != (tmp + sizeof(tmp) - 1)))
350 *ptmp++ = *s++;
351 if (*s != '\"')
352 return -1;
353 s++; /* skip past the trailing " */
354 *ptmp = '\0';
356 }
357 else if ((plen = mutt_istr_startswith(s, "RFC822.SIZE")))
358 {
359 s += plen;
360 SKIPWS(s);
361 ptmp = tmp;
362 while (isdigit((unsigned char) *s) && (ptmp != (tmp + sizeof(tmp) - 1)))
363 *ptmp++ = *s++;
364 *ptmp = '\0';
365 if (!mutt_str_atol(tmp, &h->content_length))
366 return -1;
367 }
368 else if (mutt_istr_startswith(s, "BODY") || mutt_istr_startswith(s, "RFC822.HEADER"))
369 {
370 /* handle above, in msg_fetch_header */
371 return -2;
372 }
373 else if ((plen = mutt_istr_startswith(s, "MODSEQ")))
374 {
375 s += plen;
376 SKIPWS(s);
377 if (*s != '(')
378 {
379 mutt_debug(LL_DEBUG1, "bogus MODSEQ response: %s\n", s);
380 return -1;
381 }
382 s++;
383 while (*s && (*s != ')'))
384 s++;
385 if (*s == ')')
386 {
387 s++;
388 }
389 else
390 {
391 mutt_debug(LL_DEBUG1, "Unterminated MODSEQ response: %s\n", s);
392 return -1;
393 }
394 }
395 else if (*s == ')')
396 {
397 s++; /* end of request */
398 }
399 else if (*s)
400 {
401 /* got something i don't understand */
402 imap_error("msg_parse_fetch", s);
403 return -1;
404 }
405 }
406
407 return 0;
408}
409
422static int msg_fetch_header(struct Mailbox *m, struct ImapHeader *ih, char *buf, FILE *fp)
423{
424 int rc = -1; /* default now is that string isn't FETCH response */
425
427
428 if (buf[0] != '*')
429 return rc;
430
431 /* skip to message number */
433 if (!mutt_str_atoui(buf, &ih->edata->msn))
434 return rc;
435
436 /* find FETCH tag */
438 if (!mutt_istr_startswith(buf, "FETCH"))
439 return rc;
440
441 rc = -2; /* we've got a FETCH response, for better or worse */
442 buf = strchr(buf, '(');
443 if (!buf)
444 return rc;
445 buf++;
446
447 /* FIXME: current implementation - call msg_parse_fetch - if it returns -2,
448 * read header lines and call it again. Silly. */
449 int parse_rc = msg_parse_fetch(ih, buf);
450 if (parse_rc == 0)
451 return 0;
452 if ((parse_rc != -2) || !fp)
453 return rc;
454
455 unsigned int bytes = 0;
456 if (imap_get_literal_count(buf, &bytes) == 0)
457 {
458 imap_read_literal(fp, adata, bytes, NULL);
459
460 /* we may have other fields of the FETCH _after_ the literal
461 * (eg Domino puts FLAGS here). Nothing wrong with that, either.
462 * This all has to go - we should accept literals and nonliterals
463 * interchangeably at any time. */
465 return rc;
466
467 if (msg_parse_fetch(ih, adata->buf) == -1)
468 return rc;
469 }
470
471 rc = 0; /* success */
472
473 /* subtract headers from message size - unfortunately only the subset of
474 * headers we've requested. */
475 ih->content_length -= bytes;
476
477 return rc;
478}
479
488static int flush_buffer(char *buf, size_t *len, struct Connection *conn)
489{
490 buf[*len] = '\0';
491 int rc = mutt_socket_write_n(conn, buf, *len);
492 *len = 0;
493 return rc;
494}
495
505{
506 bool abort = false;
507
509 /* L10N: This prompt is made if the user hits Ctrl-C when opening an IMAP mailbox */
510 if (query_yesorno(_("Abort download and close mailbox?"), MUTT_YES) == MUTT_YES)
511 {
512 abort = true;
514 }
515 SigInt = false;
516
517 return abort;
518}
519
528static void imap_alloc_uid_hash(struct ImapAccountData *adata, unsigned int msn_count)
529{
530 struct ImapMboxData *mdata = adata->mailbox->mdata;
531 if (!mdata->uid_hash)
532 mdata->uid_hash = mutt_hash_int_new(MAX(6 * msn_count / 5, 30), MUTT_HASH_NO_FLAGS);
533}
534
552static unsigned int imap_fetch_msn_seqset(struct Buffer *buf, struct ImapAccountData *adata,
553 bool evalhc, unsigned int msn_begin,
554 unsigned int msn_end, unsigned int *fetch_msn_end)
555{
556 struct ImapMboxData *mdata = adata->mailbox->mdata;
557 unsigned int max_headers_per_fetch = UINT_MAX;
558 bool first_chunk = true;
559 int state = 0; /* 1: single msn, 2: range of msn */
560 unsigned int msn;
561 unsigned int range_begin = 0;
562 unsigned int range_end = 0;
563 unsigned int msn_count = 0;
564
565 buf_reset(buf);
566 if (msn_end < msn_begin)
567 return 0;
568
569 const long c_imap_fetch_chunk_size = cs_subset_long(NeoMutt->sub, "imap_fetch_chunk_size");
570 if (c_imap_fetch_chunk_size > 0)
571 max_headers_per_fetch = c_imap_fetch_chunk_size;
572
573 if (!evalhc)
574 {
575 if ((msn_end - msn_begin + 1) <= max_headers_per_fetch)
576 *fetch_msn_end = msn_end;
577 else
578 *fetch_msn_end = msn_begin + max_headers_per_fetch - 1;
579 buf_printf(buf, "%u:%u", msn_begin, *fetch_msn_end);
580 return (*fetch_msn_end - msn_begin + 1);
581 }
582
583 for (msn = msn_begin; msn <= (msn_end + 1); msn++)
584 {
585 if ((msn_count < max_headers_per_fetch) && (msn <= msn_end) &&
586 !imap_msn_get(&mdata->msn, msn - 1))
587 {
588 msn_count++;
589
590 switch (state)
591 {
592 case 1: /* single: convert to a range */
593 state = 2;
595
596 case 2: /* extend range ending */
597 range_end = msn;
598 break;
599 default:
600 state = 1;
601 range_begin = msn;
602 break;
603 }
604 }
605 else if (state)
606 {
607 if (first_chunk)
608 first_chunk = false;
609 else
610 buf_addch(buf, ',');
611
612 if (state == 1)
613 buf_add_printf(buf, "%u", range_begin);
614 else if (state == 2)
615 buf_add_printf(buf, "%u:%u", range_begin, range_end);
616 state = 0;
617
618 if ((buf_len(buf) > 500) || (msn_count >= max_headers_per_fetch))
619 break;
620 }
621 }
622
623 /* The loop index goes one past to terminate the range if needed. */
624 *fetch_msn_end = msn - 1;
625
626 return msn_count;
627}
628
644static void set_changed_flag(struct Mailbox *m, struct Email *e, int local_changes,
645 bool *server_changes, enum MessageType flag_name,
646 bool old_hd_flag, bool new_hd_flag, bool h_flag)
647{
648 /* If there are local_changes, we only want to note if the server
649 * flags have changed, so we can set a reopen flag in
650 * cmd_parse_fetch(). We don't want to count a local modification
651 * to the header flag as a "change". */
652 if ((old_hd_flag == new_hd_flag) && (local_changes != 0))
653 return;
654
655 if (new_hd_flag == h_flag)
656 return;
657
658 if (server_changes)
659 *server_changes = true;
660
661 /* Local changes have priority */
662 if (local_changes == 0)
663 mutt_set_flag(m, e, flag_name, new_hd_flag, true);
664}
665
666#ifdef USE_HCACHE
685 unsigned int msn_end, unsigned int uid_next,
686 bool store_flag_updates, bool eval_condstore)
687{
688 struct Progress *progress = NULL;
689 char buf[1024] = { 0 };
690 int rc = -1;
691
692 struct Mailbox *m = adata->mailbox;
693 struct ImapMboxData *mdata = imap_mdata_get(m);
694 int idx = m->msg_count;
695
696 if (m->verbose)
697 {
698 /* L10N: Comparing the cached data with the IMAP server's data */
699 progress = progress_new(MUTT_PROGRESS_READ, msn_end);
700 progress_set_message(progress, _("Evaluating cache..."));
701 }
702
703 /* If we are using CONDSTORE's "FETCH CHANGEDSINCE", then we keep
704 * the flags in the header cache, and update them further below.
705 * Otherwise, we fetch the current state of the flags here. */
706 snprintf(buf, sizeof(buf), "UID FETCH 1:%u (UID%s)", uid_next - 1,
707 eval_condstore ? "" : " FLAGS");
708
709 imap_cmd_start(adata, buf);
710
712 int mfhrc = 0;
713 struct ImapHeader h = { 0 };
714 for (int msgno = 1; rc == IMAP_RES_CONTINUE; msgno++)
715 {
717 goto fail;
718
719 progress_update(progress, msgno, -1);
720
721 memset(&h, 0, sizeof(h));
722 h.edata = imap_edata_new();
723 do
724 {
725 rc = imap_cmd_step(adata);
726 if (rc != IMAP_RES_CONTINUE)
727 break;
728
729 mfhrc = msg_fetch_header(m, &h, adata->buf, NULL);
730 if (mfhrc < 0)
731 continue;
732
733 if (!h.edata->uid)
734 {
735 mutt_debug(LL_DEBUG2, "skipping hcache FETCH response for message number %d missing a UID\n",
736 h.edata->msn);
737 continue;
738 }
739
740 if ((h.edata->msn < 1) || (h.edata->msn > msn_end))
741 {
742 mutt_debug(LL_DEBUG1, "skipping hcache FETCH response for unknown message number %d\n",
743 h.edata->msn);
744 continue;
745 }
746
747 if (imap_msn_get(&mdata->msn, h.edata->msn - 1))
748 {
749 mutt_debug(LL_DEBUG2, "skipping hcache FETCH for duplicate message %d\n",
750 h.edata->msn);
751 continue;
752 }
753
754 struct Email *e = imap_hcache_get(mdata, h.edata->uid);
755 m->emails[idx] = e;
756 if (e)
757 {
758 imap_msn_set(&mdata->msn, h.edata->msn - 1, e);
759 mutt_hash_int_insert(mdata->uid_hash, h.edata->uid, e);
760
761 e->index = h.edata->uid;
762 /* messages which have not been expunged are ACTIVE (borrowed from mh
763 * folders) */
764 e->active = true;
765 e->changed = false;
766 if (eval_condstore)
767 {
768 h.edata->read = e->read;
769 h.edata->old = e->old;
770 h.edata->deleted = e->deleted;
771 h.edata->flagged = e->flagged;
772 h.edata->replied = e->replied;
773 }
774 else
775 {
776 e->read = h.edata->read;
777 e->old = h.edata->old;
778 e->deleted = h.edata->deleted;
779 e->flagged = h.edata->flagged;
780 e->replied = h.edata->replied;
781 }
782
783 /* mailbox->emails[msgno]->received is restored from hcache_fetch_email() */
784 e->edata = h.edata;
786
787 /* We take a copy of the tags so we can split the string */
788 char *tags_copy = mutt_str_dup(h.edata->flags_remote);
789 driver_tags_replace(&e->tags, tags_copy);
790 FREE(&tags_copy);
791
792 m->msg_count++;
793 mailbox_size_add(m, e);
794
795 /* If this is the first time we are fetching, we need to
796 * store the current state of flags back into the header cache */
797 if (!eval_condstore && store_flag_updates)
798 imap_hcache_put(mdata, e);
799
800 h.edata = NULL;
801 idx++;
802 }
803 } while (mfhrc == -1);
804
805 imap_edata_free((void **) &h.edata);
806
807 if ((mfhrc < -1) || ((rc != IMAP_RES_CONTINUE) && (rc != IMAP_RES_OK)))
808 goto fail;
809 }
810
811 rc = 0;
812fail:
813 progress_free(&progress);
814 return rc;
815}
816
829static int read_headers_qresync_eval_cache(struct ImapAccountData *adata, char *uid_seqset)
830{
831 int rc;
832 unsigned int uid = 0;
833
834 mutt_debug(LL_DEBUG2, "Reading uid seqset from header cache\n");
835 struct Mailbox *m = adata->mailbox;
836 struct ImapMboxData *mdata = adata->mailbox->mdata;
837 unsigned int msn = 1;
838
839 if (m->verbose)
840 mutt_message(_("Evaluating cache..."));
841
842 struct SeqsetIterator *iter = mutt_seqset_iterator_new(uid_seqset);
843 if (!iter)
844 return -1;
845
846 while ((rc = mutt_seqset_iterator_next(iter, &uid)) == 0)
847 {
848 /* The seqset may contain more headers than the fetch request, so
849 * we need to watch and reallocate the context and msn_index */
850 imap_msn_reserve(&mdata->msn, msn);
851
852 struct Email *e = imap_hcache_get(mdata, uid);
853 if (e)
854 {
855 imap_msn_set(&mdata->msn, msn - 1, e);
856
858
860 e->edata = edata;
862
863 e->index = uid;
864 e->active = true;
865 e->changed = false;
866 edata->read = e->read;
867 edata->old = e->old;
868 edata->deleted = e->deleted;
869 edata->flagged = e->flagged;
870 edata->replied = e->replied;
871
872 edata->msn = msn;
873 edata->uid = uid;
875
876 mailbox_size_add(m, e);
877 m->emails[m->msg_count++] = e;
878
879 msn++;
880 }
881 else if (!uid)
882 {
883 /* A non-zero uid missing from the header cache is either the
884 * result of an expunged message (not recorded in the uid seqset)
885 * or a hole in the header cache.
886 *
887 * We have to assume it's an earlier expunge and compact the msn's
888 * in that case, because cmd_parse_vanished() won't find it in the
889 * uid_hash and decrement later msn's there.
890 *
891 * Thus we only increment the uid if the uid was 0: an actual
892 * stored "blank" in the uid seqset.
893 */
894 msn++;
895 }
896 }
897
899
900 return rc;
901}
902
916 unsigned int msn_end, unsigned int uid_next,
917 unsigned long long hc_modseq, bool eval_qresync)
918{
919 struct Progress *progress = NULL;
920 char buf[1024] = { 0 };
921 unsigned int header_msn = 0;
922
923 struct Mailbox *m = adata->mailbox;
924 struct ImapMboxData *mdata = imap_mdata_get(m);
925
926 if (m->verbose)
927 {
928 /* L10N: Fetching IMAP flag changes, using the CONDSTORE extension */
929 progress = progress_new(MUTT_PROGRESS_READ, msn_end);
930 progress_set_message(progress, _("Fetching flag updates..."));
931 }
932
933 snprintf(buf, sizeof(buf), "UID FETCH 1:%u (FLAGS) (CHANGEDSINCE %llu%s)",
934 uid_next - 1, hc_modseq, eval_qresync ? " VANISHED" : "");
935
936 imap_cmd_start(adata, buf);
937
938 int rc = IMAP_RES_CONTINUE;
939 for (int msgno = 1; rc == IMAP_RES_CONTINUE; msgno++)
940 {
942 goto fail;
943
944 progress_update(progress, msgno, -1);
945
946 /* cmd_parse_fetch will update the flags */
947 rc = imap_cmd_step(adata);
948 if (rc != IMAP_RES_CONTINUE)
949 break;
950
951 /* so we just need to grab the header and persist it back into
952 * the header cache */
953 char *fetch_buf = adata->buf;
954 if (fetch_buf[0] != '*')
955 continue;
956
957 fetch_buf = imap_next_word(fetch_buf);
958 if (!isdigit((unsigned char) *fetch_buf) || !mutt_str_atoui(fetch_buf, &header_msn))
959 continue;
960
961 if ((header_msn < 1) || (header_msn > msn_end) ||
962 !imap_msn_get(&mdata->msn, header_msn - 1))
963 {
964 mutt_debug(LL_DEBUG1, "skipping CONDSTORE flag update for unknown message number %u\n",
965 header_msn);
966 continue;
967 }
968
969 imap_hcache_put(mdata, imap_msn_get(&mdata->msn, header_msn - 1));
970 }
971
972 if (rc != IMAP_RES_OK)
973 goto fail;
974
975 /* The IMAP flag setting as part of cmd_parse_fetch() ends up
976 * flipping these on. */
977 mdata->check_status &= ~IMAP_FLAGS_PENDING;
978 m->changed = false;
979
980 /* VANISHED handling: we need to empty out the messages */
981 if (mdata->reopen & IMAP_EXPUNGE_PENDING)
982 {
984 imap_expunge_mailbox(m, false);
985
986 imap_hcache_open(adata, mdata);
987 mdata->reopen &= ~IMAP_EXPUNGE_PENDING;
988 }
989
990 /* undo expunge count updates.
991 * mview_update() will do this at the end of the header fetch. */
992 m->vcount = 0;
993 m->msg_tagged = 0;
994 m->msg_deleted = 0;
995 m->msg_new = 0;
996 m->msg_unread = 0;
997 m->msg_flagged = 0;
998 m->changed = false;
999
1000 rc = 0;
1001fail:
1002 progress_free(&progress);
1003 return rc;
1004}
1005
1014static int imap_verify_qresync(struct Mailbox *m)
1015{
1016 assert(m);
1018 struct ImapMboxData *mdata = imap_mdata_get(m);
1019 if (!adata || (adata->mailbox != m))
1020 return -1;
1021
1022 const size_t max_msn = imap_msn_highest(&mdata->msn);
1023
1024 unsigned int msn;
1025 unsigned int uid;
1026 struct Email *e = NULL;
1027 struct Email *uidh = NULL;
1028
1029 for (int i = 0; i < m->msg_count; i++)
1030 {
1031 e = m->emails[i];
1032 const struct ImapEmailData *edata = imap_edata_get(e);
1033 if (!edata)
1034 goto fail;
1035
1036 msn = imap_edata_get(e)->msn;
1037 uid = imap_edata_get(e)->uid;
1038
1039 if ((msn < 1) || (msn > max_msn) || imap_msn_get(&mdata->msn, msn - 1) != e)
1040 goto fail;
1041
1042 uidh = (struct Email *) mutt_hash_int_find(mdata->uid_hash, uid);
1043 if (uidh != e)
1044 goto fail;
1045 }
1046
1047 return 0;
1048
1049fail:
1050 imap_msn_free(&mdata->msn);
1051 mutt_hash_free(&mdata->uid_hash);
1055
1056 for (int i = 0; i < m->msg_count; i++)
1057 {
1058 if (m->emails[i] && m->emails[i]->edata)
1059 imap_edata_free(&m->emails[i]->edata);
1060 email_free(&m->emails[i]);
1061 }
1062 m->msg_count = 0;
1063 m->size = 0;
1064 hcache_delete_raw(mdata->hcache, "MODSEQ", 6);
1066 imap_hcache_close(mdata);
1067
1068 if (m->verbose)
1069 {
1070 /* L10N: After opening an IMAP mailbox using QRESYNC, Mutt performs a quick
1071 sanity check. If that fails, Mutt reopens the mailbox using a normal
1072 download. */
1073 mutt_error(_("QRESYNC failed. Reopening mailbox."));
1074 }
1075 return -1;
1076}
1077
1078#endif /* USE_HCACHE */
1079
1091static int read_headers_fetch_new(struct Mailbox *m, unsigned int msn_begin,
1092 unsigned int msn_end, bool evalhc,
1093 unsigned int *maxuid, bool initial_download)
1094{
1095 int rc = -1;
1096 unsigned int fetch_msn_end = 0;
1097 struct Progress *progress = NULL;
1098 char *hdrreq = NULL;
1099 struct Buffer *tempfile = NULL;
1100 FILE *fp = NULL;
1101 struct ImapHeader h = { 0 };
1102 struct Buffer *buf = NULL;
1103 static const char *const want_headers = "DATE FROM SENDER SUBJECT TO CC MESSAGE-ID REFERENCES "
1104 "CONTENT-TYPE CONTENT-DESCRIPTION IN-REPLY-TO REPLY-TO "
1105 "LINES LIST-POST LIST-SUBSCRIBE LIST-UNSUBSCRIBE X-LABEL "
1106 "X-ORIGINAL-TO";
1107
1109 struct ImapMboxData *mdata = imap_mdata_get(m);
1110 struct ImapEmailData *edata = NULL;
1111
1112 if (!adata || (adata->mailbox != m))
1113 return -1;
1114
1115 struct Buffer *hdr_list = buf_pool_get();
1116 buf_strcpy(hdr_list, want_headers);
1117 const char *const c_imap_headers = cs_subset_string(NeoMutt->sub, "imap_headers");
1118 if (c_imap_headers)
1119 {
1120 buf_addch(hdr_list, ' ');
1121 buf_addstr(hdr_list, c_imap_headers);
1122 }
1123#ifdef USE_AUTOCRYPT
1124 const bool c_autocrypt = cs_subset_bool(NeoMutt->sub, "autocrypt");
1125 if (c_autocrypt)
1126 {
1127 buf_addch(hdr_list, ' ');
1128 buf_addstr(hdr_list, "AUTOCRYPT");
1129 }
1130#endif
1131
1132 if (adata->capabilities & IMAP_CAP_IMAP4REV1)
1133 {
1134 mutt_str_asprintf(&hdrreq, "BODY.PEEK[HEADER.FIELDS (%s)]", buf_string(hdr_list));
1135 }
1136 else if (adata->capabilities & IMAP_CAP_IMAP4)
1137 {
1138 mutt_str_asprintf(&hdrreq, "RFC822.HEADER.LINES (%s)", buf_string(hdr_list));
1139 }
1140 else
1141 { /* Unable to fetch headers for lower versions */
1142 mutt_error(_("Unable to fetch headers from this IMAP server version"));
1143 goto bail;
1144 }
1145
1146 buf_pool_release(&hdr_list);
1147
1148 /* instead of downloading all headers and then parsing them, we parse them
1149 * as they come in. */
1150 tempfile = buf_pool_get();
1151 buf_mktemp(tempfile);
1152 fp = mutt_file_fopen(buf_string(tempfile), "w+");
1153 if (!fp)
1154 {
1155 mutt_error(_("Could not create temporary file %s"), buf_string(tempfile));
1156 goto bail;
1157 }
1158 unlink(buf_string(tempfile));
1159 buf_pool_release(&tempfile);
1160
1161 if (m->verbose)
1162 {
1163 progress = progress_new(MUTT_PROGRESS_READ, msn_end);
1164 progress_set_message(progress, _("Fetching message headers..."));
1165 }
1166
1167 buf = buf_pool_get();
1168
1169 /* NOTE:
1170 * The (fetch_msn_end < msn_end) used to be important to prevent
1171 * an infinite loop, in the event the server did not return all
1172 * the headers (due to a pending expunge, for example).
1173 *
1174 * I believe the new chunking imap_fetch_msn_seqset()
1175 * implementation and "msn_begin = fetch_msn_end + 1" assignment
1176 * at the end of the loop makes the comparison unneeded, but to be
1177 * cautious I'm keeping it.
1178 */
1179 edata = imap_edata_new();
1180 while ((fetch_msn_end < msn_end) &&
1181 imap_fetch_msn_seqset(buf, adata, evalhc, msn_begin, msn_end, &fetch_msn_end))
1182 {
1183 char *cmd = NULL;
1184 mutt_str_asprintf(&cmd, "FETCH %s (UID FLAGS INTERNALDATE RFC822.SIZE %s)",
1185 buf_string(buf), hdrreq);
1186 imap_cmd_start(adata, cmd);
1187 FREE(&cmd);
1188
1189 int msgno = msn_begin;
1190
1191 while (true)
1192 {
1193 rewind(fp);
1194 memset(&h, 0, sizeof(h));
1195 h.edata = edata;
1196
1197 if (initial_download && SigInt && query_abort_header_download(adata))
1198 {
1199 goto bail;
1200 }
1201
1202 const int rc2 = imap_cmd_step(adata);
1203 if (rc2 != IMAP_RES_CONTINUE)
1204 {
1205 if (rc2 != IMAP_RES_OK)
1206 {
1207 goto bail;
1208 }
1209 break;
1210 }
1211
1212 switch (msg_fetch_header(m, &h, adata->buf, fp))
1213 {
1214 case 0:
1215 break;
1216 case -1:
1217 continue;
1218 case -2:
1219 goto bail;
1220 }
1221
1222 if (!ftello(fp))
1223 {
1224 mutt_debug(LL_DEBUG2, "ignoring fetch response with no body\n");
1225 continue;
1226 }
1227
1228 /* make sure we don't get remnants from older larger message headers */
1229 fputs("\n\n", fp);
1230
1231 if ((h.edata->msn < 1) || (h.edata->msn > fetch_msn_end))
1232 {
1233 mutt_debug(LL_DEBUG1, "skipping FETCH response for unknown message number %d\n",
1234 h.edata->msn);
1235 continue;
1236 }
1237
1238 /* May receive FLAGS updates in a separate untagged response */
1239 if (imap_msn_get(&mdata->msn, h.edata->msn - 1))
1240 {
1241 mutt_debug(LL_DEBUG2, "skipping FETCH response for duplicate message %d\n",
1242 h.edata->msn);
1243 continue;
1244 }
1245
1246 progress_update(progress, msgno++, -1);
1247
1248 struct Email *e = email_new();
1250
1251 m->emails[m->msg_count++] = e;
1252
1253 imap_msn_set(&mdata->msn, h.edata->msn - 1, e);
1254 mutt_hash_int_insert(mdata->uid_hash, h.edata->uid, e);
1255
1256 e->index = h.edata->uid;
1257 /* messages which have not been expunged are ACTIVE (borrowed from mh
1258 * folders) */
1259 e->active = true;
1260 e->changed = false;
1261 e->read = h.edata->read;
1262 e->old = h.edata->old;
1263 e->deleted = h.edata->deleted;
1264 e->flagged = h.edata->flagged;
1265 e->replied = h.edata->replied;
1266 e->received = h.received;
1267 e->edata = (void *) imap_edata_clone(h.edata);
1269 STAILQ_INIT(&e->tags);
1270
1271 /* We take a copy of the tags so we can split the string */
1272 char *tags_copy = mutt_str_dup(h.edata->flags_remote);
1273 driver_tags_replace(&e->tags, tags_copy);
1274 FREE(&tags_copy);
1275
1276 if (*maxuid < h.edata->uid)
1277 *maxuid = h.edata->uid;
1278
1279 rewind(fp);
1280 /* NOTE: if Date: header is missing, mutt_rfc822_read_header depends
1281 * on h.received being set */
1282 e->env = mutt_rfc822_read_header(fp, e, false, false);
1283 /* body built as a side-effect of mutt_rfc822_read_header */
1284 e->body->length = h.content_length;
1285 mailbox_size_add(m, e);
1286
1287#ifdef USE_HCACHE
1288 imap_hcache_put(mdata, e);
1289#endif /* USE_HCACHE */
1290 }
1291
1292 /* In case we get new mail while fetching the headers. */
1293 if (mdata->reopen & IMAP_NEWMAIL_PENDING)
1294 {
1295 msn_end = mdata->new_mail_count;
1296 mx_alloc_memory(m, msn_end);
1297 imap_msn_reserve(&mdata->msn, msn_end);
1298 mdata->reopen &= ~IMAP_NEWMAIL_PENDING;
1299 mdata->new_mail_count = 0;
1300 }
1301
1302 /* Note: RFC3501 section 7.4.1 and RFC7162 section 3.2.10.2 say we
1303 * must not get any EXPUNGE/VANISHED responses in the middle of a
1304 * FETCH, nor when no command is in progress (e.g. between the
1305 * chunked FETCH commands). We previously tried to be robust by
1306 * setting:
1307 * msn_begin = mdata->max_msn + 1;
1308 * but with chunking and header cache holes this
1309 * may not be correct. So here we must assume the msn values have
1310 * not been altered during or after the fetch. */
1311 msn_begin = fetch_msn_end + 1;
1312 }
1313
1314 rc = 0;
1315
1316bail:
1317 buf_pool_release(&hdr_list);
1318 buf_pool_release(&buf);
1319 buf_pool_release(&tempfile);
1320 mutt_file_fclose(&fp);
1321 FREE(&hdrreq);
1322 imap_edata_free((void **) &edata);
1323 progress_free(&progress);
1324
1325 return rc;
1326}
1327
1341int imap_read_headers(struct Mailbox *m, unsigned int msn_begin,
1342 unsigned int msn_end, bool initial_download)
1343{
1344 unsigned int maxuid = 0;
1345 int rc = -1;
1346 bool evalhc = false;
1347
1348#ifdef USE_HCACHE
1349 uint32_t uidvalidity = 0;
1350 unsigned int uid_next = 0;
1351 unsigned long long modseq = 0;
1352 bool has_condstore = false;
1353 bool has_qresync = false;
1354 bool eval_condstore = false;
1355 bool eval_qresync = false;
1356 char *uid_seqset = NULL;
1357 const unsigned int msn_begin_save = msn_begin;
1358#endif /* USE_HCACHE */
1359
1361 struct ImapMboxData *mdata = imap_mdata_get(m);
1362 if (!adata || (adata->mailbox != m))
1363 return -1;
1364
1365#ifdef USE_HCACHE
1366retry:
1367#endif /* USE_HCACHE */
1368
1369 /* make sure context has room to hold the mailbox */
1370 mx_alloc_memory(m, msn_end);
1371 imap_msn_reserve(&mdata->msn, msn_end);
1372 imap_alloc_uid_hash(adata, msn_end);
1373
1375 mdata->new_mail_count = 0;
1376
1377#ifdef USE_HCACHE
1378 imap_hcache_open(adata, mdata);
1379
1380 if (mdata->hcache && initial_download)
1381 {
1382 hcache_fetch_raw_obj(mdata->hcache, "UIDVALIDITY", 11, &uidvalidity);
1383 hcache_fetch_raw_obj(mdata->hcache, "UIDNEXT", 7, &uid_next);
1384 if (mdata->modseq)
1385 {
1386 const bool c_imap_condstore = cs_subset_bool(NeoMutt->sub, "imap_condstore");
1387 if ((adata->capabilities & IMAP_CAP_CONDSTORE) && c_imap_condstore)
1388 has_condstore = true;
1389
1390 /* If IMAP_CAP_QRESYNC and ImapQResync then NeoMutt sends ENABLE QRESYNC.
1391 * If we receive an ENABLED response back, then adata->qresync is set. */
1392 if (adata->qresync)
1393 has_qresync = true;
1394 }
1395
1396 if (uidvalidity && uid_next && uidvalidity == mdata->uidvalidity)
1397 {
1398 evalhc = true;
1399 if (hcache_fetch_raw_obj(mdata->hcache, "MODSEQ", 6, &modseq))
1400 {
1401 if (has_qresync)
1402 {
1403 uid_seqset = imap_hcache_get_uid_seqset(mdata);
1404 if (uid_seqset)
1405 eval_qresync = true;
1406 }
1407
1408 if (!eval_qresync && has_condstore)
1409 eval_condstore = true;
1410 }
1411 }
1412 }
1413 if (evalhc)
1414 {
1415 if (eval_qresync)
1416 {
1417 if (read_headers_qresync_eval_cache(adata, uid_seqset) < 0)
1418 goto bail;
1419 }
1420 else
1421 {
1422 if (read_headers_normal_eval_cache(adata, msn_end, uid_next, has_condstore || has_qresync,
1423 eval_condstore) < 0)
1424 goto bail;
1425 }
1426
1427 if ((eval_condstore || eval_qresync) && (modseq != mdata->modseq))
1428 {
1430 modseq, eval_qresync) < 0)
1431 {
1432 goto bail;
1433 }
1434 }
1435
1436 /* Look for the first empty MSN and start there */
1437 while (msn_begin <= msn_end)
1438 {
1439 if (!imap_msn_get(&mdata->msn, msn_begin - 1))
1440 break;
1441 msn_begin++;
1442 }
1443 }
1444#endif /* USE_HCACHE */
1445
1446 if (read_headers_fetch_new(m, msn_begin, msn_end, evalhc, &maxuid, initial_download) < 0)
1447 goto bail;
1448
1449#ifdef USE_HCACHE
1450 if (eval_qresync && initial_download)
1451 {
1452 if (imap_verify_qresync(m) != 0)
1453 {
1454 eval_qresync = false;
1455 eval_condstore = false;
1456 evalhc = false;
1457 modseq = 0;
1458 maxuid = 0;
1459 FREE(&uid_seqset);
1460 uidvalidity = 0;
1461 uid_next = 0;
1462 msn_begin = msn_begin_save;
1463
1464 goto retry;
1465 }
1466 }
1467#endif /* USE_HCACHE */
1468
1469 if (maxuid && (mdata->uid_next < maxuid + 1))
1470 mdata->uid_next = maxuid + 1;
1471
1472#ifdef USE_HCACHE
1473 hcache_store_raw(mdata->hcache, "UIDVALIDITY", 11, &mdata->uidvalidity,
1474 sizeof(mdata->uidvalidity));
1475 if (maxuid && (mdata->uid_next < maxuid + 1))
1476 {
1477 mutt_debug(LL_DEBUG2, "Overriding UIDNEXT: %u -> %u\n", mdata->uid_next, maxuid + 1);
1478 mdata->uid_next = maxuid + 1;
1479 }
1480 if (mdata->uid_next > 1)
1481 {
1482 hcache_store_raw(mdata->hcache, "UIDNEXT", 7, &mdata->uid_next, sizeof(mdata->uid_next));
1483 }
1484
1485 /* We currently only sync CONDSTORE and QRESYNC on the initial download.
1486 * To do it more often, we'll need to deal with flag updates combined with
1487 * unsync'ed local flag changes. We'll also need to properly sync flags to
1488 * the header cache on close. I'm not sure it's worth the added complexity. */
1489 if (initial_download)
1490 {
1491 if (has_condstore || has_qresync)
1492 {
1493 hcache_store_raw(mdata->hcache, "MODSEQ", 6, &mdata->modseq, sizeof(mdata->modseq));
1494 }
1495 else
1496 {
1497 hcache_delete_raw(mdata->hcache, "MODSEQ", 6);
1498 }
1499
1500 if (has_qresync)
1502 else
1504 }
1505#endif /* USE_HCACHE */
1506
1507 /* TODO: it's not clear to me why we are calling mx_alloc_memory yet again. */
1509
1510 mdata->reopen |= IMAP_REOPEN_ALLOW;
1511
1512 rc = msn_end;
1513
1514bail:
1515#ifdef USE_HCACHE
1517 FREE(&uid_seqset);
1518#endif /* USE_HCACHE */
1519
1520 return rc;
1521}
1522
1530int imap_append_message(struct Mailbox *m, struct Message *msg)
1531{
1532 if (!m || !msg)
1533 return -1;
1534
1535 FILE *fp = NULL;
1536 char buf[2048] = { 0 };
1537 struct Buffer *internaldate = NULL;
1538 char imap_flags[128] = { 0 };
1539 size_t len;
1540 struct Progress *progress = NULL;
1541 size_t sent;
1542 int c, last;
1543 int rc;
1544
1546 struct ImapMboxData *mdata = imap_mdata_get(m);
1547
1548 fp = mutt_file_fopen(msg->path, "r");
1549 if (!fp)
1550 {
1551 mutt_perror("%s", msg->path);
1552 goto fail;
1553 }
1554
1555 /* currently we set the \Seen flag on all messages, but probably we
1556 * should scan the message Status header for flag info. Since we're
1557 * already rereading the whole file for length it isn't any more
1558 * expensive (it'd be nice if we had the file size passed in already
1559 * by the code that writes the file, but that's a lot of changes.
1560 * Ideally we'd have an Email structure with flag info here... */
1561 for (last = EOF, len = 0; (c = fgetc(fp)) != EOF; last = c)
1562 {
1563 if ((c == '\n') && (last != '\r'))
1564 len++;
1565
1566 len++;
1567 }
1568 rewind(fp);
1569
1570 if (m->verbose)
1571 {
1572 progress = progress_new(MUTT_PROGRESS_NET, len);
1573 progress_set_message(progress, _("Uploading message..."));
1574 }
1575
1576 internaldate = buf_pool_get();
1577 mutt_date_make_imap(internaldate, msg->received);
1578
1579 imap_flags[0] = '\0';
1580 imap_flags[1] = '\0';
1581
1582 if (msg->flags.read)
1583 mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Seen");
1584 if (msg->flags.replied)
1585 mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Answered");
1586 if (msg->flags.flagged)
1587 mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Flagged");
1588 if (msg->flags.draft)
1589 mutt_str_cat(imap_flags, sizeof(imap_flags), " \\Draft");
1590
1591 snprintf(buf, sizeof(buf), "APPEND %s (%s) \"%s\" {%lu}", mdata->munge_name,
1592 imap_flags + 1, buf_string(internaldate), (unsigned long) len);
1593 buf_pool_release(&internaldate);
1594
1595 imap_cmd_start(adata, buf);
1596
1597 do
1598 {
1599 rc = imap_cmd_step(adata);
1600 } while (rc == IMAP_RES_CONTINUE);
1601
1602 if (rc != IMAP_RES_RESPOND)
1603 goto cmd_step_fail;
1604
1605 for (last = EOF, sent = len = 0; (c = fgetc(fp)) != EOF; last = c)
1606 {
1607 if ((c == '\n') && (last != '\r'))
1608 buf[len++] = '\r';
1609
1610 buf[len++] = c;
1611
1612 if (len > sizeof(buf) - 3)
1613 {
1614 sent += len;
1615 if (flush_buffer(buf, &len, adata->conn) < 0)
1616 goto fail;
1617 progress_update(progress, sent, -1);
1618 }
1619 }
1620
1621 if (len)
1622 if (flush_buffer(buf, &len, adata->conn) < 0)
1623 goto fail;
1624
1625 if (mutt_socket_send(adata->conn, "\r\n") < 0)
1626 goto fail;
1627 mutt_file_fclose(&fp);
1628
1629 do
1630 {
1631 rc = imap_cmd_step(adata);
1632 } while (rc == IMAP_RES_CONTINUE);
1633
1634 if (rc != IMAP_RES_OK)
1635 goto cmd_step_fail;
1636
1637 progress_free(&progress);
1638 return 0;
1639
1640cmd_step_fail:
1641 mutt_debug(LL_DEBUG1, "command failed: %s\n", adata->buf);
1642 if (rc != IMAP_RES_BAD)
1643 {
1644 char *pc = imap_next_word(adata->buf); /* skip sequence number or token */
1645 pc = imap_next_word(pc); /* skip response code */
1646 if (*pc != '\0')
1647 mutt_error("%s", pc);
1648 }
1649
1650fail:
1651 mutt_file_fclose(&fp);
1652 progress_free(&progress);
1653 return -1;
1654}
1655
1662static int emails_to_uid_array(struct EmailArray *ea, struct UidArray *uida)
1663{
1664 struct Email **ep = NULL;
1665 ARRAY_FOREACH(ep, ea)
1666 {
1667 struct Email *e = *ep;
1668 struct ImapEmailData *edata = imap_edata_get(e);
1669
1670 ARRAY_ADD(uida, edata->uid);
1671 }
1672 ARRAY_SORT(uida, imap_sort_uid, NULL);
1673
1674 return ARRAY_SIZE(uida);
1675}
1676
1687int imap_copy_messages(struct Mailbox *m, struct EmailArray *ea,
1688 const char *dest, enum MessageSaveOpt save_opt)
1689{
1690 if (!m || !ea || ARRAY_EMPTY(ea) || !dest)
1691 return -1;
1692
1693 char buf[PATH_MAX] = { 0 };
1694 char mbox[PATH_MAX] = { 0 };
1695 char mmbox[PATH_MAX] = { 0 };
1696 char prompt[PATH_MAX + 64];
1697 int rc;
1698 struct ConnAccount cac = { { 0 } };
1699 enum QuadOption err_continue = MUTT_NO;
1700 int triedcreate = 0;
1701 struct Email *e_cur = *ARRAY_GET(ea, 0);
1702 bool single = (ARRAY_SIZE(ea) == 1);
1704
1705 if (single && e_cur->attach_del)
1706 {
1707 mutt_debug(LL_DEBUG3, "#1 Message contains attachments to be deleted\n");
1708 return 1;
1709 }
1710
1711 if (imap_parse_path(dest, &cac, buf, sizeof(buf)))
1712 {
1713 mutt_debug(LL_DEBUG1, "bad destination %s\n", dest);
1714 return -1;
1715 }
1716
1717 /* check that the save-to folder is in the same account */
1718 if (!imap_account_match(&adata->conn->account, &cac))
1719 {
1720 mutt_debug(LL_DEBUG3, "%s not same server as %s\n", dest, mailbox_path(m));
1721 return 1;
1722 }
1723
1724 imap_fix_path(adata->delim, buf, mbox, sizeof(mbox));
1725 if (*mbox == '\0')
1726 mutt_str_copy(mbox, "INBOX", sizeof(mbox));
1727 imap_munge_mbox_name(adata->unicode, mmbox, sizeof(mmbox), mbox);
1728
1729 /* loop in case of TRYCREATE */
1730 struct Buffer *cmd = buf_pool_get();
1731 struct Buffer *sync_cmd = buf_pool_get();
1732 do
1733 {
1734 buf_reset(sync_cmd);
1735 buf_reset(cmd);
1736
1737 if (single)
1738 {
1739 mutt_message(_("Copying message %d to %s..."), e_cur->index + 1, mbox);
1740 buf_add_printf(cmd, "UID COPY %u %s", imap_edata_get(e_cur)->uid, mmbox);
1741
1742 if (e_cur->active && e_cur->changed)
1743 {
1744 rc = imap_sync_message_for_copy(m, e_cur, sync_cmd, &err_continue);
1745 if (rc < 0)
1746 {
1747 mutt_debug(LL_DEBUG1, "#2 could not sync\n");
1748 goto out;
1749 }
1750 }
1751 rc = imap_exec(adata, buf_string(cmd), IMAP_CMD_QUEUE);
1752 if (rc != IMAP_EXEC_SUCCESS)
1753 {
1754 mutt_debug(LL_DEBUG1, "#2 could not queue copy\n");
1755 goto out;
1756 }
1757 }
1758 else /* copy tagged messages */
1759 {
1760 /* if any messages have attachments to delete, fall through to FETCH
1761 * and APPEND. TODO: Copy what we can with COPY, fall through for the
1762 * remainder. */
1763 struct Email **ep = NULL;
1764 ARRAY_FOREACH(ep, ea)
1765 {
1766 struct Email *e = *ep;
1767 if (e->attach_del)
1768 {
1769 mutt_debug(LL_DEBUG3, "#2 Message contains attachments to be deleted\n");
1770 rc = 1;
1771 goto out;
1772 }
1773
1774 if (e->active && e->changed)
1775 {
1776 rc = imap_sync_message_for_copy(m, e, sync_cmd, &err_continue);
1777 if (rc < 0)
1778 {
1779 mutt_debug(LL_DEBUG1, "#1 could not sync\n");
1780 goto out;
1781 }
1782 }
1783 }
1784
1785 struct UidArray uida = ARRAY_HEAD_INITIALIZER;
1786 emails_to_uid_array(ea, &uida);
1787 rc = imap_exec_msg_set(adata, "UID COPY", mmbox, &uida);
1788 ARRAY_FREE(&uida);
1789
1790 if (rc == 0)
1791 {
1792 mutt_debug(LL_DEBUG1, "No messages tagged\n");
1793 rc = -1;
1794 goto out;
1795 }
1796 else if (rc < 0)
1797 {
1798 mutt_debug(LL_DEBUG1, "#1 could not queue copy\n");
1799 goto out;
1800 }
1801 else
1802 {
1803 mutt_message(ngettext("Copying %d message to %s...", "Copying %d messages to %s...", rc),
1804 rc, mbox);
1805 }
1806 }
1807
1808 /* let's get it on */
1809 rc = imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS);
1810 if (rc == IMAP_EXEC_ERROR)
1811 {
1812 if (triedcreate)
1813 {
1814 mutt_debug(LL_DEBUG1, "Already tried to create mailbox %s\n", mbox);
1815 break;
1816 }
1817 /* bail out if command failed for reasons other than nonexistent target */
1818 if (!mutt_istr_startswith(imap_get_qualifier(adata->buf), "[TRYCREATE]"))
1819 break;
1820 mutt_debug(LL_DEBUG3, "server suggests TRYCREATE\n");
1821 snprintf(prompt, sizeof(prompt), _("Create %s?"), mbox);
1822 const bool c_confirm_create = cs_subset_bool(NeoMutt->sub, "confirm_create");
1823 if (c_confirm_create &&
1824 (query_yesorno_help(prompt, MUTT_YES, NeoMutt->sub, "confirm_create") != MUTT_YES))
1825 {
1827 goto out;
1828 }
1829 if (imap_create_mailbox(adata, mbox) < 0)
1830 break;
1831 triedcreate = 1;
1832 }
1833 } while (rc == IMAP_EXEC_ERROR);
1834
1835 if (rc != 0)
1836 {
1837 imap_error("imap_copy_messages", adata->buf);
1838 goto out;
1839 }
1840
1841 /* cleanup */
1842 if (save_opt == SAVE_MOVE)
1843 {
1844 struct Email **ep = NULL;
1845 ARRAY_FOREACH(ep, ea)
1846 {
1847 struct Email *e = *ep;
1848 mutt_set_flag(m, e, MUTT_DELETE, true, true);
1849 mutt_set_flag(m, e, MUTT_PURGE, true, true);
1850 }
1851 }
1852
1853 rc = 0;
1854
1855out:
1856 buf_pool_release(&cmd);
1857 buf_pool_release(&sync_cmd);
1858
1859 return (rc < 0) ? -1 : rc;
1860}
1861
1869int imap_cache_del(struct Mailbox *m, struct Email *e)
1870{
1872 struct ImapMboxData *mdata = imap_mdata_get(m);
1873
1874 if (!e || !adata || (adata->mailbox != m))
1875 return -1;
1876
1877 mdata->bcache = imap_bcache_open(m);
1878 char id[64] = { 0 };
1879 snprintf(id, sizeof(id), "%u-%u", mdata->uidvalidity, imap_edata_get(e)->uid);
1880 return mutt_bcache_del(mdata->bcache, id);
1881}
1882
1889{
1891 struct ImapMboxData *mdata = imap_mdata_get(m);
1892
1893 if (!adata || (adata->mailbox != m))
1894 return -1;
1895
1896 mdata->bcache = imap_bcache_open(m);
1898
1899 return 0;
1900}
1901
1920char *imap_set_flags(struct Mailbox *m, struct Email *e, char *s, bool *server_changes)
1921{
1923 if (!adata || (adata->mailbox != m))
1924 return NULL;
1925
1926 struct ImapHeader newh = { 0 };
1927 struct ImapEmailData old_edata = { 0 };
1928 int local_changes = e->changed;
1929
1930 struct ImapEmailData *edata = e->edata;
1931 newh.edata = edata;
1932
1933 mutt_debug(LL_DEBUG2, "parsing FLAGS\n");
1934 s = msg_parse_flags(&newh, s);
1935 if (!s)
1936 return NULL;
1937
1938 /* Update tags system */
1939 /* We take a copy of the tags so we can split the string */
1940 char *tags_copy = mutt_str_dup(edata->flags_remote);
1941 driver_tags_replace(&e->tags, tags_copy);
1942 FREE(&tags_copy);
1943
1944 /* YAUH (yet another ugly hack): temporarily set context to
1945 * read-write even if it's read-only, so *server* updates of
1946 * flags can be processed by mutt_set_flag. mailbox->changed must
1947 * be restored afterwards */
1948 bool readonly = m->readonly;
1949 m->readonly = false;
1950
1951 /* This is redundant with the following two checks. Removing:
1952 * mutt_set_flag (m, e, MUTT_NEW, !(edata->read || edata->old), true); */
1953 set_changed_flag(m, e, local_changes, server_changes, MUTT_OLD, old_edata.old,
1954 edata->old, e->old);
1955 set_changed_flag(m, e, local_changes, server_changes, MUTT_READ,
1956 old_edata.read, edata->read, e->read);
1957 set_changed_flag(m, e, local_changes, server_changes, MUTT_DELETE,
1958 old_edata.deleted, edata->deleted, e->deleted);
1959 set_changed_flag(m, e, local_changes, server_changes, MUTT_FLAG,
1960 old_edata.flagged, edata->flagged, e->flagged);
1961 set_changed_flag(m, e, local_changes, server_changes, MUTT_REPLIED,
1962 old_edata.replied, edata->replied, e->replied);
1963
1964 /* this message is now definitively *not* changed (mutt_set_flag
1965 * marks things changed as a side-effect) */
1966 if (local_changes == 0)
1967 e->changed = false;
1968 m->changed &= !readonly;
1969 m->readonly = readonly;
1970
1971 return s;
1972}
1973
1977bool imap_msg_open(struct Mailbox *m, struct Message *msg, struct Email *e)
1978{
1979 struct Envelope *newenv = NULL;
1980 char buf[1024] = { 0 };
1981 char *pc = NULL;
1982 unsigned int bytes;
1983 unsigned int uid;
1984 bool retried = false;
1985 bool read;
1986 int rc;
1987
1988 /* Sam's weird courier server returns an OK response even when FETCH
1989 * fails. Thanks Sam. */
1990 bool fetched = false;
1991
1993
1994 if (!adata || (adata->mailbox != m))
1995 return false;
1996
1997 msg->fp = msg_cache_get(m, e);
1998 if (msg->fp)
1999 {
2000 if (imap_edata_get(e)->parsed)
2001 return true;
2002 goto parsemsg;
2003 }
2004
2005 /* This function is called in a few places after endwin()
2006 * e.g. mutt_pipe_message(). */
2007 bool output_progress = !isendwin() && m->verbose;
2008 if (output_progress)
2009 mutt_message(_("Fetching message..."));
2010
2011 msg->fp = msg_cache_put(m, e);
2012 if (!msg->fp)
2013 {
2014 struct Buffer *path = buf_pool_get();
2015 buf_mktemp(path);
2016 msg->fp = mutt_file_fopen(buf_string(path), "w+");
2017 unlink(buf_string(path));
2018 buf_pool_release(&path);
2019
2020 if (!msg->fp)
2021 return false;
2022 }
2023
2024 /* mark this header as currently inactive so the command handler won't
2025 * also try to update it. HACK until all this code can be moved into the
2026 * command handler */
2027 e->active = false;
2028
2029 const bool c_imap_peek = cs_subset_bool(NeoMutt->sub, "imap_peek");
2030 snprintf(buf, sizeof(buf), "UID FETCH %u %s", imap_edata_get(e)->uid,
2031 ((adata->capabilities & IMAP_CAP_IMAP4REV1) ?
2032 (c_imap_peek ? "BODY.PEEK[]" : "BODY[]") :
2033 "RFC822"));
2034
2035 imap_cmd_start(adata, buf);
2036 do
2037 {
2038 rc = imap_cmd_step(adata);
2039 if (rc != IMAP_RES_CONTINUE)
2040 break;
2041
2042 pc = adata->buf;
2043 pc = imap_next_word(pc);
2044 pc = imap_next_word(pc);
2045
2046 if (mutt_istr_startswith(pc, "FETCH"))
2047 {
2048 while (*pc)
2049 {
2050 pc = imap_next_word(pc);
2051 if (pc[0] == '(')
2052 pc++;
2053 if (mutt_istr_startswith(pc, "UID"))
2054 {
2055 pc = imap_next_word(pc);
2056 if (!mutt_str_atoui(pc, &uid))
2057 goto bail;
2058 if (uid != imap_edata_get(e)->uid)
2059 {
2060 mutt_error(_("The message index is incorrect. Try reopening the mailbox."));
2061 }
2062 }
2063 else if (mutt_istr_startswith(pc, "RFC822") || mutt_istr_startswith(pc, "BODY[]"))
2064 {
2065 pc = imap_next_word(pc);
2066 if (imap_get_literal_count(pc, &bytes) < 0)
2067 {
2068 imap_error("imap_msg_open()", buf);
2069 goto bail;
2070 }
2071
2072 const int res = imap_read_literal(msg->fp, adata, bytes, NULL);
2073 if (res < 0)
2074 {
2075 goto bail;
2076 }
2077 /* pick up trailing line */
2078 rc = imap_cmd_step(adata);
2079 if (rc != IMAP_RES_CONTINUE)
2080 goto bail;
2081 pc = adata->buf;
2082
2083 fetched = true;
2084 }
2085 else if (!e->changed && mutt_istr_startswith(pc, "FLAGS"))
2086 {
2087 /* UW-IMAP will provide a FLAGS update here if the FETCH causes a
2088 * change (eg from \Unseen to \Seen).
2089 * Uncommitted changes in neomutt take precedence. If we decide to
2090 * incrementally update flags later, this won't stop us syncing */
2091 pc = imap_set_flags(m, e, pc, NULL);
2092 if (!pc)
2093 goto bail;
2094 }
2095 }
2096 }
2097 } while (rc == IMAP_RES_CONTINUE);
2098
2099 /* see comment before command start. */
2100 e->active = true;
2101
2102 fflush(msg->fp);
2103 if (ferror(msg->fp))
2104 goto bail;
2105
2106 if (rc != IMAP_RES_OK)
2107 goto bail;
2108
2109 if (!fetched || !imap_code(adata->buf))
2110 goto bail;
2111
2112 if (msg_cache_commit(m, e) < 0)
2113 mutt_debug(LL_DEBUG1, "failed to add message to cache\n");
2114
2115parsemsg:
2116 /* Update the header information. Previously, we only downloaded a
2117 * portion of the headers, those required for the main display. */
2118 rewind(msg->fp);
2119 /* It may be that the Status header indicates a message is read, but the
2120 * IMAP server doesn't know the message has been \Seen. So we capture
2121 * the server's notion of 'read' and if it differs from the message info
2122 * picked up in mutt_rfc822_read_header, we mark the message (and context
2123 * changed). Another possibility: ignore Status on IMAP? */
2124 read = e->read;
2125 newenv = mutt_rfc822_read_header(msg->fp, e, false, false);
2126 mutt_env_merge(e->env, &newenv);
2127
2128 /* see above. We want the new status in e->read, so we unset it manually
2129 * and let mutt_set_flag set it correctly, updating context. */
2130 if (read != e->read)
2131 {
2132 e->read = read;
2133 mutt_set_flag(m, e, MUTT_NEW, read, true);
2134 }
2135
2136 e->lines = 0;
2137 while (fgets(buf, sizeof(buf), msg->fp) && !feof(msg->fp))
2138 {
2139 e->lines++;
2140 }
2141
2142 e->body->length = ftell(msg->fp) - e->body->offset;
2143
2145 rewind(msg->fp);
2146 imap_edata_get(e)->parsed = true;
2147
2148 /* retry message parse if cached message is empty */
2149 if (!retried && ((e->lines == 0) || (e->body->length == 0)))
2150 {
2151 imap_cache_del(m, e);
2152 retried = true;
2153 goto parsemsg;
2154 }
2155
2156 return true;
2157
2158bail:
2159 e->active = true;
2160 mutt_file_fclose(&msg->fp);
2161 imap_cache_del(m, e);
2162 return false;
2163}
2164
2170int imap_msg_commit(struct Mailbox *m, struct Message *msg)
2171{
2172 int rc = mutt_file_fclose(&msg->fp);
2173 if (rc != 0)
2174 return rc;
2175
2176 return imap_append_message(m, msg);
2177}
2178
2184int imap_msg_close(struct Mailbox *m, struct Message *msg)
2185{
2186 return mutt_file_fclose(&msg->fp);
2187}
2188
2192int imap_msg_save_hcache(struct Mailbox *m, struct Email *e)
2193{
2194 int rc = 0;
2195#ifdef USE_HCACHE
2196 bool close_hc = true;
2198 struct ImapMboxData *mdata = imap_mdata_get(m);
2199 if (!mdata || !adata)
2200 return -1;
2201 if (mdata->hcache)
2202 close_hc = false;
2203 else
2204 imap_hcache_open(adata, mdata);
2205 rc = imap_hcache_put(mdata, e);
2206 if (close_hc)
2208#endif
2209 return rc;
2210}
#define ARRAY_SORT(head, fn, sdata)
Sort an array.
Definition: array.h:279
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:156
#define ARRAY_FOREACH(elem, head)
Iterate over all elements of the array.
Definition: array.h:212
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:74
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:87
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:204
#define ARRAY_GET(head, idx)
Return the element at index.
Definition: array.h:109
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:58
const char * mutt_str_atol(const char *str, long *dst)
Convert ASCII string to a long.
Definition: atoi.c:143
const char * mutt_str_atoui(const char *str, unsigned int *dst)
Convert ASCII string to an unsigned integer.
Definition: atoi.c:214
Body Caching (local copies of email bodies)
int mutt_bcache_commit(struct BodyCache *bcache, const char *id)
Move a temporary file into the Body Cache.
Definition: bcache.c:249
struct BodyCache * mutt_bcache_open(struct ConnAccount *account, const char *mailbox)
Open an Email-Body Cache.
Definition: bcache.c:143
int mutt_bcache_list(struct BodyCache *bcache, bcache_list_t want_id, void *data)
Find matching entries in the Body Cache.
Definition: bcache.c:331
FILE * mutt_bcache_get(struct BodyCache *bcache, const char *id)
Open a file in the Body Cache.
Definition: bcache.c:182
int mutt_bcache_del(struct BodyCache *bcache, const char *id)
Delete a file from the Body Cache.
Definition: bcache.c:266
FILE * mutt_bcache_put(struct BodyCache *bcache, const char *id)
Create a file in the Body Cache.
Definition: bcache.c:209
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:203
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:490
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:75
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:240
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
void buf_join_str(struct Buffer *buf, const char *str, char sep)
Join a buffer with a string separated by sep.
Definition: buffer.c:749
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:394
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:570
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:292
long cs_subset_long(const struct ConfigSubset *sub, const char *name)
Get a long config item by name.
Definition: helpers.c:96
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
Convenience wrapper for the config headers.
Connection Library.
Convenience wrapper for the core headers.
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:250
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: get.c:57
struct Email * email_new(void)
Create a new Email.
Definition: email.c:80
void email_free(struct Email **ptr)
Free an Email.
Definition: email.c:46
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:1200
void mutt_env_merge(struct Envelope *base, struct Envelope **extra)
Merge the headers of two Envelopes.
Definition: envelope.c:193
Manage where the email is piped to external commands.
MessageSaveOpt
Message save option.
Definition: external.h:51
@ SAVE_MOVE
Move message to another mailbox, removing the original.
Definition: external.h:53
#define mutt_file_fclose(FP)
Definition: file.h:147
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:146
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:57
static int imap_bcache_delete(const char *id, struct BodyCache *bcache, void *data)
Delete an entry from the message cache - Implements bcache_list_t -.
Definition: message.c:170
void imap_edata_free(void **ptr)
Free the private Email data - Implements Email::edata_free() -.
Definition: edata.c:40
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_message(...)
Definition: logging2.h:91
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
#define mutt_perror(...)
Definition: logging2.h:93
int imap_msg_close(struct Mailbox *m, struct Message *msg)
Close an email - Implements MxOps::msg_close() -.
Definition: message.c:2184
int imap_msg_commit(struct Mailbox *m, struct Message *msg)
Save changes to an email - Implements MxOps::msg_commit() -.
Definition: message.c:2170
bool imap_msg_open(struct Mailbox *m, struct Message *msg, struct Email *e)
Open an email message in a Mailbox - Implements MxOps::msg_open() -.
Definition: message.c:1977
int imap_msg_save_hcache(struct Mailbox *m, struct Email *e)
Save message to the header cache - Implements MxOps::msg_save_hcache() -.
Definition: message.c:2192
int imap_sort_uid(const void *a, const void *b, void *sdata)
Compare two UIDs - Implements sort_t -.
Definition: msg_set.c:55
Convenience wrapper for the gui headers.
struct HashTable * mutt_hash_int_new(size_t num_elems, HashFlags flags)
Create a new Hash Table (with integer keys)
Definition: hash.c:285
void * mutt_hash_int_find(const struct HashTable *table, unsigned int intkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:392
struct HashElem * mutt_hash_int_insert(struct HashTable *table, unsigned int intkey, void *data)
Add a new element to the Hash Table (with integer keys)
Definition: hash.c:347
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:109
int hcache_delete_raw(struct HeaderCache *hc, const char *key, size_t keylen)
Multiplexor for StoreOps::delete_record.
Definition: hcache.c:750
int hcache_store_raw(struct HeaderCache *hc, const char *key, size_t keylen, void *data, size_t dlen)
Store a key / data pair.
Definition: hcache.c:722
Header cache multiplexor.
#define hcache_fetch_raw_obj(hc, key, keylen, dst)
Definition: lib.h:161
struct ImapAccountData * imap_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition: adata.c:123
int imap_cmd_start(struct ImapAccountData *adata, const char *cmdstr)
Given an IMAP command, send it to the server.
Definition: command.c:1118
int imap_cmd_step(struct ImapAccountData *adata)
Reads server responses from an IMAP command.
Definition: command.c:1132
bool imap_code(const char *s)
Was the command successful.
Definition: command.c:1259
int imap_exec(struct ImapAccountData *adata, const char *cmdstr, ImapCmdFlags flags)
Execute a command and wait for the response from the server.
Definition: command.c:1307
struct ImapEmailData * imap_edata_new(void)
Create a new ImapEmailData.
Definition: edata.c:57
struct ImapEmailData * imap_edata_clone(struct ImapEmailData *src)
Clone an ImapEmailData.
Definition: edata.c:79
struct ImapEmailData * imap_edata_get(struct Email *e)
Get the private data for this Email.
Definition: edata.c:67
int imap_parse_path(const char *path, struct ConnAccount *cac, char *mailbox, size_t mailboxlen)
Parse an IMAP mailbox name into ConnAccount, name.
Definition: util.c:474
struct ImapMboxData * imap_mdata_get(struct Mailbox *m)
Get the Mailbox data for this mailbox.
Definition: mdata.c:60
int imap_cache_clean(struct Mailbox *m)
Delete all the entries in the message cache.
Definition: message.c:1888
static struct BodyCache * imap_bcache_open(struct Mailbox *m)
Open a message cache.
Definition: message.c:82
static FILE * msg_cache_put(struct Mailbox *m, struct Email *e)
Put an email into the message cache.
Definition: message.c:130
char * imap_set_flags(struct Mailbox *m, struct Email *e, char *s, bool *server_changes)
Fill the message header according to the server flags.
Definition: message.c:1920
static unsigned int imap_fetch_msn_seqset(struct Buffer *buf, struct ImapAccountData *adata, bool evalhc, unsigned int msn_begin, unsigned int msn_end, unsigned int *fetch_msn_end)
Generate a sequence set.
Definition: message.c:552
static int msg_parse_fetch(struct ImapHeader *h, char *s)
Handle headers returned from header fetch.
Definition: message.c:310
static int imap_verify_qresync(struct Mailbox *m)
Check to see if QRESYNC got jumbled.
Definition: message.c:1014
static int flush_buffer(char *buf, size_t *len, struct Connection *conn)
Write data to a connection.
Definition: message.c:488
int imap_append_message(struct Mailbox *m, struct Message *msg)
Write an email back to the server.
Definition: message.c:1530
static int emails_to_uid_array(struct EmailArray *ea, struct UidArray *uida)
Extract IMAP UIDs from Emails.
Definition: message.c:1662
static int msg_fetch_header(struct Mailbox *m, struct ImapHeader *ih, char *buf, FILE *fp)
Import IMAP FETCH response into an ImapHeader.
Definition: message.c:422
static int read_headers_condstore_qresync_updates(struct ImapAccountData *adata, unsigned int msn_end, unsigned int uid_next, unsigned long long hc_modseq, bool eval_qresync)
Retrieve updates from the server.
Definition: message.c:915
static FILE * msg_cache_get(struct Mailbox *m, struct Email *e)
Get the message cache entry for an email.
Definition: message.c:109
int imap_copy_messages(struct Mailbox *m, struct EmailArray *ea, const char *dest, enum MessageSaveOpt save_opt)
Server COPY messages to another folder.
Definition: message.c:1687
static bool query_abort_header_download(struct ImapAccountData *adata)
Ask the user whether to abort the download.
Definition: message.c:504
int imap_cache_del(struct Mailbox *m, struct Email *e)
Delete an email from the body cache.
Definition: message.c:1869
static void set_changed_flag(struct Mailbox *m, struct Email *e, int local_changes, bool *server_changes, enum MessageType flag_name, bool old_hd_flag, bool new_hd_flag, bool h_flag)
Have the flags of an email changed.
Definition: message.c:644
static int read_headers_fetch_new(struct Mailbox *m, unsigned int msn_begin, unsigned int msn_end, bool evalhc, unsigned int *maxuid, bool initial_download)
Retrieve new messages from the server.
Definition: message.c:1091
int imap_read_headers(struct Mailbox *m, unsigned int msn_begin, unsigned int msn_end, bool initial_download)
Read headers from the server.
Definition: message.c:1341
static int msg_cache_commit(struct Mailbox *m, struct Email *e)
Add to the message cache.
Definition: message.c:151
static int read_headers_normal_eval_cache(struct ImapAccountData *adata, unsigned int msn_end, unsigned int uid_next, bool store_flag_updates, bool eval_condstore)
Retrieve data from the header cache.
Definition: message.c:684
static char * msg_parse_flags(struct ImapHeader *h, char *s)
Read a FLAGS token into an ImapHeader.
Definition: message.c:193
static int read_headers_qresync_eval_cache(struct ImapAccountData *adata, char *uid_seqset)
Retrieve data from the header cache.
Definition: message.c:829
static void imap_alloc_uid_hash(struct ImapAccountData *adata, unsigned int msn_count)
Create a Hash Table for the UIDs.
Definition: message.c:528
#define IMAP_CMD_NO_FLAGS
No flags are set.
Definition: private.h:71
#define IMAP_RES_RESPOND
+
Definition: private.h:57
#define IMAP_EXPUNGE_PENDING
Messages on the server have been expunged.
Definition: private.h:66
int imap_get_literal_count(const char *buf, unsigned int *bytes)
Write number of bytes in an IMAP literal into bytes.
Definition: util.c:741
#define IMAP_RES_OK
<tag> OK ...
Definition: private.h:55
int imap_hcache_store_uid_seqset(struct ImapMboxData *mdata)
Store a UID Sequence Set in the header cache.
Definition: util.c:415
int imap_hcache_put(struct ImapMboxData *mdata, struct Email *e)
Add an entry to the header cache.
Definition: util.c:380
#define IMAP_REOPEN_ALLOW
Allow re-opening a folder upon expunge.
Definition: private.h:64
#define IMAP_CAP_IMAP4
Server supports IMAP4.
Definition: private.h:121
struct SeqsetIterator * mutt_seqset_iterator_new(const char *seqset)
Create a new Sequence Set Iterator.
Definition: util.c:1086
#define IMAP_CAP_IMAP4REV1
Server supports IMAP4rev1.
Definition: private.h:122
char * imap_hcache_get_uid_seqset(struct ImapMboxData *mdata)
Get a UID Sequence Set from the header cache.
Definition: util.c:450
struct Email * imap_hcache_get(struct ImapMboxData *mdata, unsigned int uid)
Get a header cache entry by its UID.
Definition: util.c:355
int mutt_seqset_iterator_next(struct SeqsetIterator *iter, unsigned int *next)
Get the next UID from a Sequence Set.
Definition: util.c:1107
@ IMAP_EXEC_SUCCESS
Imap command executed or queued successfully.
Definition: private.h:82
@ IMAP_EXEC_ERROR
Imap command failure.
Definition: private.h:83
void mutt_seqset_iterator_free(struct SeqsetIterator **ptr)
Free a Sequence Set Iterator.
Definition: util.c:1166
char * imap_fix_path(char delim, const char *mailbox, char *path, size_t plen)
Fix up the imap path.
Definition: util.c:679
#define IMAP_NEWMAIL_PENDING
New mail is waiting on the server.
Definition: private.h:67
void imap_cachepath(char delim, const char *mailbox, struct Buffer *dest)
Generate a cache path for a mailbox.
Definition: util.c:710
void imap_error(const char *where, const char *msg)
Show an error and abort.
Definition: util.c:657
void imap_hcache_close(struct ImapMboxData *mdata)
Close the header cache.
Definition: util.c:340
int imap_hcache_clear_uid_seqset(struct ImapMboxData *mdata)
Delete a UID Sequence Set from the header cache.
Definition: util.c:436
bool imap_account_match(const struct ConnAccount *a1, const struct ConnAccount *a2)
Compare two Accounts.
Definition: util.c:1054
void imap_munge_mbox_name(bool unicode, char *dest, size_t dlen, const char *src)
Quote awkward characters in a mailbox name.
Definition: util.c:921
void imap_hcache_open(struct ImapAccountData *adata, struct ImapMboxData *mdata)
Open a header cache.
Definition: util.c:299
#define IMAP_RES_CONTINUE
* ...
Definition: private.h:56
char * imap_next_word(char *s)
Find where the next IMAP word begins.
Definition: util.c:785
#define IMAP_RES_BAD
<tag> BAD ...
Definition: private.h:54
#define IMAP_CAP_CONDSTORE
RFC7162.
Definition: private.h:136
#define IMAP_CMD_QUEUE
Queue a command, do not execute.
Definition: private.h:73
char * imap_get_qualifier(char *buf)
Get the qualifier from a tagged response.
Definition: util.c:768
void imap_close_connection(struct ImapAccountData *adata)
Close an IMAP connection.
Definition: imap.c:850
void imap_expunge_mailbox(struct Mailbox *m, bool resort)
Purge messages from the server.
Definition: imap.c:670
int imap_create_mailbox(struct ImapAccountData *adata, const char *mailbox)
Create a new mailbox.
Definition: imap.c:437
int imap_sync_message_for_copy(struct Mailbox *m, struct Email *e, struct Buffer *cmd, enum QuadOption *err_continue)
Update server to reflect the flags of a single message.
Definition: imap.c:927
int imap_read_literal(FILE *fp, struct ImapAccountData *adata, unsigned long bytes, struct Progress *progress)
Read bytes bytes from server into file.
Definition: imap.c:591
@ 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
#define FREE(x)
Definition: memory.h:45
#define MAX(a, b)
Definition: memory.h:31
int imap_exec_msg_set(struct ImapAccountData *adata, const char *pre, const char *post, struct UidArray *uida)
Execute a command using a set of UIDs.
Definition: msg_set.c:133
IMAP Message Sets.
void imap_msn_free(struct MSNArray *msn)
Free the cache.
Definition: msn.c:60
size_t imap_msn_highest(const struct MSNArray *msn)
Return the highest MSN in use.
Definition: msn.c:70
struct Email * imap_msn_get(const struct MSNArray *msn, size_t idx)
Return the Email associated with an msn.
Definition: msn.c:81
void imap_msn_set(struct MSNArray *msn, size_t idx, struct Email *e)
Cache an Email into a given position.
Definition: msn.c:93
void imap_msn_reserve(struct MSNArray *msn, size_t num)
Create / reallocate the cache.
Definition: msn.c:42
IMAP MSN helper functions.
int mutt_date_make_imap(struct Buffer *buf, time_t timestamp)
Format date in IMAP style: DD-MMM-YYYY HH:MM:SS +ZZzz.
Definition: date.c:810
time_t mutt_date_parse_imap(const char *s)
Parse date of the form: DD-MMM-YYYY HH:MM:SS +ZZzz.
Definition: date.c:853
Convenience wrapper for the library headers.
#define FALLTHROUGH
Definition: lib.h:111
Message logging.
#define _(a)
Definition: message.h:28
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
int mutt_str_asprintf(char **strp, const char *fmt,...)
Definition: string.c:852
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:630
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition: string.c:242
char * mutt_str_cat(char *buf, size_t buflen, const char *s)
Concatenate two strings.
Definition: string.c:268
Many unsorted constants and some structs.
MessageType
To set flags or match patterns.
Definition: mutt.h:67
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:73
@ MUTT_OLD
Old messages.
Definition: mutt.h:71
@ MUTT_PURGE
Messages to be purged (bypass trash)
Definition: mutt.h:77
@ MUTT_FLAG
Flagged messages.
Definition: mutt.h:79
@ MUTT_DELETE
Messages to be deleted.
Definition: mutt.h:75
@ MUTT_NEW
New messages.
Definition: mutt.h:70
@ MUTT_REPLIED
Messages that have been replied to.
Definition: mutt.h:72
#define PATH_MAX
Definition: mutt.h:42
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
NeoMutt Logging.
void mx_alloc_memory(struct Mailbox *m, int req_size)
Create storage for the emails.
Definition: mx.c:1204
API for mailboxes.
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
Pop-specific Account data.
Pop-specific Email data.
Progress Bar.
@ MUTT_PROGRESS_NET
Progress tracks bytes, according to $net_inc
Definition: lib.h:81
@ MUTT_PROGRESS_READ
Progress tracks elements, according to $read_inc
Definition: lib.h:82
struct Progress * progress_new(enum ProgressType type, size_t size)
Create a new Progress Bar.
Definition: progress.c:139
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition: progress.c:110
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:80
Prototypes for many functions.
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
Ask the user a question.
enum QuadOption query_yesorno_help(const char *prompt, enum QuadOption def, struct ConfigSubset *sub, const char *name)
Ask the user a Yes/No question offering help.
Definition: question.c:342
enum QuadOption query_yesorno(const char *prompt, enum QuadOption def)
Ask the user a Yes/No question.
Definition: question.c:327
#define STAILQ_INIT(head)
Definition: queue.h:372
GUI display the mailboxes in a side panel.
volatile sig_atomic_t SigInt
true after SIGINT is received
Definition: signal.c:63
#define mutt_socket_write_n(conn, buf, len)
Definition: socket.h:59
#define mutt_socket_send(conn, buf)
Definition: socket.h:57
Key value store.
#define SKIPWS(ch)
Definition: string2.h:45
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
Local cache of email bodies.
Definition: bcache.c:51
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:36
Login details for a remote server.
Definition: connaccount.h:53
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
The envelope/body of an email.
Definition: email.h:39
bool read
Email is read.
Definition: email.h:50
struct Envelope * env
Envelope information.
Definition: email.h:68
void * edata
Driver-specific data.
Definition: email.h:74
int lines
How many lines in the body of this message?
Definition: email.h:62
struct Body * body
List of MIME parts.
Definition: email.h:69
bool active
Message is not to be removed.
Definition: email.h:76
bool old
Email is seen, but unread.
Definition: email.h:49
void(* edata_free)(void **ptr)
Definition: email.h:90
bool changed
Email has been edited.
Definition: email.h:77
bool attach_del
Has an attachment marked for deletion.
Definition: email.h:102
bool flagged
Marked important?
Definition: email.h:47
bool replied
Email has been replied to.
Definition: email.h:51
struct TagList tags
For drivers that support server tagging.
Definition: email.h:72
bool deleted
Email is deleted.
Definition: email.h:78
int index
The absolute (unsorted) message number.
Definition: email.h:113
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:61
The header of an Email.
Definition: envelope.h:57
IMAP-specific Account data -.
Definition: adata.h:40
char delim
Path delimiter.
Definition: adata.h:75
bool qresync
true, if QRESYNC is successfully ENABLE'd
Definition: adata.h:63
ImapCapFlags capabilities
Capability flags.
Definition: adata.h:55
struct Mailbox * mailbox
Current selected mailbox.
Definition: adata.h:76
char * buf
Definition: adata.h:59
struct Connection * conn
Connection to IMAP server.
Definition: adata.h:41
IMAP-specific Email data -.
Definition: edata.h:35
bool parsed
Definition: edata.h:43
unsigned int uid
32-bit Message UID
Definition: edata.h:45
unsigned int msn
Message Sequence Number.
Definition: edata.h:46
char * flags_remote
Definition: edata.h:49
bool deleted
Email has been deleted.
Definition: edata.h:39
bool old
Email has been seen.
Definition: edata.h:38
bool read
Email has been read.
Definition: edata.h:37
bool flagged
Email has been flagged.
Definition: edata.h:40
bool replied
Email has been replied to.
Definition: edata.h:41
char * flags_system
Definition: edata.h:48
IMAP-specific header.
Definition: message.h:34
time_t received
Definition: message.h:37
struct ImapEmailData * edata
Definition: message.h:35
long content_length
Definition: message.h:38
IMAP-specific Mailbox data -.
Definition: mdata.h:40
ImapOpenFlags reopen
Flags, e.g. IMAP_REOPEN_ALLOW.
Definition: mdata.h:45
unsigned int uid_next
Definition: mdata.h:52
struct HeaderCache * hcache
Email header cache.
Definition: mdata.h:63
struct BodyCache * bcache
Email body cache.
Definition: mdata.h:61
unsigned int new_mail_count
Set when EXISTS notifies of new mail.
Definition: mdata.h:47
struct HashTable * uid_hash
Hash Table: "uid" -> Email.
Definition: mdata.h:59
unsigned long long modseq
Definition: mdata.h:53
uint32_t uidvalidity
Definition: mdata.h:51
char * name
Mailbox name.
Definition: mdata.h:41
A mailbox.
Definition: mailbox.h:79
int vcount
The number of virtual messages.
Definition: mailbox.h:99
bool changed
Mailbox has been modified.
Definition: mailbox.h:110
int msg_new
Number of new messages.
Definition: mailbox.h:92
int msg_count
Total number of messages.
Definition: mailbox.h:88
void * mdata
Driver specific data.
Definition: mailbox.h:132
struct HashTable * subj_hash
Hash Table: "subject" -> Email.
Definition: mailbox.h:124
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
struct HashTable * id_hash
Hash Table: "message-id" -> Email.
Definition: mailbox.h:123
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:93
off_t size
Size of the Mailbox.
Definition: mailbox.h:84
struct HashTable * label_hash
Hash Table: "x-labels" -> Email.
Definition: mailbox.h:125
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
bool readonly
Don't allow changes to the mailbox.
Definition: mailbox.h:116
int msg_tagged
How many messages are tagged?
Definition: mailbox.h:94
bool verbose
Display status messages?
Definition: mailbox.h:117
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 draft
Message has been read.
Definition: message.h:44
bool replied
Message has been replied to.
Definition: message.h:43
time_t received
Time at which this message was received.
Definition: message.h:46
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.
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45
UID Sequence Set Iterator.
Definition: private.h:169
bool driver_tags_replace(struct TagList *tl, const char *tags)
Replace all tags.
Definition: tags.c:201
#define buf_mktemp(buf)
Definition: tmp.h:33