NeoMutt  2024-04-25-97-g7d2481
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
util.c
Go to the documentation of this file.
1
34#include "config.h"
35#include <arpa/inet.h>
36#include <ctype.h>
37#include <errno.h>
38#include <netdb.h>
39#include <signal.h>
40#include <stdbool.h>
41#include <stdio.h>
42#include <string.h>
43#include <sys/types.h>
44#include <sys/wait.h>
45#include <unistd.h>
46#include "private.h"
47#include "mutt/lib.h"
48#include "config/lib.h"
49#include "email/lib.h"
50#include "core/lib.h"
51#include "conn/lib.h"
52#include "lib.h"
53#include "bcache/lib.h"
54#include "question/lib.h"
55#include "adata.h"
56#include "edata.h"
57#include "globals.h"
58#include "mdata.h"
59#include "msn.h"
60#include "mutt_account.h"
61#ifdef USE_HCACHE
62#include "hcache/lib.h"
63#endif
64
73int imap_adata_find(const char *path, struct ImapAccountData **adata,
74 struct ImapMboxData **mdata)
75{
76 struct ConnAccount cac = { { 0 } };
77 struct ImapAccountData *tmp_adata = NULL;
78 char tmp[1024] = { 0 };
79
80 if (imap_parse_path(path, &cac, tmp, sizeof(tmp)) < 0)
81 return -1;
82
83 struct Account *np = NULL;
84 TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
85 {
86 if (np->type != MUTT_IMAP)
87 continue;
88
89 tmp_adata = np->adata;
90 if (!tmp_adata)
91 continue;
92 if (imap_account_match(&tmp_adata->conn->account, &cac))
93 {
94 *mdata = imap_mdata_new(tmp_adata, tmp);
95 *adata = tmp_adata;
96 return 0;
97 }
98 }
99 mutt_debug(LL_DEBUG3, "no ImapAccountData found\n");
100 return -1;
101}
102
108{
109 mutt_hash_free(&mdata->uid_hash);
110 imap_msn_free(&mdata->msn);
111 mutt_bcache_close(&mdata->bcache);
112}
113
121void imap_get_parent(const char *mbox, char delim, char *buf, size_t buflen)
122{
123 /* Make a copy of the mailbox name, but only if the pointers are different */
124 if (mbox != buf)
125 mutt_str_copy(buf, mbox, buflen);
126
127 int n = mutt_str_len(buf);
128
129 /* Let's go backwards until the next delimiter
130 *
131 * If buf[n] is a '/', the first n-- will allow us
132 * to ignore it. If it isn't, then buf looks like
133 * "/aaaaa/bbbb". There is at least one "b", so we can't skip
134 * the "/" after the 'a's.
135 *
136 * If buf == '/', then n-- => n == 0, so the loop ends
137 * immediately */
138 for (n--; (n >= 0) && (buf[n] != delim); n--)
139 ; // do nothing
140
141 /* We stopped before the beginning. There is a trailing slash. */
142 if (n > 0)
143 {
144 /* Strip the trailing delimiter. */
145 buf[n] = '\0';
146 }
147 else
148 {
149 buf[0] = (n == 0) ? delim : '\0';
150 }
151}
152
162void imap_get_parent_path(const char *path, char *buf, size_t buflen)
163{
164 struct ImapAccountData *adata = NULL;
165 struct ImapMboxData *mdata = NULL;
166 char mbox[1024] = { 0 };
167
168 if (imap_adata_find(path, &adata, &mdata) < 0)
169 {
170 mutt_str_copy(buf, path, buflen);
171 return;
172 }
173
174 /* Gets the parent mbox in mbox */
175 imap_get_parent(mdata->name, adata->delim, mbox, sizeof(mbox));
176
177 /* Returns a fully qualified IMAP url */
178 imap_qualify_path(buf, buflen, &adata->conn->account, mbox);
179 imap_mdata_free((void *) &mdata);
180}
181
189void imap_clean_path(char *path, size_t plen)
190{
191 struct ImapAccountData *adata = NULL;
192 struct ImapMboxData *mdata = NULL;
193
194 if (imap_adata_find(path, &adata, &mdata) < 0)
195 return;
196
197 /* Returns a fully qualified IMAP url */
198 imap_qualify_path(path, plen, &adata->conn->account, mdata->name);
199 imap_mdata_free((void *) &mdata);
200}
201
205static const char *imap_get_field(enum ConnAccountField field, void *gf_data)
206{
207 switch (field)
208 {
209 case MUTT_CA_LOGIN:
210 return cs_subset_string(NeoMutt->sub, "imap_login");
211 case MUTT_CA_USER:
212 return cs_subset_string(NeoMutt->sub, "imap_user");
213 case MUTT_CA_PASS:
214 return cs_subset_string(NeoMutt->sub, "imap_pass");
216 return cs_subset_string(NeoMutt->sub, "imap_oauth_refresh_command");
217 case MUTT_CA_HOST:
218 default:
219 return NULL;
220 }
221}
222
223#ifdef USE_HCACHE
232static void imap_msn_index_to_uid_seqset(struct Buffer *buf, struct ImapMboxData *mdata)
233{
234 int first = 1, state = 0;
235 unsigned int cur_uid = 0, last_uid = 0;
236 unsigned int range_begin = 0, range_end = 0;
237 const size_t max_msn = imap_msn_highest(&mdata->msn);
238
239 for (unsigned int msn = 1; msn <= max_msn + 1; msn++)
240 {
241 bool match = false;
242 if (msn <= max_msn)
243 {
244 struct Email *e_cur = imap_msn_get(&mdata->msn, msn - 1);
245 cur_uid = e_cur ? imap_edata_get(e_cur)->uid : 0;
246 if (!state || (cur_uid && ((cur_uid - 1) == last_uid)))
247 match = true;
248 last_uid = cur_uid;
249 }
250
251 if (match)
252 {
253 switch (state)
254 {
255 case 1: /* single: convert to a range */
256 state = 2;
258
259 case 2: /* extend range ending */
260 range_end = cur_uid;
261 break;
262 default:
263 state = 1;
264 range_begin = cur_uid;
265 break;
266 }
267 }
268 else if (state)
269 {
270 if (first)
271 first = 0;
272 else
273 buf_addch(buf, ',');
274
275 if (state == 1)
276 buf_add_printf(buf, "%u", range_begin);
277 else if (state == 2)
278 buf_add_printf(buf, "%u:%u", range_begin, range_end);
279
280 state = 1;
281 range_begin = cur_uid;
282 }
283 }
284}
285
289static void imap_hcache_namer(const char *path, struct Buffer *dest)
290{
291 buf_printf(dest, "%s.hcache", path);
292}
293
300void imap_hcache_open(struct ImapAccountData *adata, struct ImapMboxData *mdata, bool create)
301{
302 if (!adata || !mdata)
303 return;
304
305 if (mdata->hcache)
306 return;
307
308 struct HeaderCache *hc = NULL;
309 struct Buffer *mbox = buf_pool_get();
310 struct Buffer *cachepath = buf_pool_get();
311
312 imap_cachepath(adata->delim, mdata->name, mbox);
313
314 if (strstr(buf_string(mbox), "/../") || mutt_str_equal(buf_string(mbox), "..") ||
315 mutt_strn_equal(buf_string(mbox), "../", 3))
316 {
317 goto cleanup;
318 }
319 size_t len = buf_len(mbox);
320 if ((len > 3) && (mutt_str_equal(buf_string(mbox) + len - 3, "/..")))
321 goto cleanup;
322
323 struct Url url = { 0 };
324 mutt_account_tourl(&adata->conn->account, &url);
325 url.path = mbox->data;
326 url_tobuffer(&url, cachepath, U_PATH);
327
328 const char *const c_header_cache = cs_subset_path(NeoMutt->sub, "header_cache");
329 hc = hcache_open(c_header_cache, buf_string(cachepath), imap_hcache_namer, create);
330
331cleanup:
332 buf_pool_release(&mbox);
333 buf_pool_release(&cachepath);
334 mdata->hcache = hc;
335}
336
342{
343 if (!mdata->hcache)
344 return;
345
346 hcache_close(&mdata->hcache);
347}
348
356struct Email *imap_hcache_get(struct ImapMboxData *mdata, unsigned int uid)
357{
358 if (!mdata->hcache)
359 return NULL;
360
361 char key[16] = { 0 };
362
363 snprintf(key, sizeof(key), "%u", uid);
364 struct HCacheEntry hce = hcache_fetch_email(mdata->hcache, key, mutt_str_len(key),
365 mdata->uidvalidity);
366 if (!hce.email && hce.uidvalidity)
367 {
368 mutt_debug(LL_DEBUG3, "hcache uidvalidity mismatch: %u\n", hce.uidvalidity);
369 }
370
371 return hce.email;
372}
373
381int imap_hcache_put(struct ImapMboxData *mdata, struct Email *e)
382{
383 if (!mdata->hcache)
384 return -1;
385
386 char key[16] = { 0 };
387
388 snprintf(key, sizeof(key), "%u", imap_edata_get(e)->uid);
389 return hcache_store_email(mdata->hcache, key, mutt_str_len(key), e, mdata->uidvalidity);
390}
391
399int imap_hcache_del(struct ImapMboxData *mdata, unsigned int uid)
400{
401 if (!mdata->hcache)
402 return -1;
403
404 char key[16] = { 0 };
405
406 snprintf(key, sizeof(key), "%u", uid);
407 return hcache_delete_email(mdata->hcache, key, mutt_str_len(key));
408}
409
417{
418 if (!mdata->hcache)
419 return -1;
420
421 struct Buffer *buf = buf_pool_get();
422 buf_alloc(buf, 8192); // The seqset is likely large. Preallocate to reduce reallocs
424
425 int rc = hcache_store_raw(mdata->hcache, "UIDSEQSET", 9, buf->data, buf_len(buf) + 1);
426 mutt_debug(LL_DEBUG3, "Stored UIDSEQSET %s\n", buf_string(buf));
427 buf_pool_release(&buf);
428 return rc;
429}
430
438{
439 if (!mdata->hcache)
440 return -1;
441
442 return hcache_delete_raw(mdata->hcache, "UIDSEQSET", 9);
443}
444
452{
453 if (!mdata->hcache)
454 return NULL;
455
456 char *seqset = hcache_fetch_raw_str(mdata->hcache, "UIDSEQSET", 9);
457 mutt_debug(LL_DEBUG3, "Retrieved UIDSEQSET %s\n", NONULL(seqset));
458
459 return seqset;
460}
461#endif
462
475int imap_parse_path(const char *path, struct ConnAccount *cac, char *mailbox, size_t mailboxlen)
476{
477 static unsigned short ImapPort = 0;
478 static unsigned short ImapsPort = 0;
479
480 if (ImapPort == 0)
481 {
482 struct servent *service = getservbyname("imap", "tcp");
483 if (service)
484 ImapPort = ntohs(service->s_port);
485 else
486 ImapPort = IMAP_PORT;
487 mutt_debug(LL_DEBUG3, "Using default IMAP port %d\n", ImapPort);
488 }
489
490 if (ImapsPort == 0)
491 {
492 struct servent *service = getservbyname("imaps", "tcp");
493 if (service)
494 ImapsPort = ntohs(service->s_port);
495 else
496 ImapsPort = IMAP_SSL_PORT;
497 mutt_debug(LL_DEBUG3, "Using default IMAPS port %d\n", ImapsPort);
498 }
499
500 /* Defaults */
501 cac->port = ImapPort;
503 cac->service = "imap";
505
506 struct Url *url = url_parse(path);
507 if (!url)
508 return -1;
509
510 if ((url->scheme != U_IMAP) && (url->scheme != U_IMAPS))
511 {
512 url_free(&url);
513 return -1;
514 }
515
516 if ((mutt_account_fromurl(cac, url) < 0) || (cac->host[0] == '\0'))
517 {
518 url_free(&url);
519 return -1;
520 }
521
522 if (url->scheme == U_IMAPS)
523 cac->flags |= MUTT_ACCT_SSL;
524
525 mutt_str_copy(mailbox, url->path, mailboxlen);
526
527 url_free(&url);
528
529 if ((cac->flags & MUTT_ACCT_SSL) && !(cac->flags & MUTT_ACCT_PORT))
530 cac->port = ImapsPort;
531
532 return 0;
533}
534
546int imap_mxcmp(const char *mx1, const char *mx2)
547{
548 char *b1 = NULL;
549 char *b2 = NULL;
550 int rc;
551
552 if (!mx1 || (*mx1 == '\0'))
553 mx1 = "INBOX";
554 if (!mx2 || (*mx2 == '\0'))
555 mx2 = "INBOX";
556 if (mutt_istr_equal(mx1, "INBOX") && mutt_istr_equal(mx2, "INBOX"))
557 {
558 return 0;
559 }
560
561 b1 = mutt_mem_malloc(strlen(mx1) + 1);
562 b2 = mutt_mem_malloc(strlen(mx2) + 1);
563
564 imap_fix_path('\0', mx1, b1, strlen(mx1) + 1);
565 imap_fix_path('\0', mx2, b2, strlen(mx2) + 1);
566
567 rc = mutt_str_cmp(b1, b2);
568 FREE(&b1);
569 FREE(&b2);
570
571 return rc;
572}
573
582void imap_pretty_mailbox(char *path, size_t pathlen, const char *folder)
583{
584 struct ConnAccount cac_target = { { 0 } };
585 struct ConnAccount cac_home = { { 0 } };
586 struct Url url = { 0 };
587 const char *delim = NULL;
588 int tlen;
589 int hlen = 0;
590 bool home_match = false;
591 char target_mailbox[1024] = { 0 };
592 char home_mailbox[1024] = { 0 };
593
594 if (imap_parse_path(path, &cac_target, target_mailbox, sizeof(target_mailbox)) < 0)
595 return;
596
597 if (imap_path_probe(folder, NULL) != MUTT_IMAP)
598 goto fallback;
599
600 if (imap_parse_path(folder, &cac_home, home_mailbox, sizeof(home_mailbox)) < 0)
601 goto fallback;
602
603 tlen = mutt_str_len(target_mailbox);
604 hlen = mutt_str_len(home_mailbox);
605
606 /* check whether we can do '+' substitution */
607 if (tlen && imap_account_match(&cac_home, &cac_target) &&
608 mutt_strn_equal(home_mailbox, target_mailbox, hlen))
609 {
610 const char *const c_imap_delim_chars = cs_subset_string(NeoMutt->sub, "imap_delim_chars");
611 if (hlen == 0)
612 {
613 home_match = true;
614 }
615 else if (c_imap_delim_chars)
616 {
617 for (delim = c_imap_delim_chars; *delim != '\0'; delim++)
618 if (target_mailbox[hlen] == *delim)
619 home_match = true;
620 }
621 }
622
623 /* do the '+' substitution */
624 if (home_match)
625 {
626 *path++ = '+';
627 /* copy remaining path, skipping delimiter */
628 if (hlen != 0)
629 hlen++;
630 memcpy(path, target_mailbox + hlen, tlen - hlen);
631 path[tlen - hlen] = '\0';
632 return;
633 }
634
635fallback:
636 mutt_account_tourl(&cac_target, &url);
637 url.path = target_mailbox;
638 url_tostring(&url, path, pathlen, U_NO_FLAGS);
639}
640
647enum QuadOption imap_continue(const char *msg, const char *resp)
648{
649 imap_error(msg, resp);
650 return query_yesorno(_("Continue?"), MUTT_NO);
651}
652
658void imap_error(const char *where, const char *msg)
659{
660 mutt_error("%s [%s]", where, msg);
661}
662
680char *imap_fix_path(char delim, const char *mailbox, char *path, size_t plen)
681{
682 int i = 0;
683 const char *const c_imap_delim_chars = cs_subset_string(NeoMutt->sub, "imap_delim_chars");
684 for (; mailbox && *mailbox && (i < (plen - 1)); i++)
685 {
686 if ((*mailbox == delim) || (!delim && strchr(NONULL(c_imap_delim_chars), *mailbox)))
687 {
688 delim = *mailbox;
689 /* Skip multiple occurrences of delim */
690 while (*mailbox && *(mailbox + 1) == delim)
691 mailbox++;
692 }
693 path[i] = *mailbox++;
694 }
695
696 /* Do not terminate with a delimiter */
697 if ((i != 0) && (path[i - 1] == delim))
698 i--;
699
700 /* Ensure null termination */
701 path[i] = '\0';
702 return path;
703}
704
711void imap_cachepath(char delim, const char *mailbox, struct Buffer *dest)
712{
713 const char *p = mailbox;
714 buf_reset(dest);
715 if (!p)
716 return;
717
718 while (*p)
719 {
720 if (p[0] == delim)
721 {
722 buf_addch(dest, '/');
723 /* simple way to avoid collisions with UIDs */
724 if ((p[1] >= '0') && (p[1] <= '9'))
725 buf_addch(dest, '_');
726 }
727 else
728 {
729 buf_addch(dest, *p);
730 }
731 p++;
732 }
733}
734
742int imap_get_literal_count(const char *buf, unsigned int *bytes)
743{
744 char *pc = NULL;
745 char *pn = NULL;
746
747 if (!buf || !(pc = strchr(buf, '{')))
748 return -1;
749
750 pc++;
751 pn = pc;
752 while (isdigit((unsigned char) *pc))
753 pc++;
754 *pc = '\0';
755 if (!mutt_str_atoui(pn, bytes))
756 return -1;
757
758 return 0;
759}
760
769char *imap_get_qualifier(char *buf)
770{
771 char *s = buf;
772
773 /* skip tag */
774 s = imap_next_word(s);
775 /* skip OK/NO/BAD response */
776 s = imap_next_word(s);
777
778 return s;
779}
780
786char *imap_next_word(char *s)
787{
788 bool quoted = false;
789
790 while (*s)
791 {
792 if (*s == '\\')
793 {
794 s++;
795 if (*s)
796 s++;
797 continue;
798 }
799 if (*s == '\"')
800 quoted = !quoted;
801 if (!quoted && isspace(*s))
802 break;
803 s++;
804 }
805
806 SKIPWS(s);
807 return s;
808}
809
817void imap_qualify_path(char *buf, size_t buflen, struct ConnAccount *cac, char *path)
818{
819 struct Url url = { 0 };
820 mutt_account_tourl(cac, &url);
821 url.path = path;
822 url_tostring(&url, buf, buflen, U_NO_FLAGS);
823}
824
831void imap_buf_qualify_path(struct Buffer *buf, struct ConnAccount *cac, char *path)
832{
833 struct Url url = { 0 };
834 mutt_account_tourl(cac, &url);
835 url.path = path;
836 url_tobuffer(&url, buf, U_NO_FLAGS);
837}
838
848void imap_quote_string(char *dest, size_t dlen, const char *src, bool quote_backtick)
849{
850 const char *quote = "`\"\\";
851 if (!quote_backtick)
852 quote++;
853
854 char *pt = dest;
855 const char *s = src;
856
857 *pt++ = '"';
858 /* save room for quote-chars */
859 dlen -= 3;
860
861 for (; *s && dlen; s++)
862 {
863 if (strchr(quote, *s))
864 {
865 if (dlen < 2)
866 break;
867 dlen -= 2;
868 *pt++ = '\\';
869 *pt++ = *s;
870 }
871 else
872 {
873 *pt++ = *s;
874 dlen--;
875 }
876 }
877 *pt++ = '"';
878 *pt = '\0';
879}
880
886{
887 char *d = s;
888
889 if (*s == '\"')
890 s++;
891 else
892 return;
893
894 while (*s)
895 {
896 if (*s == '\"')
897 {
898 *d = '\0';
899 return;
900 }
901 if (*s == '\\')
902 {
903 s++;
904 }
905 if (*s)
906 {
907 *d = *s;
908 d++;
909 s++;
910 }
911 }
912 *d = '\0';
913}
914
922void imap_munge_mbox_name(bool unicode, char *dest, size_t dlen, const char *src)
923{
924 char *buf = mutt_str_dup(src);
925 imap_utf_encode(unicode, &buf);
926
927 imap_quote_string(dest, dlen, buf, false);
928
929 FREE(&buf);
930}
931
939void imap_unmunge_mbox_name(bool unicode, char *s)
940{
942
943 char *buf = mutt_str_dup(s);
944 if (buf)
945 {
946 imap_utf_decode(unicode, &buf);
947 strncpy(s, buf, strlen(s));
948 }
949
950 FREE(&buf);
951}
952
957{
958 time_t now = mutt_date_now();
959 struct Account *np = NULL;
960 const short c_imap_keep_alive = cs_subset_number(NeoMutt->sub, "imap_keep_alive");
961 TAILQ_FOREACH(np, &NeoMutt->accounts, entries)
962 {
963 if (np->type != MUTT_IMAP)
964 continue;
965
966 struct ImapAccountData *adata = np->adata;
967 if (!adata || !adata->mailbox)
968 continue;
969
970 if ((adata->state >= IMAP_AUTHENTICATED) && (now >= (adata->lastread + c_imap_keep_alive)))
971 imap_check_mailbox(adata->mailbox, true);
972 }
973}
974
981{
982 struct sigaction oldalrm = { 0 };
983 struct sigaction act = { 0 };
984 sigset_t oldmask = { 0 };
985 int rc;
986
987 const bool c_imap_passive = cs_subset_bool(NeoMutt->sub, "imap_passive");
988 cs_subset_str_native_set(NeoMutt->sub, "imap_passive", true, NULL);
989 OptKeepQuiet = true;
990
991 sigprocmask(SIG_SETMASK, NULL, &oldmask);
992
993 sigemptyset(&act.sa_mask);
994 act.sa_handler = mutt_sig_empty_handler;
995#ifdef SA_INTERRUPT
996 act.sa_flags = SA_INTERRUPT;
997#else
998 act.sa_flags = 0;
999#endif
1000
1001 sigaction(SIGALRM, &act, &oldalrm);
1002
1003 const short c_imap_keep_alive = cs_subset_number(NeoMutt->sub, "imap_keep_alive");
1004 alarm(c_imap_keep_alive);
1005 while ((waitpid(pid, &rc, 0) < 0) && (errno == EINTR))
1006 {
1007 alarm(0); /* cancel a possibly pending alarm */
1009 alarm(c_imap_keep_alive);
1010 }
1011
1012 alarm(0); /* cancel a possibly pending alarm */
1013
1014 sigaction(SIGALRM, &oldalrm, NULL);
1015 sigprocmask(SIG_SETMASK, &oldmask, NULL);
1016
1017 OptKeepQuiet = false;
1018 cs_subset_str_native_set(NeoMutt->sub, "imap_passive", c_imap_passive, NULL);
1019
1020 return rc;
1021}
1022
1028{
1030 struct ImapMboxData *mdata = imap_mdata_get(m);
1031 if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
1032 return;
1033 mdata->reopen |= IMAP_REOPEN_ALLOW;
1034}
1035
1041{
1043 struct ImapMboxData *mdata = imap_mdata_get(m);
1044 if (!adata || !adata->mailbox || (adata->mailbox != m) || !mdata)
1045 return;
1046 mdata->reopen &= ~IMAP_REOPEN_ALLOW;
1047}
1048
1055bool imap_account_match(const struct ConnAccount *a1, const struct ConnAccount *a2)
1056{
1057 if (!a1 || !a2)
1058 return false;
1059 if (a1->type != a2->type)
1060 return false;
1061 if (!mutt_istr_equal(a1->host, a2->host))
1062 return false;
1063 if ((a1->port != 0) && (a2->port != 0) && (a1->port != a2->port))
1064 return false;
1065 if (a1->flags & a2->flags & MUTT_ACCT_USER)
1066 return mutt_str_equal(a1->user, a2->user);
1067
1068 const char *user = NONULL(Username);
1069
1070 const char *const c_imap_user = cs_subset_string(NeoMutt->sub, "imap_user");
1071 if ((a1->type == MUTT_ACCT_TYPE_IMAP) && c_imap_user)
1072 user = c_imap_user;
1073
1074 if (a1->flags & MUTT_ACCT_USER)
1075 return mutt_str_equal(a1->user, user);
1076 if (a2->flags & MUTT_ACCT_USER)
1077 return mutt_str_equal(a2->user, user);
1078
1079 return true;
1080}
1081
1087struct SeqsetIterator *mutt_seqset_iterator_new(const char *seqset)
1088{
1089 if (!seqset || (*seqset == '\0'))
1090 return NULL;
1091
1092 struct SeqsetIterator *iter = mutt_mem_calloc(1, sizeof(struct SeqsetIterator));
1093 iter->full_seqset = mutt_str_dup(seqset);
1094 iter->eostr = strchr(iter->full_seqset, '\0');
1095 iter->substr_cur = iter->substr_end = iter->full_seqset;
1096
1097 return iter;
1098}
1099
1108int mutt_seqset_iterator_next(struct SeqsetIterator *iter, unsigned int *next)
1109{
1110 if (!iter || !next)
1111 return -1;
1112
1113 if (iter->in_range)
1114 {
1115 if ((iter->down && (iter->range_cur == (iter->range_end - 1))) ||
1116 (!iter->down && (iter->range_cur == (iter->range_end + 1))))
1117 {
1118 iter->in_range = 0;
1119 }
1120 }
1121
1122 if (!iter->in_range)
1123 {
1124 iter->substr_cur = iter->substr_end;
1125 if (iter->substr_cur == iter->eostr)
1126 return 1;
1127
1128 iter->substr_end = strchr(iter->substr_cur, ',');
1129 if (!iter->substr_end)
1130 iter->substr_end = iter->eostr;
1131 else
1132 *(iter->substr_end++) = '\0';
1133
1134 char *range_sep = strchr(iter->substr_cur, ':');
1135 if (range_sep)
1136 *range_sep++ = '\0';
1137
1138 if (!mutt_str_atoui_full(iter->substr_cur, &iter->range_cur))
1139 return -1;
1140 if (range_sep)
1141 {
1142 if (!mutt_str_atoui_full(range_sep, &iter->range_end))
1143 return -1;
1144 }
1145 else
1146 {
1147 iter->range_end = iter->range_cur;
1148 }
1149
1150 iter->down = (iter->range_end < iter->range_cur);
1151 iter->in_range = 1;
1152 }
1153
1154 *next = iter->range_cur;
1155 if (iter->down)
1156 iter->range_cur--;
1157 else
1158 iter->range_cur++;
1159
1160 return 0;
1161}
1162
1168{
1169 if (!ptr || !*ptr)
1170 return;
1171
1172 struct SeqsetIterator *iter = *ptr;
1173 FREE(&iter->full_seqset);
1174 FREE(ptr);
1175}
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)
void mutt_bcache_close(struct BodyCache **ptr)
Close an Email-Body Cache.
Definition: bcache.c:169
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_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241
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
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
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
Definition: helpers.c:168
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.
ConnAccountField
Login credentials.
Definition: connaccount.h:33
@ MUTT_CA_OAUTH_CMD
OAuth refresh command.
Definition: connaccount.h:38
@ MUTT_CA_USER
User name.
Definition: connaccount.h:36
@ MUTT_CA_LOGIN
Login name.
Definition: connaccount.h:35
@ MUTT_CA_HOST
Server name.
Definition: connaccount.h:34
@ MUTT_CA_PASS
Password.
Definition: connaccount.h:37
#define MUTT_ACCT_SSL
Account uses SSL/TLS.
Definition: connaccount.h:47
#define MUTT_ACCT_USER
User field has been set.
Definition: connaccount.h:44
#define MUTT_ACCT_PORT
Port field has been set.
Definition: connaccount.h:43
Convenience wrapper for the core headers.
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
Structs that make up an email.
bool OptKeepQuiet
(pseudo) shut up the message and refresh functions while we are executing an external program
Definition: globals.c:66
char * Username
User's login name.
Definition: globals.c:41
static const char * imap_get_field(enum ConnAccountField field, void *gf_data)
Get connection login credentials - Implements ConnAccount::get_field() -.
Definition: util.c:205
static void imap_hcache_namer(const char *path, struct Buffer *dest)
Generate a filename for the header cache - Implements hcache_namer_t -.
Definition: util.c:289
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
void imap_mdata_free(void **ptr)
Free the private Mailbox data - Implements Mailbox::mdata_free() -.
Definition: mdata.c:40
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
void mutt_hash_free(struct HashTable **ptr)
Free a hash table.
Definition: hash.c:457
struct HeaderCache * hcache_open(const char *path, const char *folder, hcache_namer_t namer, bool create)
Multiplexor for StoreOps::open.
Definition: hcache.c:471
int hcache_delete_email(struct HeaderCache *hc, const char *key, size_t keylen)
Multiplexor for StoreOps::delete_record.
Definition: hcache.c:742
void hcache_close(struct HeaderCache **ptr)
Multiplexor for StoreOps::close.
Definition: hcache.c:545
struct HCacheEntry hcache_fetch_email(struct HeaderCache *hc, const char *key, size_t keylen, uint32_t uidvalidity)
Multiplexor for StoreOps::fetch.
Definition: hcache.c:565
int hcache_store_email(struct HeaderCache *hc, const char *key, size_t keylen, struct Email *e, uint32_t uidvalidity)
Multiplexor for StoreOps::store.
Definition: hcache.c:673
char * hcache_fetch_raw_str(struct HeaderCache *hc, const char *key, size_t keylen)
Fetch a string from the cache.
Definition: hcache.c:655
int hcache_delete_raw(struct HeaderCache *hc, const char *key, size_t keylen)
Multiplexor for StoreOps::delete_record.
Definition: hcache.c:755
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:727
Header cache multiplexor.
struct ImapAccountData * imap_adata_get(struct Mailbox *m)
Get the Account data for this mailbox.
Definition: adata.c:123
struct ImapEmailData * imap_edata_get(struct Email *e)
Get the private data for this Email.
Definition: edata.c:67
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
#define IMAP_PORT
Default port for IMAP.
Definition: private.h:44
@ IMAP_AUTHENTICATED
Connection is authenticated.
Definition: private.h:107
#define IMAP_REOPEN_ALLOW
Allow re-opening a folder upon expunge.
Definition: private.h:64
void imap_utf_encode(bool unicode, char **s)
Encode email from local charset to UTF-8.
Definition: utf7.c:397
#define IMAP_SSL_PORT
Port for IMAP over SSL/TLS.
Definition: private.h:45
void imap_utf_decode(bool unicode, char **s)
Decode email from UTF-8 to local charset.
Definition: utf7.c:430
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
@ LL_DEBUG3
Log at debug level 3.
Definition: logging2.h:45
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:51
void * mutt_mem_malloc(size_t size)
Allocate memory on the heap.
Definition: memory.c:91
#define FREE(x)
Definition: memory.h:45
void imap_msn_free(struct MSNArray *msn)
Free the cache.
Definition: msn.c:62
size_t imap_msn_highest(const struct MSNArray *msn)
Return the highest MSN in use.
Definition: msn.c:72
struct Email * imap_msn_get(const struct MSNArray *msn, size_t idx)
Return the Email associated with an msn.
Definition: msn.c:83
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 FALLTHROUGH
Definition: lib.h:111
#define _(a)
Definition: message.h:28
int mutt_str_cmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:399
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_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
int mutt_account_fromurl(struct ConnAccount *cac, const struct Url *url)
Fill ConnAccount with information from url.
Definition: mutt_account.c:44
void mutt_account_tourl(struct ConnAccount *cac, struct Url *url)
Fill URL with info from account.
Definition: mutt_account.c:80
ConnAccount object used by POP and IMAP.
@ MUTT_ACCT_TYPE_IMAP
Imap Account.
Definition: mutt_account.h:38
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.
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
Ask the user a question.
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
GUI display the mailboxes in a side panel.
void mutt_sig_empty_handler(int sig)
Dummy signal handler.
Definition: signal.c:117
Key value store.
#define NONULL(x)
Definition: string2.h:37
#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
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
const char * service
Name of the service, e.g. "imap".
Definition: connaccount.h:61
char host[128]
Server to login to.
Definition: connaccount.h:54
const char *(* get_field)(enum ConnAccountField field, void *gf_data)
Definition: connaccount.h:70
unsigned char type
Connection type, e.g. MUTT_ACCT_TYPE_IMAP.
Definition: connaccount.h:59
MuttAccountFlags flags
Which fields are initialised, e.g. MUTT_ACCT_USER.
Definition: connaccount.h:60
unsigned short port
Port to connect to.
Definition: connaccount.h:58
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
The envelope/body of an email.
Definition: email.h:39
char * path
Path of Email (for local Mailboxes)
Definition: email.h:70
Wrapper for Email retrieved from the header cache.
Definition: lib.h:99
uint32_t uidvalidity
IMAP-specific UIDVALIDITY.
Definition: lib.h:100
struct Email * email
Retrieved email.
Definition: lib.h:102
Header Cache.
Definition: lib.h:86
IMAP-specific Account data -.
Definition: adata.h:40
char delim
Path delimiter.
Definition: adata.h:75
struct Mailbox * mailbox
Current selected mailbox.
Definition: adata.h:76
struct Connection * conn
Connection to IMAP server.
Definition: adata.h:41
unsigned int uid
32-bit Message UID
Definition: edata.h:45
IMAP-specific Mailbox data -.
Definition: mdata.h:40
struct HeaderCache * hcache
Email header cache.
Definition: mdata.h:63
struct BodyCache * bcache
Email body cache.
Definition: mdata.h:61
struct HashTable * uid_hash
Hash Table: "uid" -> Email.
Definition: mdata.h:59
uint32_t uidvalidity
Definition: mdata.h:51
char * name
Mailbox name.
Definition: mdata.h:41
A mailbox.
Definition: mailbox.h:79
void * mdata
Driver specific data.
Definition: mailbox.h:132
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
UID Sequence Set Iterator.
Definition: private.h:169
char * eostr
Definition: private.h:171
char * substr_end
Definition: private.h:177
unsigned int range_end
Definition: private.h:175
char * substr_cur
Definition: private.h:176
char * full_seqset
Definition: private.h:170
unsigned int range_cur
Definition: private.h:174
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:69
char * src
Raw URL string.
Definition: url.h:77
char * path
Path.
Definition: url.h:75
enum UrlScheme scheme
Scheme, e.g. U_SMTPS.
Definition: url.h:70
int cs_subset_str_native_set(const struct ConfigSubset *sub, const char *name, intptr_t value, struct Buffer *err)
Natively set the value of a string config item.
Definition: subset.c:297
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
int url_tobuffer(const struct Url *url, struct Buffer *buf, uint8_t flags)
Output the URL string for a given Url object.
Definition: url.c:358
#define U_NO_FLAGS
Definition: url.h:49
@ U_IMAP
Url is imap://.
Definition: url.h:39
@ U_IMAPS
Url is imaps://.
Definition: url.h:40
#define U_PATH
Definition: url.h:50
void imap_unmunge_mbox_name(bool unicode, char *s)
Remove quoting from a mailbox name.
Definition: util.c:939
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
void imap_qualify_path(char *buf, size_t buflen, struct ConnAccount *cac, char *path)
Make an absolute IMAP folder target.
Definition: util.c:817
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
void imap_hcache_open(struct ImapAccountData *adata, struct ImapMboxData *mdata, bool create)
Open a header cache.
Definition: util.c:300
int imap_get_literal_count(const char *buf, unsigned int *bytes)
Write number of bytes in an IMAP literal into bytes.
Definition: util.c:742
int imap_hcache_store_uid_seqset(struct ImapMboxData *mdata)
Store a UID Sequence Set in the header cache.
Definition: util.c:416
int imap_hcache_put(struct ImapMboxData *mdata, struct Email *e)
Add an entry to the header cache.
Definition: util.c:381
void imap_mdata_cache_reset(struct ImapMboxData *mdata)
Release and clear cache data of ImapMboxData structure.
Definition: util.c:107
void imap_get_parent(const char *mbox, char delim, char *buf, size_t buflen)
Get an IMAP folder's parent.
Definition: util.c:121
struct SeqsetIterator * mutt_seqset_iterator_new(const char *seqset)
Create a new Sequence Set Iterator.
Definition: util.c:1087
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
char * imap_hcache_get_uid_seqset(struct ImapMboxData *mdata)
Get a UID Sequence Set from the header cache.
Definition: util.c:451
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
void imap_unquote_string(char *s)
Equally stupid unquoting routine.
Definition: util.c:885
struct Email * imap_hcache_get(struct ImapMboxData *mdata, unsigned int uid)
Get a header cache entry by its UID.
Definition: util.c:356
int imap_wait_keep_alive(pid_t pid)
Wait for a process to change state.
Definition: util.c:980
void imap_get_parent_path(const char *path, char *buf, size_t buflen)
Get the path of the parent folder.
Definition: util.c:162
int mutt_seqset_iterator_next(struct SeqsetIterator *iter, unsigned int *next)
Get the next UID from a Sequence Set.
Definition: util.c:1108
void imap_clean_path(char *path, size_t plen)
Cleans an IMAP path using imap_fix_path.
Definition: util.c:189
void mutt_seqset_iterator_free(struct SeqsetIterator **ptr)
Free a Sequence Set Iterator.
Definition: util.c:1167
char * imap_fix_path(char delim, const char *mailbox, char *path, size_t plen)
Fix up the imap path.
Definition: util.c:680
int imap_mxcmp(const char *mx1, const char *mx2)
Compare mailbox names, giving priority to INBOX.
Definition: util.c:546
void imap_pretty_mailbox(char *path, size_t pathlen, const char *folder)
Prettify an IMAP mailbox name.
Definition: util.c:582
void imap_cachepath(char delim, const char *mailbox, struct Buffer *dest)
Generate a cache path for a mailbox.
Definition: util.c:711
void imap_error(const char *where, const char *msg)
Show an error and abort.
Definition: util.c:658
void imap_hcache_close(struct ImapMboxData *mdata)
Close the header cache.
Definition: util.c:341
int imap_hcache_del(struct ImapMboxData *mdata, unsigned int uid)
Delete an item from the header cache.
Definition: util.c:399
int imap_hcache_clear_uid_seqset(struct ImapMboxData *mdata)
Delete a UID Sequence Set from the header cache.
Definition: util.c:437
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
void imap_keep_alive(void)
Poll the current folder to keep the connection alive.
Definition: util.c:956
static void imap_msn_index_to_uid_seqset(struct Buffer *buf, struct ImapMboxData *mdata)
Convert MSN index of UIDs to Seqset.
Definition: util.c:232
void imap_buf_qualify_path(struct Buffer *buf, struct ConnAccount *cac, char *path)
Make an absolute IMAP folder target to a buffer.
Definition: util.c:831
char * imap_next_word(char *s)
Find where the next IMAP word begins.
Definition: util.c:786
char * imap_get_qualifier(char *buf)
Get the qualifier from a tagged response.
Definition: util.c:769