NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
imap.c
Go to the documentation of this file.
1
42#include "config.h"
43#include <ctype.h>
44#include <limits.h>
45#include <stdbool.h>
46#include <stdint.h>
47#include <stdio.h>
48#include <string.h>
49#include "private.h"
50#include "mutt/lib.h"
51#include "config/lib.h"
52#include "email/lib.h"
53#include "core/lib.h"
54#include "conn/lib.h"
55#include "mutt.h"
56#include "lib.h"
57#include "editor/lib.h"
58#include "history/lib.h"
59#include "parse/lib.h"
60#include "progress/lib.h"
61#include "question/lib.h"
62#include "adata.h"
63#include "auth.h"
64#include "commands.h"
65#include "edata.h"
66#include "external.h"
67#include "hook.h"
68#include "mdata.h"
69#include "msg_set.h"
70#include "msn.h"
71#include "mutt_logging.h"
72#include "mutt_socket.h"
73#include "muttlib.h"
74#include "mx.h"
75#include "sort.h"
76#ifdef ENABLE_NLS
77#include <libintl.h>
78#endif
79
80struct Progress;
81struct stat;
82
86static const struct Command ImapCommands[] = {
87 // clang-format off
88 { "subscribe-to", parse_subscribe_to, 0 },
89 { "unsubscribe-from", parse_unsubscribe_from, 0 },
90 // clang-format on
91};
92
96void imap_init(void)
97{
99}
100
107static int check_capabilities(struct ImapAccountData *adata)
108{
109 if (imap_exec(adata, "CAPABILITY", IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
110 {
111 imap_error("check_capabilities", adata->buf);
112 return -1;
113 }
114
115 if (!((adata->capabilities & IMAP_CAP_IMAP4) || (adata->capabilities & IMAP_CAP_IMAP4REV1)))
116 {
117 mutt_error(_("This IMAP server is ancient. NeoMutt does not work with it."));
118 return -1;
119 }
120
121 return 0;
122}
123
133static char *get_flags(struct ListHead *hflags, char *s)
134{
135 /* sanity-check string */
136 const size_t plen = mutt_istr_startswith(s, "FLAGS");
137 if (plen == 0)
138 {
139 mutt_debug(LL_DEBUG1, "not a FLAGS response: %s\n", s);
140 return NULL;
141 }
142 s += plen;
143 SKIPWS(s);
144 if (*s != '(')
145 {
146 mutt_debug(LL_DEBUG1, "bogus FLAGS response: %s\n", s);
147 return NULL;
148 }
149
150 /* update caller's flags handle */
151 while (*s && (*s != ')'))
152 {
153 s++;
154 SKIPWS(s);
155 const char *flag_word = s;
156 while (*s && (*s != ')') && !isspace(*s))
157 s++;
158 const char ctmp = *s;
159 *s = '\0';
160 if (*flag_word)
161 mutt_list_insert_tail(hflags, mutt_str_dup(flag_word));
162 *s = ctmp;
163 }
164
165 /* note bad flags response */
166 if (*s != ')')
167 {
168 mutt_debug(LL_DEBUG1, "Unterminated FLAGS response: %s\n", s);
169 mutt_list_free(hflags);
170
171 return NULL;
172 }
173
174 s++;
175
176 return s;
177}
178
187static void set_flag(struct Mailbox *m, AclFlags aclflag, bool flag,
188 const char *str, struct Buffer *flags)
189{
190 if (m->rights & aclflag)
191 if (flag && imap_has_flag(&imap_mdata_get(m)->flags, str))
192 buf_addstr(flags, str);
193}
194
203static bool compare_flags_for_copy(struct Email *e)
204{
205 struct ImapEmailData *edata = e->edata;
206
207 if (e->read != edata->read)
208 return true;
209 if (e->old != edata->old)
210 return true;
211 if (e->flagged != edata->flagged)
212 return true;
213 if (e->replied != edata->replied)
214 return true;
215
216 return false;
217}
218
230static int select_email_uids(struct Email **emails, int num_emails, enum MessageType flag,
231 bool changed, bool invert, struct UidArray *uida)
232{
233 if (!emails || !uida)
234 return -1;
235
236 for (int i = 0; i < num_emails; i++)
237 {
238 struct Email *e = emails[i];
239 if (changed && !e->changed)
240 continue;
241
242 /* don't include pending expunged messages.
243 *
244 * TODO: can we unset active in cmd_parse_expunge() and
245 * cmd_parse_vanished() instead of checking for index != INT_MAX. */
246 if (!e || !e->active || (e->index == INT_MAX))
247 continue;
248
250
251 bool match = false;
252 switch (flag)
253 {
254 case MUTT_DELETED:
255 if (e->deleted != edata->deleted)
256 match = invert ^ e->deleted;
257 break;
258 case MUTT_FLAG:
259 if (e->flagged != edata->flagged)
260 match = invert ^ e->flagged;
261 break;
262 case MUTT_OLD:
263 if (e->old != edata->old)
264 match = invert ^ e->old;
265 break;
266 case MUTT_READ:
267 if (e->read != edata->read)
268 match = invert ^ e->read;
269 break;
270 case MUTT_REPLIED:
271 if (e->replied != edata->replied)
272 match = invert ^ e->replied;
273 break;
274 case MUTT_TRASH:
275 if (e->deleted && !e->purge)
276 match = true;
277 break;
278 default:
279 break;
280 }
281
282 if (match)
283 ARRAY_ADD(uida, edata->uid);
284 }
285
286 return ARRAY_SIZE(uida);
287}
288
300static int sync_helper(struct Mailbox *m, struct Email **emails, int num_emails,
301 AclFlags right, enum MessageType flag, const char *name)
302{
304 if (!adata)
305 return -1;
306
307 if ((m->rights & right) == 0)
308 return 0;
309
310 if ((right == MUTT_ACL_WRITE) && !imap_has_flag(&imap_mdata_get(m)->flags, name))
311 return 0;
312
313 int count = 0;
314 char buf[1024] = { 0 };
315
316 struct UidArray uida = ARRAY_HEAD_INITIALIZER;
317
318 // Set the flag (+FLAGS) on matching emails
319 select_email_uids(emails, num_emails, flag, true, false, &uida);
320 snprintf(buf, sizeof(buf), "+FLAGS.SILENT (%s)", name);
321 int rc = imap_exec_msg_set(adata, "UID STORE", buf, &uida);
322 if (rc < 0)
323 return rc;
324 count += rc;
325 ARRAY_FREE(&uida);
326
327 // Clear the flag (-FLAGS) on non-matching emails
328 select_email_uids(emails, num_emails, flag, true, true, &uida);
329 buf[0] = '-';
330 rc = imap_exec_msg_set(adata, "UID STORE", buf, &uida);
331 if (rc < 0)
332 return rc;
333 count += rc;
334 ARRAY_FREE(&uida);
335
336 return count;
337}
338
348static size_t longest_common_prefix(struct Buffer *buf, const char *src, size_t start)
349{
350 size_t pos = start;
351
352 size_t len = buf_len(buf);
353 while ((pos < len) && buf->data[pos] && (buf->data[pos] == src[pos]))
354 pos++;
355 buf->data[pos] = '\0';
356
357 buf_fix_dptr(buf);
358
359 return pos;
360}
361
371static int complete_hosts(struct Buffer *buf)
372{
373 int rc = -1;
374 size_t matchlen;
375
376 matchlen = buf_len(buf);
377 struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
379 struct MailboxNode *np = NULL;
380 STAILQ_FOREACH(np, &ml, entries)
381 {
383 continue;
384
385 if (rc)
386 {
388 rc = 0;
389 }
390 else
391 {
392 longest_common_prefix(buf, mailbox_path(np->mailbox), matchlen);
393 }
394 }
396
397#if 0
398 TAILQ_FOREACH(conn, mutt_socket_head(), entries)
399 {
400 struct Url url = { 0 };
401 char urlstr[1024] = { 0 };
402
403 if (conn->account.type != MUTT_ACCT_TYPE_IMAP)
404 continue;
405
406 mutt_account_tourl(&conn->account, &url);
407 /* FIXME: how to handle multiple users on the same host? */
408 url.user = NULL;
409 url.path = NULL;
410 url_tostring(&url, urlstr, sizeof(urlstr), U_NO_FLAGS);
411 if (mutt_strn_equal(buf, urlstr, matchlen))
412 {
413 if (rc)
414 {
415 mutt_str_copy(buf, urlstr, buflen);
416 rc = 0;
417 }
418 else
419 {
420 longest_common_prefix(buf, urlstr, matchlen);
421 }
422 }
423 }
424#endif
425
426 return rc;
427}
428
436int imap_create_mailbox(struct ImapAccountData *adata, const char *mailbox)
437{
438 char buf[2048] = { 0 };
439 char mbox[1024] = { 0 };
440
441 imap_munge_mbox_name(adata->unicode, mbox, sizeof(mbox), mailbox);
442 snprintf(buf, sizeof(buf), "CREATE %s", mbox);
443
445 {
446 mutt_error(_("CREATE failed: %s"), imap_cmd_trailer(adata));
447 return -1;
448 }
449
450 return 0;
451}
452
463int imap_access(const char *path)
464{
465 if (imap_path_status(path, false) >= 0)
466 return 0;
467 return -1;
468}
469
478int imap_rename_mailbox(struct ImapAccountData *adata, char *oldname, const char *newname)
479{
480 char oldmbox[1024] = { 0 };
481 char newmbox[1024] = { 0 };
482 int rc = 0;
483
484 imap_munge_mbox_name(adata->unicode, oldmbox, sizeof(oldmbox), oldname);
485 imap_munge_mbox_name(adata->unicode, newmbox, sizeof(newmbox), newname);
486
487 struct Buffer *buf = buf_pool_get();
488 buf_printf(buf, "RENAME %s %s", oldmbox, newmbox);
489
491 rc = -1;
492
493 buf_pool_release(&buf);
494
495 return rc;
496}
497
505int imap_delete_mailbox(struct Mailbox *m, char *path)
506{
507 char buf[PATH_MAX + 7];
508 char mbox[PATH_MAX] = { 0 };
509 struct Url *url = url_parse(path);
510 if (!url)
511 return -1;
512
514 imap_munge_mbox_name(adata->unicode, mbox, sizeof(mbox), url->path);
515 url_free(&url);
516 snprintf(buf, sizeof(buf), "DELETE %s", mbox);
518 return -1;
519
520 return 0;
521}
522
528{
529 /* we set status here to let imap_handle_untagged know we _expect_ to
530 * receive a bye response (so it doesn't freak out and close the conn) */
531 if (adata->state == IMAP_DISCONNECTED)
532 {
533 return;
534 }
535
536 adata->status = IMAP_BYE;
537 imap_cmd_start(adata, "LOGOUT");
538 const short c_imap_poll_timeout = cs_subset_number(NeoMutt->sub, "imap_poll_timeout");
539 if ((c_imap_poll_timeout <= 0) ||
540 (mutt_socket_poll(adata->conn, c_imap_poll_timeout) != 0))
541 {
543 ; // do nothing
544 }
546 adata->state = IMAP_DISCONNECTED;
547}
548
555{
556 struct Account *np = NULL;
557 TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
558 {
559 if (np->type != MUTT_IMAP)
560 continue;
561
562 struct ImapAccountData *adata = np->adata;
563 if (!adata)
564 continue;
565
566 struct Connection *conn = adata->conn;
567 if (!conn || (conn->fd < 0))
568 continue;
569
570 mutt_message(_("Closing connection to %s..."), conn->account.host);
571 imap_logout(np->adata);
573 }
574}
575
590int imap_read_literal(FILE *fp, struct ImapAccountData *adata,
591 unsigned long bytes, struct Progress *progress)
592{
593 char c;
594 bool r = false;
595 struct Buffer buf = { 0 }; // Do not allocate, maybe it won't be used
596
597 const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
598 if (c_debug_level >= IMAP_LOG_LTRL)
599 buf_alloc(&buf, bytes + 1);
600
601 mutt_debug(LL_DEBUG2, "reading %lu bytes\n", bytes);
602
603 for (unsigned long pos = 0; pos < bytes; pos++)
604 {
605 if (mutt_socket_readchar(adata->conn, &c) != 1)
606 {
607 mutt_debug(LL_DEBUG1, "error during read, %lu bytes read\n", pos);
608 adata->status = IMAP_FATAL;
609
610 buf_dealloc(&buf);
611 return -1;
612 }
613
614 if (r && (c != '\n'))
615 fputc('\r', fp);
616
617 if (c == '\r')
618 {
619 r = true;
620 continue;
621 }
622 else
623 {
624 r = false;
625 }
626
627 fputc(c, fp);
628
629 if ((pos % 1024) == 0)
630 progress_update(progress, pos, -1);
631 if (c_debug_level >= IMAP_LOG_LTRL)
632 buf_addch(&buf, c);
633 }
634
635 if (c_debug_level >= IMAP_LOG_LTRL)
636 {
637 mutt_debug(IMAP_LOG_LTRL, "\n%s", buf.data);
638 buf_dealloc(&buf);
639 }
640 return 0;
641}
642
648void imap_notify_delete_email(struct Mailbox *m, struct Email *e)
649{
650 struct ImapMboxData *mdata = imap_mdata_get(m);
652
653 if (!mdata || !edata)
654 return;
655
656 imap_msn_remove(&mdata->msn, edata->msn - 1);
657 edata->msn = 0;
658}
659
669void imap_expunge_mailbox(struct Mailbox *m, bool resort)
670{
672 struct ImapMboxData *mdata = imap_mdata_get(m);
673 if (!adata || !mdata)
674 return;
675
676 struct Email *e = NULL;
677
678#ifdef USE_HCACHE
679 imap_hcache_open(adata, mdata, false);
680#endif
681
682 for (int i = 0; i < m->msg_count; i++)
683 {
684 e = m->emails[i];
685 if (!e)
686 break;
687
688 if (e->index == INT_MAX)
689 {
690 mutt_debug(LL_DEBUG2, "Expunging message UID %u\n", imap_edata_get(e)->uid);
691
692 e->deleted = true;
693
694 imap_cache_del(m, e);
695#ifdef USE_HCACHE
696 imap_hcache_del(mdata, imap_edata_get(e)->uid);
697#endif
698
699 mutt_hash_int_delete(mdata->uid_hash, imap_edata_get(e)->uid, e);
700
701 imap_edata_free((void **) &e->edata);
702 }
703 else
704 {
705 /* NeoMutt has several places where it turns off e->active as a
706 * hack. For example to avoid FLAG updates, or to exclude from
707 * imap_exec_msg_set.
708 *
709 * Unfortunately, when a reopen is allowed and the IMAP_EXPUNGE_PENDING
710 * flag becomes set (e.g. a flag update to a modified header),
711 * this function will be called by imap_cmd_finish().
712 *
713 * The ctx_update_tables() will free and remove these "inactive" headers,
714 * despite that an EXPUNGE was not received for them.
715 * This would result in memory leaks and segfaults due to dangling
716 * pointers in the msn_index and uid_hash.
717 *
718 * So this is another hack to work around the hacks. We don't want to
719 * remove the messages, so make sure active is on. */
720 e->active = true;
721 }
722 }
723
724#ifdef USE_HCACHE
725 imap_hcache_close(mdata);
726#endif
727
729 if (resort)
730 {
732 }
733}
734
742{
743 if (mutt_socket_open(adata->conn) < 0)
744 return -1;
745
746 adata->state = IMAP_CONNECTED;
747
748 if (imap_cmd_step(adata) != IMAP_RES_OK)
749 {
751 return -1;
752 }
753
754 if (mutt_istr_startswith(adata->buf, "* OK"))
755 {
756 if (!mutt_istr_startswith(adata->buf, "* OK [CAPABILITY") && check_capabilities(adata))
757 {
758 goto bail;
759 }
760#ifdef USE_SSL
761 /* Attempt STARTTLS if available and desired. */
762 const bool c_ssl_force_tls = cs_subset_bool(NeoMutt->sub, "ssl_force_tls");
763 if ((adata->conn->ssf == 0) &&
764 (c_ssl_force_tls || (adata->capabilities & IMAP_CAP_STARTTLS)))
765 {
766 enum QuadOption ans;
767
768 if (c_ssl_force_tls)
769 {
770 ans = MUTT_YES;
771 }
772 else if ((ans = query_quadoption(_("Secure connection with TLS?"),
773 NeoMutt->sub, "ssl_starttls")) == MUTT_ABORT)
774 {
775 goto bail;
776 }
777 if (ans == MUTT_YES)
778 {
779 enum ImapExecResult rc = imap_exec(adata, "STARTTLS", IMAP_CMD_SINGLE);
780 // Clear any data after the STARTTLS acknowledgement
781 mutt_socket_empty(adata->conn);
782
783 if (rc == IMAP_EXEC_FATAL)
784 goto bail;
785 if (rc != IMAP_EXEC_ERROR)
786 {
787 if (mutt_ssl_starttls(adata->conn))
788 {
789 mutt_error(_("Could not negotiate TLS connection"));
790 goto bail;
791 }
792 else
793 {
794 /* RFC2595 demands we recheck CAPABILITY after TLS completes. */
795 if (imap_exec(adata, "CAPABILITY", IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
796 goto bail;
797 }
798 }
799 }
800 }
801
802 if (c_ssl_force_tls && (adata->conn->ssf == 0))
803 {
804 mutt_error(_("Encrypted connection unavailable"));
805 goto bail;
806 }
807#endif
808 }
809 else if (mutt_istr_startswith(adata->buf, "* PREAUTH"))
810 {
811#ifdef USE_SSL
812 /* Unless using a secure $tunnel, an unencrypted PREAUTH response may be a
813 * MITM attack. The only way to stop "STARTTLS" MITM attacks is via
814 * $ssl_force_tls: an attacker can easily spoof "* OK" and strip the
815 * STARTTLS capability. So consult $ssl_force_tls, not $ssl_starttls, to
816 * decide whether to abort. Note that if using $tunnel and
817 * $tunnel_is_secure, adata->conn->ssf will be set to 1. */
818 const bool c_ssl_force_tls = cs_subset_bool(NeoMutt->sub, "ssl_force_tls");
819 if ((adata->conn->ssf == 0) && c_ssl_force_tls)
820 {
821 mutt_error(_("Encrypted connection unavailable"));
822 goto bail;
823 }
824#endif
825
826 adata->state = IMAP_AUTHENTICATED;
827 if (check_capabilities(adata) != 0)
828 goto bail;
829 FREE(&adata->capstr);
830 }
831 else
832 {
833 imap_error("imap_open_connection()", adata->buf);
834 goto bail;
835 }
836
837 return 0;
838
839bail:
841 FREE(&adata->capstr);
842 return -1;
843}
844
850{
851 if (adata->state != IMAP_DISCONNECTED)
852 {
853 mutt_socket_close(adata->conn);
854 adata->state = IMAP_DISCONNECTED;
855 }
856 adata->seqno = 0;
857 adata->nextcmd = 0;
858 adata->lastcmd = 0;
859 adata->status = 0;
860 memset(adata->cmds, 0, sizeof(struct ImapCommand) * adata->cmdslots);
861}
862
874bool imap_has_flag(struct ListHead *flag_list, const char *flag)
875{
876 if (STAILQ_EMPTY(flag_list))
877 return false;
878
879 const size_t flaglen = mutt_str_len(flag);
880 struct ListNode *np = NULL;
881 STAILQ_FOREACH(np, flag_list, entries)
882 {
883 const size_t nplen = strlen(np->data);
884 if ((flaglen >= nplen) && ((flag[nplen] == '\0') || (flag[nplen] == ' ')) &&
885 mutt_istrn_equal(np->data, flag, nplen))
886 {
887 return true;
888 }
889
890 if (mutt_str_equal(np->data, "\\*"))
891 return true;
892 }
893
894 return false;
895}
896
900static int imap_sort_email_uid(const void *a, const void *b, void *sdata)
901{
902 const struct Email *ea = *(struct Email const *const *) a;
903 const struct Email *eb = *(struct Email const *const *) b;
904
905 const unsigned int ua = imap_edata_get((struct Email *) ea)->uid;
906 const unsigned int ub = imap_edata_get((struct Email *) eb)->uid;
907
908 return mutt_numeric_cmp(ua, ub);
909}
910
926int imap_sync_message_for_copy(struct Mailbox *m, struct Email *e,
927 struct Buffer *cmd, enum QuadOption *err_continue)
928{
931
932 if (!adata || (adata->mailbox != m) || !e)
933 return -1;
934
936 {
937 if (e->deleted == edata->deleted)
938 e->changed = false;
939 return 0;
940 }
941
942 buf_printf(cmd, "UID STORE %u", edata->uid);
943
944 struct Buffer *flags = buf_pool_get();
945
946 set_flag(m, MUTT_ACL_SEEN, e->read, "\\Seen ", flags);
947 set_flag(m, MUTT_ACL_WRITE, e->old, "Old ", flags);
948 set_flag(m, MUTT_ACL_WRITE, e->flagged, "\\Flagged ", flags);
949 set_flag(m, MUTT_ACL_WRITE, e->replied, "\\Answered ", flags);
950 set_flag(m, MUTT_ACL_DELETE, edata->deleted, "\\Deleted ", flags);
951
952 if (m->rights & MUTT_ACL_WRITE)
953 {
954 /* restore system flags */
955 if (edata->flags_system)
956 buf_addstr(flags, edata->flags_system);
957
958 /* set custom flags */
959 struct Buffer *tags = buf_pool_get();
961 if (!buf_is_empty(tags))
962 buf_addstr(flags, buf_string(tags));
963 buf_pool_release(&tags);
964 }
965
967 buf_fix_dptr(flags);
968
969 /* UW-IMAP is OK with null flags, Cyrus isn't. The only solution is to
970 * explicitly revoke all system flags (if we have permission) */
971 if (buf_is_empty(flags))
972 {
973 set_flag(m, MUTT_ACL_SEEN, true, "\\Seen ", flags);
974 set_flag(m, MUTT_ACL_WRITE, true, "Old ", flags);
975 set_flag(m, MUTT_ACL_WRITE, true, "\\Flagged ", flags);
976 set_flag(m, MUTT_ACL_WRITE, true, "\\Answered ", flags);
977 set_flag(m, MUTT_ACL_DELETE, !edata->deleted, "\\Deleted ", flags);
978
979 /* erase custom flags */
980 if ((m->rights & MUTT_ACL_WRITE) && edata->flags_remote)
981 buf_addstr(flags, edata->flags_remote);
982
984 buf_fix_dptr(flags);
985
986 buf_addstr(cmd, " -FLAGS.SILENT (");
987 }
988 else
989 {
990 buf_addstr(cmd, " FLAGS.SILENT (");
991 }
992
993 buf_addstr(cmd, buf_string(flags));
994 buf_addstr(cmd, ")");
995
996 int rc = -1;
997
998 /* after all this it's still possible to have no flags, if you
999 * have no ACL rights */
1000 if (!buf_is_empty(flags) &&
1002 err_continue && (*err_continue != MUTT_YES))
1003 {
1004 *err_continue = imap_continue("imap_sync_message: STORE failed", adata->buf);
1005 if (*err_continue != MUTT_YES)
1006 goto done;
1007 }
1008
1009 /* server have now the updated flags */
1010 FREE(&edata->flags_remote);
1011 struct Buffer *flags_remote = buf_pool_get();
1012 driver_tags_get_with_hidden(&e->tags, flags_remote);
1013 edata->flags_remote = buf_strdup(flags_remote);
1014 buf_pool_release(&flags_remote);
1015
1016 if (e->deleted == edata->deleted)
1017 e->changed = false;
1018
1019 rc = 0;
1020
1021done:
1022 buf_pool_release(&flags);
1023 return rc;
1024}
1025
1032enum MxStatus imap_check_mailbox(struct Mailbox *m, bool force)
1033{
1034 if (!m || !m->account)
1035 return MX_STATUS_ERROR;
1036
1038 struct ImapMboxData *mdata = imap_mdata_get(m);
1039
1040 /* overload keyboard timeout to avoid many mailbox checks in a row.
1041 * Most users don't like having to wait exactly when they press a key. */
1042 int rc = 0;
1043
1044 /* try IDLE first, unless force is set */
1045 const bool c_imap_idle = cs_subset_bool(NeoMutt->sub, "imap_idle");
1046 const short c_imap_keep_alive = cs_subset_number(NeoMutt->sub, "imap_keep_alive");
1047 if (!force && c_imap_idle && (adata->capabilities & IMAP_CAP_IDLE) &&
1048 ((adata->state != IMAP_IDLE) || (mutt_date_now() >= adata->lastread + c_imap_keep_alive)))
1049 {
1050 if (imap_cmd_idle(adata) < 0)
1051 return MX_STATUS_ERROR;
1052 }
1053 if (adata->state == IMAP_IDLE)
1054 {
1055 while ((rc = mutt_socket_poll(adata->conn, 0)) > 0)
1056 {
1057 if (imap_cmd_step(adata) != IMAP_RES_CONTINUE)
1058 {
1059 mutt_debug(LL_DEBUG1, "Error reading IDLE response\n");
1060 return MX_STATUS_ERROR;
1061 }
1062 }
1063 if (rc < 0)
1064 {
1065 mutt_debug(LL_DEBUG1, "Poll failed, disabling IDLE\n");
1066 adata->capabilities &= ~IMAP_CAP_IDLE; // Clear the flag
1067 }
1068 }
1069
1070 const short c_timeout = cs_subset_number(NeoMutt->sub, "timeout");
1071 if ((force || ((adata->state != IMAP_IDLE) && (mutt_date_now() >= adata->lastread + c_timeout))) &&
1072 (imap_exec(adata, "NOOP", IMAP_CMD_POLL) != IMAP_EXEC_SUCCESS))
1073 {
1074 return MX_STATUS_ERROR;
1075 }
1076
1077 /* We call this even when we haven't run NOOP in case we have pending
1078 * changes to process, since we can reopen here. */
1079 imap_cmd_finish(adata);
1080
1081 enum MxStatus check = MX_STATUS_OK;
1082 if (mdata->check_status & IMAP_EXPUNGE_PENDING)
1083 check = MX_STATUS_REOPENED;
1084 else if (mdata->check_status & IMAP_NEWMAIL_PENDING)
1085 check = MX_STATUS_NEW_MAIL;
1086 else if (mdata->check_status & IMAP_FLAGS_PENDING)
1087 check = MX_STATUS_FLAGS;
1088 else if (rc < 0)
1089 check = MX_STATUS_ERROR;
1090
1091 mdata->check_status = IMAP_OPEN_NO_FLAGS;
1092
1093 if (force)
1094 m->last_checked = 0; // force a check on the next mx_mbox_check() call
1095 return check;
1096}
1097
1105static int imap_status(struct ImapAccountData *adata, struct ImapMboxData *mdata, bool queue)
1106{
1107 char *uidvalidity_flag = NULL;
1108 char cmd[2048] = { 0 };
1109
1110 if (!adata || !mdata)
1111 return -1;
1112
1113 /* Don't issue STATUS on the selected mailbox, it will be NOOPed or
1114 * IDLEd elsewhere.
1115 * adata->mailbox may be NULL for connections other than the current
1116 * mailbox's. */
1117 if (adata->mailbox && (adata->mailbox->mdata == mdata))
1118 {
1119 adata->mailbox->has_new = false;
1120 return mdata->messages;
1121 }
1122
1123 if (adata->mailbox && !adata->mailbox->poll_new_mail)
1124 return mdata->messages;
1125
1126 if (adata->capabilities & IMAP_CAP_IMAP4REV1)
1127 {
1128 uidvalidity_flag = "UIDVALIDITY";
1129 }
1130 else if (adata->capabilities & IMAP_CAP_STATUS)
1131 {
1132 uidvalidity_flag = "UID-VALIDITY";
1133 }
1134 else
1135 {
1136 mutt_debug(LL_DEBUG2, "Server doesn't support STATUS\n");
1137 return -1;
1138 }
1139
1140 snprintf(cmd, sizeof(cmd), "STATUS %s (UIDNEXT %s UNSEEN RECENT MESSAGES)",
1141 mdata->munge_name, uidvalidity_flag);
1142
1143 int rc = imap_exec(adata, cmd, queue ? IMAP_CMD_QUEUE : IMAP_CMD_POLL);
1144 if (rc != IMAP_EXEC_SUCCESS)
1145 {
1146 mutt_debug(LL_DEBUG1, "Error queueing command\n");
1147 return rc;
1148 }
1149 return mdata->messages;
1150}
1151
1155static enum MxStatus imap_mbox_check_stats(struct Mailbox *m, uint8_t flags)
1156{
1157 const bool queue = (flags & MUTT_MAILBOX_CHECK_IMMEDIATE) == 0;
1158 const int new_msgs = imap_mailbox_status(m, queue);
1159 if (new_msgs == -1)
1160 return MX_STATUS_ERROR;
1161 if (new_msgs == 0)
1162 return MX_STATUS_OK;
1163 return MX_STATUS_NEW_MAIL;
1164}
1165
1172int imap_path_status(const char *path, bool queue)
1173{
1174 struct Mailbox *m = mx_mbox_find2(path);
1175
1176 const bool is_temp = !m;
1177 if (is_temp)
1178 {
1179 m = mx_path_resolve(path);
1180 if (!mx_mbox_ac_link(m))
1181 {
1182 mailbox_free(&m);
1183 return 0;
1184 }
1185 }
1186
1187 int rc = imap_mailbox_status(m, queue);
1188
1189 if (is_temp)
1190 {
1191 mx_ac_remove(m, false);
1192 mailbox_free(&m);
1193 }
1194
1195 return rc;
1196}
1197
1207int imap_mailbox_status(struct Mailbox *m, bool queue)
1208{
1210 struct ImapMboxData *mdata = imap_mdata_get(m);
1211 if (!adata || !mdata)
1212 return -1;
1213 return imap_status(adata, mdata, queue);
1214}
1215
1223int imap_subscribe(const char *path, bool subscribe)
1224{
1225 struct ImapAccountData *adata = NULL;
1226 struct ImapMboxData *mdata = NULL;
1227
1228 if (imap_adata_find(path, &adata, &mdata) < 0)
1229 return -1;
1230
1231 if (subscribe)
1232 mutt_message(_("Subscribing to %s..."), mdata->name);
1233 else
1234 mutt_message(_("Unsubscribing from %s..."), mdata->name);
1235
1236 char buf[2048] = { 0 };
1237 snprintf(buf, sizeof(buf), "%sSUBSCRIBE %s", subscribe ? "" : "UN", mdata->munge_name);
1238
1239 if (imap_exec(adata, buf, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
1240 {
1241 imap_mdata_free((void *) &mdata);
1242 return -1;
1243 }
1244
1245 const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
1246 if (c_imap_check_subscribed)
1247 {
1248 char mbox[1024] = { 0 };
1249 size_t len = snprintf(mbox, sizeof(mbox), "%smailboxes ", subscribe ? "" : "un");
1250 imap_quote_string(mbox + len, sizeof(mbox) - len, path, true);
1251 struct Buffer *err = buf_pool_get();
1252 if (parse_rc_line(mbox, err))
1253 mutt_debug(LL_DEBUG1, "Error adding subscribed mailbox: %s\n", buf_string(err));
1254 buf_pool_release(&err);
1255 }
1256
1257 if (subscribe)
1258 mutt_message(_("Subscribed to %s"), mdata->name);
1259 else
1260 mutt_message(_("Unsubscribed from %s"), mdata->name);
1261 imap_mdata_free((void *) &mdata);
1262 return 0;
1263}
1264
1275int imap_complete(struct Buffer *buf, const char *path)
1276{
1277 struct ImapAccountData *adata = NULL;
1278 struct ImapMboxData *mdata = NULL;
1279 char tmp[2048] = { 0 };
1280 struct ImapList listresp = { 0 };
1281 struct Buffer *completion_buf = NULL;
1282 size_t clen;
1283 int completions = 0;
1284 int rc;
1285
1286 if (imap_adata_find(path, &adata, &mdata) < 0)
1287 {
1288 buf_strcpy(buf, path);
1289 return complete_hosts(buf);
1290 }
1291
1292 /* fire off command */
1293 const bool c_imap_list_subscribed = cs_subset_bool(NeoMutt->sub, "imap_list_subscribed");
1294 snprintf(tmp, sizeof(tmp), "%s \"\" \"%s%%\"",
1295 c_imap_list_subscribed ? "LSUB" : "LIST", mdata->real_name);
1296
1297 imap_cmd_start(adata, tmp);
1298
1299 /* and see what the results are */
1300 completion_buf = buf_pool_get();
1301 buf_strcpy(completion_buf, mdata->name);
1302 imap_mdata_free((void *) &mdata);
1303
1304 adata->cmdresult = &listresp;
1305 do
1306 {
1307 listresp.name = NULL;
1308 rc = imap_cmd_step(adata);
1309
1310 if ((rc == IMAP_RES_CONTINUE) && listresp.name)
1311 {
1312 /* if the folder isn't selectable, append delimiter to force browse
1313 * to enter it on second tab. */
1314 if (listresp.noselect)
1315 {
1316 clen = strlen(listresp.name);
1317 listresp.name[clen++] = listresp.delim;
1318 listresp.name[clen] = '\0';
1319 }
1320 /* copy in first word */
1321 if (!completions)
1322 {
1323 buf_strcpy(completion_buf, listresp.name);
1324 completions++;
1325 continue;
1326 }
1327
1328 longest_common_prefix(completion_buf, listresp.name, 0);
1329 completions++;
1330 }
1331 } while (rc == IMAP_RES_CONTINUE);
1332 adata->cmdresult = NULL;
1333
1334 if (completions)
1335 {
1336 /* reformat output */
1337 imap_buf_qualify_path(buf, &adata->conn->account, completion_buf->data);
1338 buf_pretty_mailbox(buf);
1339 buf_fix_dptr(buf);
1340 buf_pool_release(&completion_buf);
1341 return 0;
1342 }
1343
1344 buf_pool_release(&completion_buf);
1345 return -1;
1346}
1347
1356int imap_fast_trash(struct Mailbox *m, const char *dest)
1357{
1358 char prompt[1024] = { 0 };
1359 int rc = -1;
1360 bool triedcreate = false;
1361 enum QuadOption err_continue = MUTT_NO;
1362
1364 struct ImapAccountData *dest_adata = NULL;
1365 struct ImapMboxData *dest_mdata = NULL;
1366
1367 if (imap_adata_find(dest, &dest_adata, &dest_mdata) < 0)
1368 return -1;
1369
1370 struct Buffer *sync_cmd = buf_pool_get();
1371
1372 /* check that the save-to folder is in the same account */
1373 if (!imap_account_match(&(adata->conn->account), &(dest_adata->conn->account)))
1374 {
1375 mutt_debug(LL_DEBUG3, "%s not same server as %s\n", dest, mailbox_path(m));
1376 goto out;
1377 }
1378
1379 for (int i = 0; i < m->msg_count; i++)
1380 {
1381 struct Email *e = m->emails[i];
1382 if (!e)
1383 break;
1384 if (e->active && e->changed && e->deleted && !e->purge)
1385 {
1386 rc = imap_sync_message_for_copy(m, e, sync_cmd, &err_continue);
1387 if (rc < 0)
1388 {
1389 mutt_debug(LL_DEBUG1, "could not sync\n");
1390 goto out;
1391 }
1392 }
1393 }
1394
1395 /* loop in case of TRYCREATE */
1396 do
1397 {
1398 struct UidArray uida = ARRAY_HEAD_INITIALIZER;
1399 select_email_uids(m->emails, m->msg_count, MUTT_TRASH, false, false, &uida);
1400 ARRAY_SORT(&uida, imap_sort_uid, NULL);
1401 rc = imap_exec_msg_set(adata, "UID COPY", dest_mdata->munge_name, &uida);
1402 if (rc == 0)
1403 {
1404 mutt_debug(LL_DEBUG1, "No messages to trash\n");
1405 rc = -1;
1406 goto out;
1407 }
1408 else if (rc < 0)
1409 {
1410 mutt_debug(LL_DEBUG1, "could not queue copy\n");
1411 goto out;
1412 }
1413 else if (m->verbose)
1414 {
1415 mutt_message(ngettext("Copying %d message to %s...", "Copying %d messages to %s...", rc),
1416 rc, dest_mdata->name);
1417 }
1418 ARRAY_FREE(&uida);
1419
1420 /* let's get it on */
1421 rc = imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS);
1422 if (rc == IMAP_EXEC_ERROR)
1423 {
1424 if (triedcreate)
1425 {
1426 mutt_debug(LL_DEBUG1, "Already tried to create mailbox %s\n", dest_mdata->name);
1427 break;
1428 }
1429 /* bail out if command failed for reasons other than nonexistent target */
1430 if (!mutt_istr_startswith(imap_get_qualifier(adata->buf), "[TRYCREATE]"))
1431 break;
1432 mutt_debug(LL_DEBUG3, "server suggests TRYCREATE\n");
1433 snprintf(prompt, sizeof(prompt), _("Create %s?"), dest_mdata->name);
1434 const bool c_confirm_create = cs_subset_bool(NeoMutt->sub, "confirm_create");
1435 if (c_confirm_create &&
1436 (query_yesorno_help(prompt, MUTT_YES, NeoMutt->sub, "confirm_create") != MUTT_YES))
1437 {
1439 goto out;
1440 }
1441 if (imap_create_mailbox(adata, dest_mdata->name) < 0)
1442 break;
1443 triedcreate = true;
1444 }
1445 } while (rc == IMAP_EXEC_ERROR);
1446
1447 if (rc != IMAP_EXEC_SUCCESS)
1448 {
1449 imap_error("imap_fast_trash", adata->buf);
1450 goto out;
1451 }
1452
1453 rc = IMAP_EXEC_SUCCESS;
1454
1455out:
1456 buf_pool_release(&sync_cmd);
1457 imap_mdata_free((void *) &dest_mdata);
1458
1459 return ((rc == IMAP_EXEC_SUCCESS) ? 0 : -1);
1460}
1461
1471enum MxStatus imap_sync_mailbox(struct Mailbox *m, bool expunge, bool close)
1472{
1473 if (!m)
1474 return -1;
1475
1476 struct Email **emails = NULL;
1477 int rc;
1478
1480 struct ImapMboxData *mdata = imap_mdata_get(m);
1481
1482 if (adata->state < IMAP_SELECTED)
1483 {
1484 mutt_debug(LL_DEBUG2, "no mailbox selected\n");
1485 return -1;
1486 }
1487
1488 /* This function is only called when the calling code expects the context
1489 * to be changed. */
1491
1492 enum MxStatus check = imap_check_mailbox(m, false);
1493 if (check == MX_STATUS_ERROR)
1494 return check;
1495
1496 /* if we are expunging anyway, we can do deleted messages very quickly... */
1497 if (expunge && (m->rights & MUTT_ACL_DELETE))
1498 {
1499 struct UidArray uida = ARRAY_HEAD_INITIALIZER;
1500 select_email_uids(m->emails, m->msg_count, MUTT_DELETED, true, false, &uida);
1501 ARRAY_SORT(&uida, imap_sort_uid, NULL);
1502 rc = imap_exec_msg_set(adata, "UID STORE", "+FLAGS.SILENT (\\Deleted)", &uida);
1503 ARRAY_FREE(&uida);
1504 if (rc < 0)
1505 {
1506 mutt_error(_("Expunge failed"));
1507 return rc;
1508 }
1509
1510 if (rc > 0)
1511 {
1512 /* mark these messages as unchanged so second pass ignores them. Done
1513 * here so BOGUS UW-IMAP 4.7 SILENT FLAGS updates are ignored. */
1514 for (int i = 0; i < m->msg_count; i++)
1515 {
1516 struct Email *e = m->emails[i];
1517 if (!e)
1518 break;
1519 if (e->deleted && e->changed)
1520 e->active = false;
1521 }
1522 if (m->verbose)
1523 {
1524 mutt_message(ngettext("Marking %d message deleted...",
1525 "Marking %d messages deleted...", rc),
1526 rc);
1527 }
1528 }
1529 }
1530
1531#ifdef USE_HCACHE
1532 imap_hcache_open(adata, mdata, true);
1533#endif
1534
1535 /* save messages with real (non-flag) changes */
1536 for (int i = 0; i < m->msg_count; i++)
1537 {
1538 struct Email *e = m->emails[i];
1539 if (!e)
1540 break;
1541
1542 if (e->deleted)
1543 {
1544 imap_cache_del(m, e);
1545#ifdef USE_HCACHE
1546 imap_hcache_del(mdata, imap_edata_get(e)->uid);
1547#endif
1548 }
1549
1550 if (e->active && e->changed)
1551 {
1552#ifdef USE_HCACHE
1553 imap_hcache_put(mdata, e);
1554#endif
1555 /* if the message has been rethreaded or attachments have been deleted
1556 * we delete the message and reupload it.
1557 * This works better if we're expunging, of course. */
1558 if (e->env->changed || e->attach_del)
1559 {
1560 /* L10N: The plural is chosen by the last %d, i.e. the total number */
1561 if (m->verbose)
1562 {
1563 mutt_message(ngettext("Saving changed message... [%d/%d]",
1564 "Saving changed messages... [%d/%d]", m->msg_count),
1565 i + 1, m->msg_count);
1566 }
1567 bool save_append = m->append;
1568 m->append = true;
1570 m->append = save_append;
1571 e->env->changed = false;
1572 }
1573 }
1574 }
1575
1576#ifdef USE_HCACHE
1577 imap_hcache_close(mdata);
1578#endif
1579
1580 /* presort here to avoid doing 10 resorts in imap_exec_msg_set */
1581 emails = mutt_mem_malloc(m->msg_count * sizeof(struct Email *));
1582 memcpy(emails, m->emails, m->msg_count * sizeof(struct Email *));
1583 mutt_qsort_r(emails, m->msg_count, sizeof(struct Email *), imap_sort_email_uid, NULL);
1584
1585 rc = sync_helper(m, emails, m->msg_count, MUTT_ACL_DELETE, MUTT_DELETED, "\\Deleted");
1586 if (rc >= 0)
1587 rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_WRITE, MUTT_FLAG, "\\Flagged");
1588 if (rc >= 0)
1589 rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_WRITE, MUTT_OLD, "Old");
1590 if (rc >= 0)
1591 rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_SEEN, MUTT_READ, "\\Seen");
1592 if (rc >= 0)
1593 rc |= sync_helper(m, emails, m->msg_count, MUTT_ACL_WRITE, MUTT_REPLIED, "\\Answered");
1594
1595 FREE(&emails);
1596
1597 /* Flush the queued flags if any were changed in sync_helper. */
1598 if (rc > 0)
1599 if (imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
1600 rc = -1;
1601
1602 if (rc < 0)
1603 {
1604 if (close)
1605 {
1606 if (query_yesorno(_("Error saving flags. Close anyway?"), MUTT_NO) == MUTT_YES)
1607 {
1608 adata->state = IMAP_AUTHENTICATED;
1609 return 0;
1610 }
1611 }
1612 else
1613 {
1614 mutt_error(_("Error saving flags"));
1615 }
1616 return -1;
1617 }
1618
1619 /* Update local record of server state to reflect the synchronization just
1620 * completed. imap_read_headers always overwrites hcache-origin flags, so
1621 * there is no need to mutate the hcache after flag-only changes. */
1622 for (int i = 0; i < m->msg_count; i++)
1623 {
1624 struct Email *e = m->emails[i];
1625 if (!e)
1626 break;
1627 struct ImapEmailData *edata = imap_edata_get(e);
1628 edata->deleted = e->deleted;
1629 edata->flagged = e->flagged;
1630 edata->old = e->old;
1631 edata->read = e->read;
1632 edata->replied = e->replied;
1633 e->changed = false;
1634 }
1635 m->changed = false;
1636
1637 /* We must send an EXPUNGE command if we're not closing. */
1638 if (expunge && !close && (m->rights & MUTT_ACL_DELETE))
1639 {
1640 if (m->verbose)
1641 mutt_message(_("Expunging messages from server..."));
1642 /* Set expunge bit so we don't get spurious reopened messages */
1643 mdata->reopen |= IMAP_EXPUNGE_EXPECTED;
1644 if (imap_exec(adata, "EXPUNGE", IMAP_CMD_NO_FLAGS) != IMAP_EXEC_SUCCESS)
1645 {
1646 mdata->reopen &= ~IMAP_EXPUNGE_EXPECTED;
1647 imap_error(_("imap_sync_mailbox: EXPUNGE failed"), adata->buf);
1648 return -1;
1649 }
1650 mdata->reopen &= ~IMAP_EXPUNGE_EXPECTED;
1651 }
1652
1653 if (expunge && close)
1654 {
1655 adata->closing = true;
1656 imap_exec(adata, "CLOSE", IMAP_CMD_NO_FLAGS);
1657 adata->state = IMAP_AUTHENTICATED;
1658 }
1659
1660 const bool c_message_cache_clean = cs_subset_bool(NeoMutt->sub, "message_cache_clean");
1661 if (c_message_cache_clean)
1663
1664 return check;
1665}
1666
1670static bool imap_ac_owns_path(struct Account *a, const char *path)
1671{
1672 struct Url *url = url_parse(path);
1673 if (!url)
1674 return false;
1675
1676 struct ImapAccountData *adata = a->adata;
1677 struct ConnAccount *cac = &adata->conn->account;
1678
1679 const bool rc = mutt_istr_equal(url->host, cac->host) &&
1680 (!url->user || mutt_istr_equal(url->user, cac->user));
1681 url_free(&url);
1682 return rc;
1683}
1684
1688static bool imap_ac_add(struct Account *a, struct Mailbox *m)
1689{
1690 struct ImapAccountData *adata = a->adata;
1691
1692 if (!adata)
1693 {
1694 struct ConnAccount cac = { { 0 } };
1695 char mailbox[PATH_MAX] = { 0 };
1696
1697 if (imap_parse_path(mailbox_path(m), &cac, mailbox, sizeof(mailbox)) < 0)
1698 return false;
1699
1700 adata = imap_adata_new(a);
1701 adata->conn = mutt_conn_new(&cac);
1702 if (!adata->conn)
1703 {
1704 imap_adata_free((void **) &adata);
1705 return false;
1706 }
1707
1709
1710 if (imap_login(adata) < 0)
1711 {
1712 imap_adata_free((void **) &adata);
1713 return false;
1714 }
1715
1716 a->adata = adata;
1718 }
1719
1720 if (!m->mdata)
1721 {
1722 struct Url *url = url_parse(mailbox_path(m));
1723 if (!url)
1724 return false;
1725 struct ImapMboxData *mdata = imap_mdata_new(adata, url->path);
1726
1727 /* fixup path and realpath, mainly to replace / by /INBOX */
1728 char buf[1024] = { 0 };
1729 imap_qualify_path(buf, sizeof(buf), &adata->conn->account, mdata->name);
1730 buf_strcpy(&m->pathbuf, buf);
1732
1733 m->mdata = mdata;
1735 url_free(&url);
1736 }
1737 return true;
1738}
1739
1744static void imap_mbox_select(struct Mailbox *m)
1745{
1747 struct ImapMboxData *mdata = imap_mdata_get(m);
1748 if (!adata || !mdata)
1749 return;
1750
1751 const char *condstore = NULL;
1752#ifdef USE_HCACHE
1753 const bool c_imap_condstore = cs_subset_bool(NeoMutt->sub, "imap_condstore");
1754 if ((adata->capabilities & IMAP_CAP_CONDSTORE) && c_imap_condstore)
1755 condstore = " (CONDSTORE)";
1756 else
1757#endif
1758 condstore = "";
1759
1760 char buf[PATH_MAX] = { 0 };
1761 snprintf(buf, sizeof(buf), "%s %s%s", m->readonly ? "EXAMINE" : "SELECT",
1762 mdata->munge_name, condstore);
1763
1764 adata->state = IMAP_SELECTED;
1765
1766 imap_cmd_start(adata, buf);
1767}
1768
1777int imap_login(struct ImapAccountData *adata)
1778{
1779 if (!adata)
1780 return -1;
1781
1782 if (adata->state == IMAP_DISCONNECTED)
1783 {
1784 buf_reset(&adata->cmdbuf); // purge outstanding queued commands
1785 imap_open_connection(adata);
1786 }
1787 if (adata->state == IMAP_CONNECTED)
1788 {
1790 {
1791 adata->state = IMAP_AUTHENTICATED;
1792 FREE(&adata->capstr);
1793 if (adata->conn->ssf != 0)
1794 {
1795 mutt_debug(LL_DEBUG2, "Communication encrypted at %d bits\n",
1796 adata->conn->ssf);
1797 }
1798 }
1799 else
1800 {
1802 }
1803 }
1804 if (adata->state == IMAP_AUTHENTICATED)
1805 {
1806 /* capabilities may have changed */
1807 imap_exec(adata, "CAPABILITY", IMAP_CMD_PASS);
1808
1809#ifdef USE_ZLIB
1810 /* RFC4978 */
1811 const bool c_imap_deflate = cs_subset_bool(NeoMutt->sub, "imap_deflate");
1812 if ((adata->capabilities & IMAP_CAP_COMPRESS) && c_imap_deflate &&
1813 (imap_exec(adata, "COMPRESS DEFLATE", IMAP_CMD_PASS) == IMAP_EXEC_SUCCESS))
1814 {
1815 mutt_debug(LL_DEBUG2, "IMAP compression is enabled on connection to %s\n",
1816 adata->conn->account.host);
1817 mutt_zstrm_wrap_conn(adata->conn);
1818 }
1819#endif
1820
1821 /* enable RFC2971, if the server supports that */
1822 const bool c_imap_send_id = cs_subset_bool(NeoMutt->sub, "imap_send_id");
1823 if (c_imap_send_id && (adata->capabilities & IMAP_CAP_ID))
1824 {
1825 imap_exec(adata, "ID (\"name\" \"NeoMutt\" \"version\" \"" PACKAGE_VERSION "\")",
1827 }
1828
1829 /* enable RFC6855, if the server supports that */
1830 const bool c_imap_rfc5161 = cs_subset_bool(NeoMutt->sub, "imap_rfc5161");
1831 if (c_imap_rfc5161 && (adata->capabilities & IMAP_CAP_ENABLE))
1832 imap_exec(adata, "ENABLE UTF8=ACCEPT", IMAP_CMD_QUEUE);
1833
1834 /* enable QRESYNC. Advertising QRESYNC also means CONDSTORE
1835 * is supported (even if not advertised), so flip that bit. */
1836 if (adata->capabilities & IMAP_CAP_QRESYNC)
1837 {
1839 const bool c_imap_qresync = cs_subset_bool(NeoMutt->sub, "imap_qresync");
1840 if (c_imap_rfc5161 && c_imap_qresync)
1841 imap_exec(adata, "ENABLE QRESYNC", IMAP_CMD_QUEUE);
1842 }
1843
1844 /* get root delimiter, '/' as default */
1845 adata->delim = '/';
1846 imap_exec(adata, "LIST \"\" \"\"", IMAP_CMD_QUEUE);
1847
1848 /* we may need the root delimiter before we open a mailbox */
1849 imap_exec(adata, NULL, IMAP_CMD_NO_FLAGS);
1850
1851 /* select the mailbox that used to be open before disconnect */
1852 if (adata->mailbox)
1853 {
1854 imap_mbox_select(adata->mailbox);
1855 }
1856 }
1857
1858 if (adata->state < IMAP_AUTHENTICATED)
1859 return -1;
1860
1861 return 0;
1862}
1863
1868{
1869 if (!m->account || !m->mdata)
1870 return MX_OPEN_ERROR;
1871
1872 char buf[PATH_MAX] = { 0 };
1873 int count = 0;
1874 int rc;
1875
1877 struct ImapMboxData *mdata = imap_mdata_get(m);
1878
1879 mutt_debug(LL_DEBUG3, "opening %s, saving %s\n", m->pathbuf.data,
1880 (adata->mailbox ? adata->mailbox->pathbuf.data : "(none)"));
1881 adata->prev_mailbox = adata->mailbox;
1882 adata->mailbox = m;
1883
1884 /* clear mailbox status */
1885 adata->status = 0;
1886 m->rights = 0;
1887 mdata->new_mail_count = 0;
1888
1889 if (m->verbose)
1890 mutt_message(_("Selecting %s..."), mdata->name);
1891
1892 /* pipeline ACL test */
1893 if (adata->capabilities & IMAP_CAP_ACL)
1894 {
1895 snprintf(buf, sizeof(buf), "MYRIGHTS %s", mdata->munge_name);
1896 imap_exec(adata, buf, IMAP_CMD_QUEUE);
1897 }
1898 else
1899 {
1900 /* assume we have all rights if ACL is unavailable */
1903 }
1904
1905 /* pipeline the postponed count if possible */
1906 const char *const c_postponed = cs_subset_string(NeoMutt->sub, "postponed");
1907 struct Mailbox *m_postponed = mx_mbox_find2(c_postponed);
1908 struct ImapAccountData *postponed_adata = imap_adata_get(m_postponed);
1909 if (postponed_adata &&
1910 imap_account_match(&postponed_adata->conn->account, &adata->conn->account))
1911 {
1912 imap_mailbox_status(m_postponed, true);
1913 }
1914
1915 const bool c_imap_check_subscribed = cs_subset_bool(NeoMutt->sub, "imap_check_subscribed");
1916 if (c_imap_check_subscribed)
1917 imap_exec(adata, "LSUB \"\" \"*\"", IMAP_CMD_QUEUE);
1918
1920
1921 do
1922 {
1923 char *pc = NULL;
1924
1925 rc = imap_cmd_step(adata);
1926 if (rc != IMAP_RES_CONTINUE)
1927 break;
1928
1929 if (!mutt_strn_equal(adata->buf, "* ", 2))
1930 continue;
1931 pc = imap_next_word(adata->buf);
1932
1933 /* Obtain list of available flags here, may be overridden by a
1934 * PERMANENTFLAGS tag in the OK response */
1935 if (mutt_istr_startswith(pc, "FLAGS"))
1936 {
1937 /* don't override PERMANENTFLAGS */
1938 if (STAILQ_EMPTY(&mdata->flags))
1939 {
1940 mutt_debug(LL_DEBUG3, "Getting mailbox FLAGS\n");
1941 pc = get_flags(&mdata->flags, pc);
1942 if (!pc)
1943 goto fail;
1944 }
1945 }
1946 else if (mutt_istr_startswith(pc, "OK [PERMANENTFLAGS"))
1947 {
1948 /* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */
1949 mutt_debug(LL_DEBUG3, "Getting mailbox PERMANENTFLAGS\n");
1950 /* safe to call on NULL */
1951 mutt_list_free(&mdata->flags);
1952 /* skip "OK [PERMANENT" so syntax is the same as FLAGS */
1953 pc += 13;
1954 pc = get_flags(&(mdata->flags), pc);
1955 if (!pc)
1956 goto fail;
1957 }
1958 else if (mutt_istr_startswith(pc, "OK [UIDVALIDITY"))
1959 {
1960 /* save UIDVALIDITY for the header cache */
1961 mutt_debug(LL_DEBUG3, "Getting mailbox UIDVALIDITY\n");
1962 pc += 3;
1963 pc = imap_next_word(pc);
1964 if (!mutt_str_atoui(pc, &mdata->uidvalidity))
1965 goto fail;
1966 }
1967 else if (mutt_istr_startswith(pc, "OK [UIDNEXT"))
1968 {
1969 mutt_debug(LL_DEBUG3, "Getting mailbox UIDNEXT\n");
1970 pc += 3;
1971 pc = imap_next_word(pc);
1972 if (!mutt_str_atoui(pc, &mdata->uid_next))
1973 goto fail;
1974 }
1975 else if (mutt_istr_startswith(pc, "OK [HIGHESTMODSEQ"))
1976 {
1977 mutt_debug(LL_DEBUG3, "Getting mailbox HIGHESTMODSEQ\n");
1978 pc += 3;
1979 pc = imap_next_word(pc);
1980 if (!mutt_str_atoull(pc, &mdata->modseq))
1981 goto fail;
1982 }
1983 else if (mutt_istr_startswith(pc, "OK [NOMODSEQ"))
1984 {
1985 mutt_debug(LL_DEBUG3, "Mailbox has NOMODSEQ set\n");
1986 mdata->modseq = 0;
1987 }
1988 else
1989 {
1990 pc = imap_next_word(pc);
1991 if (mutt_istr_startswith(pc, "EXISTS"))
1992 {
1993 count = mdata->new_mail_count;
1994 mdata->new_mail_count = 0;
1995 }
1996 }
1997 } while (rc == IMAP_RES_CONTINUE);
1998
1999 if (rc == IMAP_RES_NO)
2000 {
2001 char *s = imap_next_word(adata->buf); /* skip seq */
2002 s = imap_next_word(s); /* Skip response */
2003 mutt_error("%s", s);
2004 goto fail;
2005 }
2006
2007 if (rc != IMAP_RES_OK)
2008 goto fail;
2009
2010 /* check for READ-ONLY notification */
2011 if (mutt_istr_startswith(imap_get_qualifier(adata->buf), "[READ-ONLY]") &&
2012 !(adata->capabilities & IMAP_CAP_ACL))
2013 {
2014 mutt_debug(LL_DEBUG2, "Mailbox is read-only\n");
2015 m->readonly = true;
2016 }
2017
2018 /* dump the mailbox flags we've found */
2019 const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
2020 if (c_debug_level > LL_DEBUG2)
2021 {
2022 if (STAILQ_EMPTY(&mdata->flags))
2023 {
2024 mutt_debug(LL_DEBUG3, "No folder flags found\n");
2025 }
2026 else
2027 {
2028 struct ListNode *np = NULL;
2029 struct Buffer *flag_buffer = buf_pool_get();
2030 buf_printf(flag_buffer, "Mailbox flags: ");
2031 STAILQ_FOREACH(np, &mdata->flags, entries)
2032 {
2033 buf_add_printf(flag_buffer, "[%s] ", np->data);
2034 }
2035 mutt_debug(LL_DEBUG3, "%s\n", buf_string(flag_buffer));
2036 buf_pool_release(&flag_buffer);
2037 }
2038 }
2039
2040 if (!((m->rights & MUTT_ACL_DELETE) || (m->rights & MUTT_ACL_SEEN) ||
2041 (m->rights & MUTT_ACL_WRITE) || (m->rights & MUTT_ACL_INSERT)))
2042 {
2043 m->readonly = true;
2044 }
2045
2046 mx_alloc_memory(m, count);
2047
2048 m->msg_count = 0;
2049 m->msg_unread = 0;
2050 m->msg_flagged = 0;
2051 m->msg_new = 0;
2052 m->msg_deleted = 0;
2053 m->size = 0;
2054 m->vcount = 0;
2055
2056 if ((count > 0) && (imap_read_headers(m, 1, count, true) < 0))
2057 {
2058 mutt_error(_("Error opening mailbox"));
2059 goto fail;
2060 }
2061
2062 mutt_debug(LL_DEBUG2, "msg_count is %d\n", m->msg_count);
2063 return MX_OPEN_OK;
2064
2065fail:
2066 if (adata->state == IMAP_SELECTED)
2067 adata->state = IMAP_AUTHENTICATED;
2068 return MX_OPEN_ERROR;
2069}
2070
2075{
2076 if (!m->account)
2077 return false;
2078
2079 /* in APPEND mode, we appear to hijack an existing IMAP connection -
2080 * mailbox is brand new and mostly empty */
2082 struct ImapMboxData *mdata = imap_mdata_get(m);
2083
2084 int rc = imap_mailbox_status(m, false);
2085 if (rc >= 0)
2086 return true;
2087 if (rc == -1)
2088 return false;
2089
2090 char buf[PATH_MAX + 64];
2091 snprintf(buf, sizeof(buf), _("Create %s?"), mdata->name);
2092 const bool c_confirm_create = cs_subset_bool(NeoMutt->sub, "confirm_create");
2093 if (c_confirm_create &&
2094 (query_yesorno_help(buf, MUTT_YES, NeoMutt->sub, "confirm_create") != MUTT_YES))
2095 return false;
2096
2097 if (imap_create_mailbox(adata, mdata->name) < 0)
2098 return false;
2099
2100 return true;
2101}
2102
2109static enum MxStatus imap_mbox_check(struct Mailbox *m)
2110{
2112 enum MxStatus rc = imap_check_mailbox(m, false);
2113 /* NOTE - mv might have been changed at this point. In particular,
2114 * m could be NULL. Beware. */
2116
2117 return rc;
2118}
2119
2123static enum MxStatus imap_mbox_close(struct Mailbox *m)
2124{
2126 struct ImapMboxData *mdata = imap_mdata_get(m);
2127
2128 /* Check to see if the mailbox is actually open */
2129 if (!adata || !mdata)
2130 return MX_STATUS_OK;
2131
2132 /* imap_mbox_open_append() borrows the struct ImapAccountData temporarily,
2133 * just for the connection.
2134 *
2135 * So when these are equal, it means we are actually closing the
2136 * mailbox and should clean up adata. Otherwise, we don't want to
2137 * touch adata - it's still being used. */
2138 if (m == adata->mailbox)
2139 {
2140 if ((adata->status != IMAP_FATAL) && (adata->state >= IMAP_SELECTED))
2141 {
2142 /* mx_mbox_close won't sync if there are no deleted messages
2143 * and the mailbox is unchanged, so we may have to close here */
2144 if (m->msg_deleted == 0)
2145 {
2146 adata->closing = true;
2147 imap_exec(adata, "CLOSE", IMAP_CMD_NO_FLAGS);
2148 }
2149 adata->state = IMAP_AUTHENTICATED;
2150 }
2151
2152 mutt_debug(LL_DEBUG3, "closing %s, restoring %s\n", m->pathbuf.data,
2153 (adata->prev_mailbox ? adata->prev_mailbox->pathbuf.data : "(none)"));
2154 adata->mailbox = adata->prev_mailbox;
2157 }
2158
2159 return MX_STATUS_OK;
2160}
2161
2165static bool imap_msg_open_new(struct Mailbox *m, struct Message *msg, const struct Email *e)
2166{
2167 bool success = false;
2168
2169 struct Buffer *tmp = buf_pool_get();
2170 buf_mktemp(tmp);
2171
2172 msg->fp = mutt_file_fopen(buf_string(tmp), "w");
2173 if (!msg->fp)
2174 {
2175 mutt_perror("%s", buf_string(tmp));
2176 goto cleanup;
2177 }
2178
2179 msg->path = buf_strdup(tmp);
2180 success = true;
2181
2182cleanup:
2183 buf_pool_release(&tmp);
2184 return success;
2185}
2186
2190static int imap_tags_edit(struct Mailbox *m, const char *tags, struct Buffer *buf)
2191{
2192 struct ImapMboxData *mdata = imap_mdata_get(m);
2193 if (!mdata)
2194 return -1;
2195
2196 char *new_tag = NULL;
2197 char *checker = NULL;
2198
2199 /* Check for \* flags capability */
2200 if (!imap_has_flag(&mdata->flags, NULL))
2201 {
2202 mutt_error(_("IMAP server doesn't support custom flags"));
2203 return -1;
2204 }
2205
2206 buf_reset(buf);
2207 if (tags)
2208 buf_strcpy(buf, tags);
2209
2210 if (mw_get_field("Tags: ", buf, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) != 0)
2211 return -1;
2212
2213 /* each keyword must be atom defined by rfc822 as:
2214 *
2215 * atom = 1*<any CHAR except specials, SPACE and CTLs>
2216 * CHAR = ( 0.-127. )
2217 * specials = "(" / ")" / "<" / ">" / "@"
2218 * / "," / ";" / ":" / "\" / <">
2219 * / "." / "[" / "]"
2220 * SPACE = ( 32. )
2221 * CTLS = ( 0.-31., 127.)
2222 *
2223 * And must be separated by one space.
2224 */
2225
2226 new_tag = buf->data;
2227 checker = buf->data;
2228 SKIPWS(checker);
2229 while (*checker != '\0')
2230 {
2231 if ((*checker < 32) || (*checker >= 127) || // We allow space because it's the separator
2232 (*checker == 40) || // (
2233 (*checker == 41) || // )
2234 (*checker == 60) || // <
2235 (*checker == 62) || // >
2236 (*checker == 64) || // @
2237 (*checker == 44) || // ,
2238 (*checker == 59) || // ;
2239 (*checker == 58) || // :
2240 (*checker == 92) || // backslash
2241 (*checker == 34) || // "
2242 (*checker == 46) || // .
2243 (*checker == 91) || // [
2244 (*checker == 93)) // ]
2245 {
2246 mutt_error(_("Invalid IMAP flags"));
2247 return 0;
2248 }
2249
2250 /* Skip duplicate space */
2251 while ((checker[0] == ' ') && (checker[1] == ' '))
2252 checker++;
2253
2254 /* copy char to new_tag and go the next one */
2255 *new_tag++ = *checker++;
2256 }
2257 *new_tag = '\0';
2258 new_tag = buf->data; /* rewind */
2260
2261 return !mutt_str_equal(tags, buf_string(buf));
2262}
2263
2277static int imap_tags_commit(struct Mailbox *m, struct Email *e, const char *buf)
2278{
2279 char uid[11] = { 0 };
2280
2282
2283 if (*buf == '\0')
2284 buf = NULL;
2285
2286 if (!(adata->mailbox->rights & MUTT_ACL_WRITE))
2287 return 0;
2288
2289 snprintf(uid, sizeof(uid), "%u", imap_edata_get(e)->uid);
2290
2291 /* Remove old custom flags */
2292 if (imap_edata_get(e)->flags_remote)
2293 {
2294 struct Buffer *cmd = buf_pool_get();
2295 buf_addstr(cmd, "UID STORE ");
2296 buf_addstr(cmd, uid);
2297 buf_addstr(cmd, " -FLAGS.SILENT (");
2298 buf_addstr(cmd, imap_edata_get(e)->flags_remote);
2299 buf_addstr(cmd, ")");
2300
2301 /* Should we return here, or we are fine and we could
2302 * continue to add new flags */
2303 int rc = imap_exec(adata, buf_string(cmd), IMAP_CMD_NO_FLAGS);
2304 buf_pool_release(&cmd);
2305 if (rc != IMAP_EXEC_SUCCESS)
2306 {
2307 return -1;
2308 }
2309 }
2310
2311 /* Add new custom flags */
2312 if (buf)
2313 {
2314 struct Buffer *cmd = buf_pool_get();
2315 buf_addstr(cmd, "UID STORE ");
2316 buf_addstr(cmd, uid);
2317 buf_addstr(cmd, " +FLAGS.SILENT (");
2318 buf_addstr(cmd, buf);
2319 buf_addstr(cmd, ")");
2320
2321 int rc = imap_exec(adata, buf_string(cmd), IMAP_CMD_NO_FLAGS);
2322 buf_pool_release(&cmd);
2323 if (rc != IMAP_EXEC_SUCCESS)
2324 {
2325 mutt_debug(LL_DEBUG1, "fail to add new flags\n");
2326 return -1;
2327 }
2328 }
2329
2330 /* We are good sync them */
2331 mutt_debug(LL_DEBUG1, "NEW TAGS: %s\n", buf);
2332 driver_tags_replace(&e->tags, buf);
2333 FREE(&imap_edata_get(e)->flags_remote);
2334 struct Buffer *flags_remote = buf_pool_get();
2335 driver_tags_get_with_hidden(&e->tags, flags_remote);
2336 imap_edata_get(e)->flags_remote = buf_strdup(flags_remote);
2337 buf_pool_release(&flags_remote);
2339 return 0;
2340}
2341
2345enum MailboxType imap_path_probe(const char *path, const struct stat *st)
2346{
2347 if (mutt_istr_startswith(path, "imap://"))
2348 return MUTT_IMAP;
2349
2350 if (mutt_istr_startswith(path, "imaps://"))
2351 return MUTT_IMAP;
2352
2353 return MUTT_UNKNOWN;
2354}
2355
2359int imap_path_canon(struct Buffer *path)
2360{
2361 struct Url *url = url_parse(buf_string(path));
2362 if (!url)
2363 return 0;
2364
2365 char tmp[PATH_MAX] = { 0 };
2366 char tmp2[PATH_MAX];
2367
2368 imap_fix_path('\0', url->path, tmp, sizeof(tmp));
2369 url->path = tmp;
2370 url_tostring(url, tmp2, sizeof(tmp2), U_NO_FLAGS);
2371 buf_strcpy(path, tmp2);
2372 url_free(&url);
2373
2374 return 0;
2375}
2376
2386{
2388 return imap_path_canon(path);
2389}
2390
2394static int imap_path_is_empty(struct Buffer *path)
2395{
2396 int rc = imap_path_status(buf_string(path), false);
2397 if (rc < 0)
2398 return -1;
2399 if (rc == 0)
2400 return 1;
2401 return 0;
2402}
2403
2407const struct MxOps MxImapOps = {
2408 // clang-format off
2409 .type = MUTT_IMAP,
2410 .name = "imap",
2411 .is_local = false,
2412 .ac_owns_path = imap_ac_owns_path,
2413 .ac_add = imap_ac_add,
2414 .mbox_open = imap_mbox_open,
2415 .mbox_open_append = imap_mbox_open_append,
2416 .mbox_check = imap_mbox_check,
2417 .mbox_check_stats = imap_mbox_check_stats,
2418 .mbox_sync = NULL, /* imap syncing is handled by imap_sync_mailbox */
2419 .mbox_close = imap_mbox_close,
2420 .msg_open = imap_msg_open,
2421 .msg_open_new = imap_msg_open_new,
2422 .msg_commit = imap_msg_commit,
2423 .msg_close = imap_msg_close,
2424 .msg_padding_size = NULL,
2425 .msg_save_hcache = imap_msg_save_hcache,
2426 .tags_edit = imap_tags_edit,
2427 .tags_commit = imap_tags_commit,
2428 .path_probe = imap_path_probe,
2429 .path_canon = imap_path_canon,
2430 .path_is_empty = imap_path_is_empty,
2431 // clang-format on
2432};
#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_SIZE(head)
The number of elements stored.
Definition: array.h:87
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:204
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:58
const char * mutt_str_atoull(const char *str, unsigned long long *dst)
Convert ASCII string to an unsigned long long.
Definition: atoi.c:292
const char * mutt_str_atoui(const char *str, unsigned int *dst)
Convert ASCII string to an unsigned integer.
Definition: atoi.c:214
IMAP authenticator multiplexor.
@ IMAP_AUTH_SUCCESS
Authentication successful.
Definition: auth.h:40
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:204
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:491
void buf_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:377
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
void buf_fix_dptr(struct Buffer *buf)
Move the dptr to end of the Buffer.
Definition: buffer.c:182
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
void buf_alloc(struct Buffer *buf, size_t new_size)
Make sure a buffer can store at least new_size bytes.
Definition: buffer.c:337
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
Functions to parse commands in a config file.
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:143
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
Convenience wrapper for the config headers.
Connection Library.
void mutt_account_unsetpass(struct ConnAccount *cac)
Unset ConnAccount's password.
Definition: connaccount.c:177
void commands_register(const struct Command *cmds, const size_t num_cmds)
Add commands to Commands array.
Definition: command.c:53
Convenience wrapper for the core headers.
void mailbox_free(struct Mailbox **ptr)
Free a Mailbox.
Definition: mailbox.c:89
void mailbox_changed(struct Mailbox *m, enum NotifyMailbox action)
Notify observers of a change to a Mailbox.
Definition: mailbox.c:233
#define MUTT_ACL_CREATE
Create a mailbox.
Definition: mailbox.h:62
@ NT_MAILBOX_RESORT
Email list needs resorting.
Definition: mailbox.h:190
@ NT_MAILBOX_UPDATE
Update internal tables.
Definition: mailbox.h:191
#define MUTT_ACL_POST
Post (submit messages to the server)
Definition: mailbox.h:68
#define MUTT_ACL_LOOKUP
Lookup mailbox (visible to 'list')
Definition: mailbox.h:67
#define MUTT_ACL_INSERT
Add/copy into the mailbox (used when editing a message)
Definition: mailbox.h:66
#define MUTT_ACL_DELETE
Delete a message.
Definition: mailbox.h:63
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition: mailbox.h:223
uint16_t AclFlags
ACL Rights - These show permission to...
Definition: mailbox.h:59
#define MUTT_ACL_WRITE
Write to a message (for flagging or linking threads)
Definition: mailbox.h:71
MailboxType
Supported mailbox formats.
Definition: mailbox.h:41
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
@ MUTT_MAILBOX_ANY
Match any Mailbox type.
Definition: mailbox.h:42
@ MUTT_UNKNOWN
Mailbox wasn't recognised.
Definition: mailbox.h:44
#define MUTT_ACL_SEEN
Change the 'seen' status of a message.
Definition: mailbox.h:70
#define MUTT_ACL_READ
Read the mailbox.
Definition: mailbox.h:69
Edit a string.
Structs that make up an email.
int mutt_save_message_mbox(struct Mailbox *m_src, struct Email *e, enum MessageSaveOpt save_opt, enum MessageTransformOpt transform_opt, struct Mailbox *m_dst)
Save a message to a given mailbox.
Definition: external.c:737
Manage where the email is piped to external commands.
@ TRANSFORM_NONE
No transformation.
Definition: external.h:42
@ SAVE_MOVE
Move message to another mailbox, removing the original.
Definition: external.h:53
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:148
int mutt_ssl_starttls(struct Connection *conn)
Negotiate TLS over an already opened connection.
Definition: gnutls.c:1145
void imap_adata_free(void **ptr)
Free the private Account data - Implements Account::adata_free() -.
Definition: adata.c:69
enum CommandResult parse_unsubscribe_from(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'unsubscribe-from' command - Implements Command::parse() -.
Definition: commands.c:1573
enum CommandResult parse_subscribe_to(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'subscribe-to' command - Implements Command::parse() -.
Definition: commands.c:1235
void imap_edata_free(void **ptr)
Free the private Email data - Implements Email::edata_free() -.
Definition: edata.c:40
int mw_get_field(const char *prompt, struct Buffer *buf, CompletionFlags complete, enum HistoryClass hclass, const struct CompleteOps *comp_api, void *cdata)
Ask the user for a string -.
Definition: window.c:274
#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
void imap_mdata_free(void **ptr)
Free the private Mailbox data - Implements Mailbox::mdata_free() -.
Definition: mdata.c:40
static bool imap_ac_add(struct Account *a, struct Mailbox *m)
Add a Mailbox to an Account - Implements MxOps::ac_add() -.
Definition: imap.c:1688
static bool imap_ac_owns_path(struct Account *a, const char *path)
Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
Definition: imap.c:1670
const struct MxOps MxImapOps
IMAP Mailbox - Implements MxOps -.
Definition: imap.c:2407
static enum MxStatus imap_mbox_check_stats(struct Mailbox *m, uint8_t flags)
Check the Mailbox statistics - Implements MxOps::mbox_check_stats() -.
Definition: imap.c:1155
static enum MxStatus imap_mbox_check(struct Mailbox *m)
Check for new mail - Implements MxOps::mbox_check() -.
Definition: imap.c:2109
static enum MxStatus imap_mbox_close(struct Mailbox *m)
Close a Mailbox - Implements MxOps::mbox_close() -.
Definition: imap.c:2123
static bool imap_mbox_open_append(struct Mailbox *m, OpenMailboxFlags flags)
Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
Definition: imap.c:2074
static enum MxOpenReturns imap_mbox_open(struct Mailbox *m)
Open a mailbox - Implements MxOps::mbox_open() -.
Definition: imap.c:1867
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
static bool imap_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: imap.c:2165
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_path_canon(struct Buffer *path)
Canonicalise a Mailbox path - Implements MxOps::path_canon() -.
Definition: imap.c:2359
static int imap_path_is_empty(struct Buffer *path)
Is the mailbox empty - Implements MxOps::path_is_empty() -.
Definition: imap.c:2394
enum MailboxType imap_path_probe(const char *path, const struct stat *st)
Is this an IMAP Mailbox? - Implements MxOps::path_probe() -.
Definition: imap.c:2345
static int imap_tags_commit(struct Mailbox *m, struct Email *e, const char *buf)
Save the tags to a message - Implements MxOps::tags_commit() -.
Definition: imap.c:2277
static int imap_tags_edit(struct Mailbox *m, const char *tags, struct Buffer *buf)
Prompt and validate new messages tags - Implements MxOps::tags_edit() -.
Definition: imap.c:2190
int imap_sort_uid(const void *a, const void *b, void *sdata)
Compare two UIDs - Implements sort_t -.
Definition: msg_set.c:55
static int imap_sort_email_uid(const void *a, const void *b, void *sdata)
Compare two Emails by UID - Implements sort_t -.
Definition: imap.c:900
void mutt_hash_int_delete(struct HashTable *table, unsigned int intkey, const void *data)
Remove an element from a Hash Table.
Definition: hash.c:444
Read/write command history from/to a file.
@ HC_OTHER
Miscellaneous strings.
Definition: lib.h:56
void mutt_account_hook(const char *url)
Perform an account hook.
Definition: hook.c:879
Parse and execute user-defined hooks.
struct ImapAccountData * imap_adata_new(struct Account *a)
Allocate and initialise a new ImapAccountData structure.
Definition: adata.c:98
struct ImapAccountData * imap_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition: adata.c:123
int imap_authenticate(struct ImapAccountData *adata)
Authenticate to an IMAP server.
Definition: auth.c:115
int imap_cmd_start(struct ImapAccountData *adata, const char *cmdstr)
Given an IMAP command, send it to the server.
Definition: command.c:1115
const char * imap_cmd_trailer(struct ImapAccountData *adata)
Extra information after tagged command response if any.
Definition: command.c:1267
int imap_cmd_idle(struct ImapAccountData *adata)
Enter the IDLE state.
Definition: command.c:1436
int imap_cmd_step(struct ImapAccountData *adata)
Reads server responses from an IMAP command.
Definition: command.c:1129
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:1304
void imap_cmd_finish(struct ImapAccountData *adata)
Attempt to perform cleanup.
Definition: command.c:1369
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:475
struct ImapMboxData * imap_mdata_new(struct ImapAccountData *adata, const char *name)
Allocate and initialise a new ImapMboxData structure.
Definition: mdata.c:74
struct ImapMboxData * imap_mdata_get(struct Mailbox *m)
Get the Mailbox data for this mailbox.
Definition: mdata.c:61
int imap_cache_clean(struct Mailbox *m)
Delete all the entries in the message cache.
Definition: message.c:1888
int imap_cache_del(struct Mailbox *m, struct Email *e)
Delete an email from the body cache.
Definition: message.c:1869
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:1340
#define IMAP_CAP_ENABLE
RFC5161.
Definition: private.h:135
#define IMAP_CAP_IDLE
RFC2177: IDLE.
Definition: private.h:133
#define IMAP_CMD_NO_FLAGS
No flags are set.
Definition: private.h:71
void imap_qualify_path(char *buf, size_t buflen, struct ConnAccount *conn_account, char *path)
Make an absolute IMAP folder target.
Definition: util.c:817
#define IMAP_CAP_ID
RFC2971: IMAP4 ID extension.
Definition: private.h:141
void imap_allow_reopen(struct Mailbox *m)
Allow re-opening a folder upon expunge.
Definition: util.c:1027
void imap_disallow_reopen(struct Mailbox *m)
Disallow re-opening a folder upon expunge.
Definition: util.c:1040
@ IMAP_DISCONNECTED
Disconnected from server.
Definition: private.h:105
@ IMAP_IDLE
Connection is idle.
Definition: private.h:111
@ IMAP_AUTHENTICATED
Connection is authenticated.
Definition: private.h:107
@ IMAP_SELECTED
Mailbox is selected.
Definition: private.h:108
@ IMAP_CONNECTED
Connected to server.
Definition: private.h:106
#define IMAP_EXPUNGE_PENDING
Messages on the server have been expunged.
Definition: private.h:66
void imap_hcache_open(struct ImapAccountData *adata, struct ImapMboxData *mdata, bool create)
Open a header cache.
Definition: util.c:300
#define IMAP_RES_OK
<tag> OK ...
Definition: private.h:55
#define IMAP_OPEN_NO_FLAGS
No flags are set.
Definition: private.h:63
#define IMAP_EXPUNGE_EXPECTED
Messages will be expunged from the server.
Definition: private.h:65
int imap_hcache_put(struct ImapMboxData *mdata, struct Email *e)
Add an entry to the header cache.
Definition: util.c:381
#define IMAP_LOG_LTRL
Definition: private.h:49
#define IMAP_CMD_POLL
Poll the tcp connection before running the imap command.
Definition: private.h:74
void imap_mdata_cache_reset(struct ImapMboxData *mdata)
Release and clear cache data of ImapMboxData structure.
Definition: util.c:107
#define IMAP_CAP_IMAP4
Server supports IMAP4.
Definition: private.h:121
#define IMAP_CAP_STARTTLS
RFC2595: STARTTLS.
Definition: private.h:131
#define IMAP_CAP_IMAP4REV1
Server supports IMAP4rev1.
Definition: private.h:122
#define IMAP_CAP_STATUS
Server supports STATUS command.
Definition: private.h:123
void imap_quote_string(char *dest, size_t dlen, const char *src, bool quote_backtick)
Quote string according to IMAP rules.
Definition: util.c:848
enum QuadOption imap_continue(const char *msg, const char *resp)
Display a message and ask the user if they want to go on.
Definition: util.c:647
#define IMAP_CMD_PASS
Command contains a password. Suppress logging.
Definition: private.h:72
void imap_buf_qualify_path(struct Buffer *buf, struct ConnAccount *conn_account, char *path)
Make an absolute IMAP folder target to a buffer.
Definition: util.c:831
ImapExecResult
Imap_exec return code.
Definition: private.h:81
@ IMAP_EXEC_SUCCESS
Imap command executed or queued successfully.
Definition: private.h:82
@ IMAP_EXEC_ERROR
Imap command failure.
Definition: private.h:83
@ IMAP_EXEC_FATAL
Imap connection failure.
Definition: private.h:84
#define IMAP_CAP_ACL
RFC2086: IMAP4 ACL extension.
Definition: private.h:124
#define IMAP_CAP_QRESYNC
RFC7162.
Definition: private.h:137
char * imap_fix_path(char delim, const char *mailbox, char *path, size_t plen)
Fix up the imap path.
Definition: util.c:680
#define IMAP_NEWMAIL_PENDING
New mail is waiting on the server.
Definition: private.h:67
void imap_error(const char *where, const char *msg)
Show an error and abort.
Definition: util.c:658
#define IMAP_FLAGS_PENDING
Flags have changed on the server.
Definition: private.h:68
void imap_hcache_close(struct ImapMboxData *mdata)
Close the header cache.
Definition: util.c:341
@ IMAP_BYE
Logged out from server.
Definition: private.h:96
@ IMAP_FATAL
Unrecoverable error occurred.
Definition: private.h:95
#define IMAP_CAP_COMPRESS
RFC4978: COMPRESS=DEFLATE.
Definition: private.h:139
int imap_hcache_del(struct ImapMboxData *mdata, unsigned int uid)
Delete an item from the header cache.
Definition: util.c:399
#define IMAP_RES_NO
<tag> NO ...
Definition: private.h:53
int imap_adata_find(const char *path, struct ImapAccountData **adata, struct ImapMboxData **mdata)
Find the Account data for this path.
Definition: util.c:73
bool imap_account_match(const struct ConnAccount *a1, const struct ConnAccount *a2)
Compare two Accounts.
Definition: util.c:1055
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:922
#define IMAP_CMD_SINGLE
Run a single command.
Definition: private.h:75
#define IMAP_RES_CONTINUE
* ...
Definition: private.h:56
char * imap_next_word(char *s)
Find where the next IMAP word begins.
Definition: util.c:786
#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:769
static void imap_logout(struct ImapAccountData *adata)
Gracefully log out of server.
Definition: imap.c:527
int imap_mailbox_status(struct Mailbox *m, bool queue)
Refresh the number of total and new messages.
Definition: imap.c:1207
int imap_path_status(const char *path, bool queue)
Refresh the number of total and new messages.
Definition: imap.c:1172
void imap_notify_delete_email(struct Mailbox *m, struct Email *e)
Inform IMAP that an Email has been deleted.
Definition: imap.c:648
void imap_close_connection(struct ImapAccountData *adata)
Close an IMAP connection.
Definition: imap.c:849
int imap_expand_path(struct Buffer *path)
Buffer wrapper around imap_path_canon()
Definition: imap.c:2385
static int imap_status(struct ImapAccountData *adata, struct ImapMboxData *mdata, bool queue)
Refresh the number of total and new messages.
Definition: imap.c:1105
int imap_complete(struct Buffer *buf, const char *path)
Try to complete an IMAP folder path.
Definition: imap.c:1275
int imap_subscribe(const char *path, bool subscribe)
Subscribe to a mailbox.
Definition: imap.c:1223
int imap_delete_mailbox(struct Mailbox *m, char *path)
Delete a mailbox.
Definition: imap.c:505
void imap_expunge_mailbox(struct Mailbox *m, bool resort)
Purge messages from the server.
Definition: imap.c:669
static size_t longest_common_prefix(struct Buffer *buf, const char *src, size_t start)
Find longest prefix common to two strings.
Definition: imap.c:348
int imap_open_connection(struct ImapAccountData *adata)
Open an IMAP connection.
Definition: imap.c:741
static int sync_helper(struct Mailbox *m, struct Email **emails, int num_emails, AclFlags right, enum MessageType flag, const char *name)
Sync flag changes to the server.
Definition: imap.c:300
int imap_rename_mailbox(struct ImapAccountData *adata, char *oldname, const char *newname)
Rename a mailbox.
Definition: imap.c:478
static int complete_hosts(struct Buffer *buf)
Look for completion matches for mailboxes.
Definition: imap.c:371
int imap_create_mailbox(struct ImapAccountData *adata, const char *mailbox)
Create a new mailbox.
Definition: imap.c:436
static int check_capabilities(struct ImapAccountData *adata)
Make sure we can log in to this server.
Definition: imap.c:107
int imap_fast_trash(struct Mailbox *m, const char *dest)
Use server COPY command to copy deleted messages to trash.
Definition: imap.c:1356
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:926
static int select_email_uids(struct Email **emails, int num_emails, enum MessageType flag, bool changed, bool invert, struct UidArray *uida)
Create a list of Email UIDs by type.
Definition: imap.c:230
enum MxStatus imap_sync_mailbox(struct Mailbox *m, bool expunge, bool close)
Sync all the changes to the server.
Definition: imap.c:1471
int imap_access(const char *path)
Check permissions on an IMAP mailbox with a new connection.
Definition: imap.c:463
void imap_logout_all(void)
Close all open connections.
Definition: imap.c:554
enum MxStatus imap_check_mailbox(struct Mailbox *m, bool force)
Use the NOOP or IDLE command to poll for new mail.
Definition: imap.c:1032
static char * get_flags(struct ListHead *hflags, char *s)
Make a simple list out of a FLAGS response.
Definition: imap.c:133
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:590
bool imap_has_flag(struct ListHead *flag_list, const char *flag)
Does the flag exist in the list.
Definition: imap.c:874
static void set_flag(struct Mailbox *m, AclFlags aclflag, bool flag, const char *str, struct Buffer *flags)
Append str to flags if we currently have permission according to aclflag.
Definition: imap.c:187
static void imap_mbox_select(struct Mailbox *m)
Select a Mailbox.
Definition: imap.c:1744
int imap_login(struct ImapAccountData *adata)
Open an IMAP connection.
Definition: imap.c:1777
static const struct Command ImapCommands[]
Imap Commands.
Definition: imap.c:86
void imap_init(void)
Setup feature commands.
Definition: imap.c:96
static bool compare_flags_for_copy(struct Email *e)
Compare local flags against the server.
Definition: imap.c:203
struct ListNode * mutt_list_insert_tail(struct ListHead *h, char *s)
Append a string to the end of a List.
Definition: list.c:65
void mutt_list_free(struct ListHead *h)
Free a List AND its strings.
Definition: list.c:123
@ 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 * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:91
#define FREE(x)
Definition: memory.h:45
#define mutt_array_size(x)
Definition: memory.h:38
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_remove(struct MSNArray *msn, size_t idx)
Remove an entry from the cache.
Definition: msn.c:116
IMAP MSN helper functions.
time_t mutt_date_now(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:456
Convenience wrapper for the library headers.
#define _(a)
Definition: message.h:28
void mutt_str_remove_trailing_ws(char *s)
Trim trailing whitespace from a string.
Definition: string.c:565
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
bool mutt_strn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings (to a maximum), safely.
Definition: string.c:425
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:230
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
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:581
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
bool mutt_istrn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings ignoring case (to a maximum), safely.
Definition: string.c:453
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:280
Many unsorted constants and some structs.
#define MUTT_COMP_NO_FLAGS
No flags are set.
Definition: mutt.h:56
MessageType
To set flags or match patterns.
Definition: mutt.h:67
@ MUTT_TRASH
Trashed messages.
Definition: mutt.h:85
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:73
@ MUTT_OLD
Old messages.
Definition: mutt.h:71
@ MUTT_FLAG
Flagged messages.
Definition: mutt.h:79
@ MUTT_DELETED
Deleted messages.
Definition: mutt.h:78
@ MUTT_REPLIED
Messages that have been replied to.
Definition: mutt.h:72
#define PATH_MAX
Definition: mutt.h:42
void mutt_account_tourl(struct ConnAccount *cac, struct Url *url)
Fill URL with info from account.
Definition: mutt_account.c:80
@ MUTT_ACCT_TYPE_IMAP
Imap Account.
Definition: mutt_account.h:38
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:74
NeoMutt Logging.
struct Connection * mutt_conn_new(const struct ConnAccount *cac)
Create a new Connection.
Definition: mutt_socket.c:49
NeoMutt connections.
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:519
Some miscellaneous functions.
void mx_alloc_memory(struct Mailbox *m, int req_size)
Create storage for the emails.
Definition: mx.c:1206
int mx_ac_remove(struct Mailbox *m, bool keep_account)
Remove a Mailbox from an Account and delete Account if empty.
Definition: mx.c:1740
struct Mailbox * mx_mbox_find2(const char *path)
Find a Mailbox on an Account.
Definition: mx.c:1605
bool mx_mbox_ac_link(struct Mailbox *m)
Link a Mailbox to an existing or new Account.
Definition: mx.c:251
struct Mailbox * mx_path_resolve(const char *path)
Get a Mailbox for a path.
Definition: mx.c:1636
API for mailboxes.
uint8_t OpenMailboxFlags
Flags for mutt_open_mailbox(), e.g. MUTT_NOSORT.
Definition: mxapi.h:39
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_MAILBOX_CHECK_IMMEDIATE
Don't postpone the actual checking.
Definition: mxapi.h:56
MxStatus
Return values from mbox_check(), mbox_check_stats(), mbox_sync(), 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
void neomutt_mailboxlist_clear(struct MailboxList *ml)
Free a Mailbox List.
Definition: neomutt.c:168
size_t neomutt_mailboxlist_get_all(struct MailboxList *head, struct NeoMutt *n, enum MailboxType type)
Get a List of all Mailboxes.
Definition: neomutt.c:191
Notmuch-specific Mailbox data.
Text parsing functions.
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.
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Definition: progress.c:80
void mutt_qsort_r(void *base, size_t nmemb, size_t size, sort_t compar, void *sdata)
Sort an array, where the comparator has access to opaque data rather than requiring global variables.
Definition: qsort_r.c:67
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ 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:341
enum QuadOption query_quadoption(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
Definition: question.c:365
enum QuadOption query_yesorno(const char *prompt, enum QuadOption def)
Ask the user a Yes/No question.
Definition: question.c:326
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define STAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:324
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define STAILQ_EMPTY(head)
Definition: queue.h:348
enum CommandResult parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: rc.c:104
GUI display the mailboxes in a side panel.
int mutt_socket_close(struct Connection *conn)
Close a socket.
Definition: socket.c:100
int mutt_socket_poll(struct Connection *conn, time_t wait_secs)
Checks whether reads would block.
Definition: socket.c:182
int mutt_socket_readchar(struct Connection *conn, char *c)
Simple read buffering to speed things up.
Definition: socket.c:200
void mutt_socket_empty(struct Connection *conn)
Clear out any queued data.
Definition: socket.c:306
int mutt_socket_open(struct Connection *conn)
Simple wrapper.
Definition: socket.c:76
Assorted sorting methods.
#define mutt_numeric_cmp(a, b)
Definition: sort.h:35
Key value store.
#define SKIPWS(ch)
Definition: string2.h:45
A group of associated Mailboxes.
Definition: account.h:36
enum MailboxType type
Type of Mailboxes this Account contains.
Definition: account.h:37
char * name
Name of Account.
Definition: account.h:38
void(* adata_free)(void **ptr)
Definition: account.h:53
void * adata
Private data (for Mailbox backends)
Definition: account.h:42
String manipulation buffer.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:37
Login details for a remote server.
Definition: connaccount.h:53
char user[128]
Username.
Definition: connaccount.h:56
char host[128]
Server to login to.
Definition: connaccount.h:54
unsigned int ssf
Security strength factor, in bits (see notes)
Definition: connection.h:50
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
int fd
Socket file descriptor.
Definition: connection.h:53
The envelope/body of an email.
Definition: email.h:39
bool read
Email is read.
Definition: email.h:50
bool purge
Skip trash folder when deleting.
Definition: email.h:79
struct Envelope * env
Envelope information.
Definition: email.h:68
void * edata
Driver-specific data.
Definition: email.h:74
bool active
Message is not to be removed.
Definition: email.h:76
bool old
Email is seen, but unread.
Definition: email.h:49
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
char * path
Path of Email (for local Mailboxes)
Definition: email.h:70
bool deleted
Email is deleted.
Definition: email.h:78
int index
The absolute (unsorted) message number.
Definition: email.h:113
unsigned char changed
Changed fields, e.g. MUTT_ENV_CHANGED_SUBJECT.
Definition: envelope.h:90
IMAP-specific Account data -.
Definition: adata.h:40
char delim
Path delimiter.
Definition: adata.h:75
struct Mailbox * prev_mailbox
Previously selected mailbox.
Definition: adata.h:77
struct ImapList * cmdresult
Definition: adata.h:66
int lastcmd
Last command in the queue.
Definition: adata.h:72
bool closing
If true, we are waiting for CLOSE completion.
Definition: adata.h:43
time_t lastread
last time we read a command for the server
Definition: adata.h:58
bool unicode
If true, we can send UTF-8, and the server will use UTF8 rather than mUTF7.
Definition: adata.h:62
ImapCapFlags capabilities
Capability flags.
Definition: adata.h:55
int nextcmd
Next command to be sent.
Definition: adata.h:71
unsigned char state
ImapState, e.g. IMAP_AUTHENTICATED.
Definition: adata.h:44
struct Mailbox * mailbox
Current selected mailbox.
Definition: adata.h:76
char * capstr
Capability string from the server.
Definition: adata.h:54
struct ImapCommand * cmds
Queue of commands for the server.
Definition: adata.h:69
unsigned char status
ImapFlags, e.g. IMAP_FATAL.
Definition: adata.h:45
int cmdslots
Size of the command queue.
Definition: adata.h:70
char * buf
Definition: adata.h:59
unsigned int seqno
tag sequence number, e.g. '{seqid}0001'
Definition: adata.h:57
struct Connection * conn
Connection to IMAP server.
Definition: adata.h:41
struct Buffer cmdbuf
Definition: adata.h:73
IMAP command structure.
Definition: private.h:160
IMAP-specific Email data -.
Definition: edata.h:35
unsigned int uid
32-bit Message UID
Definition: edata.h:45
char * flags_remote
Definition: edata.h:49
bool deleted
Email has been deleted.
Definition: edata.h:39
char * flags_system
Definition: edata.h:48
Items in an IMAP browser.
Definition: private.h:149
bool noselect
Definition: private.h:152
char * name
Definition: private.h:150
char delim
Definition: private.h:151
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 ListHead flags
Definition: mdata.h:50
char * real_name
Original Mailbox name, e.g.: INBOX can be just \0.
Definition: mdata.h:43
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
char * munge_name
Munged version of the mailbox name.
Definition: mdata.h:42
uint32_t uidvalidity
Definition: mdata.h:51
char * name
Mailbox name.
Definition: mdata.h:41
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
List of Mailboxes.
Definition: mailbox.h:166
struct Mailbox * mailbox
Mailbox in the list.
Definition: mailbox.h:167
A mailbox.
Definition: mailbox.h:79
void(* mdata_free)(void **ptr)
Definition: mailbox.h:143
int vcount
The number of virtual messages.
Definition: mailbox.h:99
bool changed
Mailbox has been modified.
Definition: mailbox.h:110
bool has_new
Mailbox has new mail.
Definition: mailbox.h:85
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:81
bool append
Mailbox is opened in append mode.
Definition: mailbox.h:109
int msg_new
Number of new messages.
Definition: mailbox.h:92
time_t last_checked
Last time we checked this mailbox for new mail.
Definition: mailbox.h:105
int msg_count
Total number of messages.
Definition: mailbox.h:88
AclFlags rights
ACL bits, see AclFlags.
Definition: mailbox.h:119
bool poll_new_mail
Check for new mail.
Definition: mailbox.h:115
void * mdata
Driver specific data.
Definition: mailbox.h:132
struct Email ** emails
Array of Emails.
Definition: mailbox.h:96
struct Buffer pathbuf
Path of the Mailbox.
Definition: mailbox.h:80
int msg_deleted
Number of deleted messages.
Definition: mailbox.h:93
struct Account * account
Account that owns this Mailbox.
Definition: mailbox.h:127
off_t size
Size of the Mailbox.
Definition: mailbox.h:84
int msg_flagged
Number of flagged messages.
Definition: mailbox.h:90
bool readonly
Don't allow changes to the mailbox.
Definition: mailbox.h:116
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
Definition: mxapi.h:91
enum MailboxType type
Mailbox type, e.g. MUTT_IMAP.
Definition: mxapi.h:92
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct AccountList accounts
List of all Accounts.
Definition: neomutt.h:47
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:69
char * user
Username.
Definition: url.h:71
char * host
Host.
Definition: url.h:73
char * path
Path.
Definition: url.h:75
bool driver_tags_replace(struct TagList *tl, const char *tags)
Replace all tags.
Definition: tags.c:201
void driver_tags_get_with_hidden(struct TagList *tl, struct Buffer *tags)
Get all tags, also hidden ones, separated by space.
Definition: tags.c:174
#define buf_mktemp(buf)
Definition: tmp.h:33
struct Url * url_parse(const char *src)
Fill in Url.
Definition: url.c:239
void url_free(struct Url **ptr)
Free the contents of a URL.
Definition: url.c:124
int url_tostring(const struct Url *url, char *dest, size_t len, uint8_t flags)
Output the URL string for a given Url object.
Definition: url.c:423
#define U_NO_FLAGS
Definition: url.h:49
void mutt_zstrm_wrap_conn(struct Connection *conn)
Wrap a compression layer around a Connection.
Definition: zstrm.c:291