NeoMutt  2024-11-14-138-ge5ca67
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
exec.c
Go to the documentation of this file.
1
33#include "config.h"
34#include <stdarg.h> // IWYU pragma: keep
35#include <stdbool.h>
36#include <stdio.h>
37#include <string.h>
38#include <unistd.h>
39#include "private.h"
40#include "mutt/lib.h"
41#include "address/lib.h"
42#include "config/lib.h"
43#include "email/lib.h"
44#include "core/lib.h"
45#include "alias/alias.h" // IWYU pragma: keep
46#include "alias/gui.h" // IWYU pragma: keep
47#include "alias/lib.h"
48#include "mutt.h"
49#include "lib.h"
50#include "attach/lib.h"
51#include "ncrypt/lib.h"
52#include "send/lib.h"
53#include "copy.h"
54#include "handler.h"
55#include "maillist.h"
56#include "mx.h"
57#ifndef USE_FMEMOPEN
58#include <sys/stat.h>
59#endif
60
61static bool pattern_exec(struct Pattern *pat, PatternExecFlags flags,
62 struct Mailbox *m, struct Email *e,
63 struct Message *msg, struct PatternCache *cache);
64
72static bool patmatch(const struct Pattern *pat, const char *buf)
73{
74 if (pat->is_multi)
75 return (mutt_list_find(&pat->p.multi_cases, buf) != NULL);
76 if (pat->string_match)
77 return pat->ign_case ? mutt_istr_find(buf, pat->p.str) : strstr(buf, pat->p.str);
78 if (pat->group_match)
79 return mutt_group_match(pat->p.group, buf);
80 return (regexec(pat->p.regex, buf, 0, NULL, 0) == 0);
81}
82
88{
89 const struct PatternFlags *entry = lookup_op(op);
90 if (entry)
91 {
92 /* L10N: One of the crypt pattern operators: ~g, ~G, ~k, ~V
93 was invoked when NeoMutt was compiled without crypto support.
94 %c is the pattern character, i.e. "g". */
95 mutt_error(_("Pattern operator '~%c' is disabled"), entry->tag);
96 }
97 else
98 {
99 /* L10N: An unknown pattern operator was somehow invoked.
100 This shouldn't be possible unless there is a bug. */
101 mutt_error(_("error: unknown op %d (report this error)"), op);
102 }
103}
104
113static bool msg_search(struct Pattern *pat, struct Email *e, struct Message *msg)
114{
115 ASSERT(msg);
116
117 bool match = false;
118
119 FILE *fp = NULL;
120 long len = 0;
121#ifdef USE_FMEMOPEN
122 char *temp = NULL;
123 size_t tempsize = 0;
124#else
125 struct stat st = { 0 };
126#endif
127
128 const bool needs_head = (pat->op == MUTT_PAT_HEADER) || (pat->op == MUTT_PAT_WHOLE_MSG);
129 const bool needs_body = (pat->op == MUTT_PAT_BODY) || (pat->op == MUTT_PAT_WHOLE_MSG);
130 const bool c_thorough_search = cs_subset_bool(NeoMutt->sub, "thorough_search");
131 if (c_thorough_search)
132 {
133 /* decode the header / body */
134 struct State state = { 0 };
135 state.fp_in = msg->fp;
136 state.flags = STATE_CHARCONV;
137#ifdef USE_FMEMOPEN
138 state.fp_out = open_memstream(&temp, &tempsize);
139 if (!state.fp_out)
140 {
141 mutt_perror(_("Error opening 'memory stream'"));
142 return false;
143 }
144#else
145 state.fp_out = mutt_file_mkstemp();
146 if (!state.fp_out)
147 {
148 mutt_perror(_("Can't create temporary file"));
149 return false;
150 }
151#endif
152
153 if (needs_head)
154 {
155 mutt_copy_header(msg->fp, e, state.fp_out, CH_FROM | CH_DECODE, NULL, 0);
156 }
157
158 if (needs_body)
159 {
161
162 if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT) &&
164 {
165 if (state.fp_out)
166 {
167 mutt_file_fclose(&state.fp_out);
168#ifdef USE_FMEMOPEN
169 FREE(&temp);
170#endif
171 }
172 return false;
173 }
174
175 if (!mutt_file_seek(msg->fp, e->offset, SEEK_SET))
176 {
177#ifdef USE_FMEMOPEN
178 FREE(&temp);
179#endif
180 return false;
181 }
182 mutt_body_handler(e->body, &state);
183 }
184
185#ifdef USE_FMEMOPEN
186 mutt_file_fclose(&state.fp_out);
187 len = tempsize;
188
189 if (tempsize != 0)
190 {
191 fp = fmemopen(temp, tempsize, "r");
192 if (!fp)
193 {
194 mutt_perror(_("Error re-opening 'memory stream'"));
195 FREE(&temp);
196 return false;
197 }
198 }
199 else
200 { /* fmemopen can't handle empty buffers */
201 fp = mutt_file_fopen("/dev/null", "r");
202 if (!fp)
203 {
204 mutt_perror(_("Error opening /dev/null"));
205 FREE(&temp);
206 return false;
207 }
208 }
209#else
210 fp = state.fp_out;
211 fflush(fp);
212 if (!mutt_file_seek(fp, 0, SEEK_SET) || fstat(fileno(fp), &st))
213 {
214 mutt_perror(_("Error checking length of temporary file"));
215 mutt_file_fclose(&fp);
216 return false;
217 }
218 len = (long) st.st_size;
219#endif
220 }
221 else
222 {
223 /* raw header / body */
224 fp = msg->fp;
225 if (needs_head)
226 {
227 if (!mutt_file_seek(fp, e->offset, SEEK_SET))
228 {
229 return false;
230 }
231 len = e->body->offset - e->offset;
232 }
233 if (needs_body)
234 {
235 if (pat->op == MUTT_PAT_BODY)
236 {
237 if (!mutt_file_seek(fp, e->body->offset, SEEK_SET))
238 {
239 return false;
240 }
241 }
242 len += e->body->length;
243 }
244 }
245
246 /* search the file "fp" */
247 if (pat->op == MUTT_PAT_HEADER)
248 {
249 struct Buffer *buf = buf_pool_get();
250 while (len > 0)
251 {
252 if (mutt_rfc822_read_line(fp, buf) == 0)
253 {
254 break;
255 }
256 len -= buf_len(buf);
257 if (patmatch(pat, buf_string(buf)))
258 {
259 match = true;
260 break;
261 }
262 }
263 buf_pool_release(&buf);
264 }
265 else
266 {
267 char buf[1024] = { 0 };
268 while (len > 0)
269 {
270 if (!fgets(buf, sizeof(buf), fp))
271 {
272 break; /* don't loop forever */
273 }
274 len -= mutt_str_len(buf);
275 if (patmatch(pat, buf))
276 {
277 match = true;
278 break;
279 }
280 }
281 }
282
283 if (c_thorough_search)
284 mutt_file_fclose(&fp);
285
286#ifdef USE_FMEMOPEN
287 FREE(&temp);
288#endif
289
290 return match;
291}
292
303static bool perform_and(struct PatternList *pat, PatternExecFlags flags,
304 struct Mailbox *m, struct Email *e, struct Message *msg,
305 struct PatternCache *cache)
306{
307 struct Pattern *p = NULL;
308
309 SLIST_FOREACH(p, pat, entries)
310 {
311 if (!pattern_exec(p, flags, m, e, msg, cache))
312 {
313 return false;
314 }
315 }
316 return true;
317}
318
327static bool perform_alias_and(struct PatternList *pat, PatternExecFlags flags,
328 struct AliasView *av, struct PatternCache *cache)
329{
330 struct Pattern *p = NULL;
331
332 SLIST_FOREACH(p, pat, entries)
333 {
334 if (!mutt_pattern_alias_exec(p, flags, av, cache))
335 {
336 return false;
337 }
338 }
339 return true;
340}
341
352static int perform_or(struct PatternList *pat, PatternExecFlags flags,
353 struct Mailbox *m, struct Email *e, struct Message *msg,
354 struct PatternCache *cache)
355{
356 struct Pattern *p = NULL;
357
358 SLIST_FOREACH(p, pat, entries)
359 {
360 if (pattern_exec(p, flags, m, e, msg, cache))
361 {
362 return true;
363 }
364 }
365 return false;
366}
367
376static int perform_alias_or(struct PatternList *pat, PatternExecFlags flags,
377 struct AliasView *av, struct PatternCache *cache)
378{
379 struct Pattern *p = NULL;
380
381 SLIST_FOREACH(p, pat, entries)
382 {
383 if (mutt_pattern_alias_exec(p, flags, av, cache))
384 {
385 return true;
386 }
387 }
388 return false;
389}
390
397static bool match_tags(struct Pattern *pat, struct TagList *tags)
398{
399 struct Tag *tag = NULL;
400 bool matched = false;
401 STAILQ_FOREACH(tag, tags, entries)
402 {
403 matched |= patmatch(pat, tag->name);
404 }
405 return pat->pat_not ^ matched;
406}
407
418static int match_addrlist(struct Pattern *pat, bool match_personal, int n, ...)
419{
420 va_list ap;
421
422 va_start(ap, n);
423 while (n-- > 0)
424 {
425 struct AddressList *al = va_arg(ap, struct AddressList *);
426 struct Address *a = NULL;
427 TAILQ_FOREACH(a, al, entries)
428 {
429 if (pat->all_addr ^
430 ((!pat->is_alias || alias_reverse_lookup(a)) &&
431 ((a->mailbox && patmatch(pat, buf_string(a->mailbox))) ||
432 (match_personal && a->personal && patmatch(pat, buf_string(a->personal))))))
433 {
434 va_end(ap);
435 return !pat->all_addr; /* Found match, or non-match if all_addr */
436 }
437 }
438 }
439 va_end(ap);
440 return pat->all_addr; /* No matches, or all matches if all_addr */
441}
442
449static bool match_reference(struct Pattern *pat, struct ListHead *refs)
450{
451 struct ListNode *np = NULL;
452 STAILQ_FOREACH(np, refs, entries)
453 {
454 if (patmatch(pat, np->data))
455 return true;
456 }
457 return false;
458}
459
471static bool mutt_is_predicate_recipient(bool all_addr, struct Envelope *env, addr_predicate_t p)
472{
473 struct AddressList *als[] = { &env->to, &env->cc };
474 for (size_t i = 0; i < mutt_array_size(als); ++i)
475 {
476 struct AddressList *al = als[i];
477 struct Address *a = NULL;
478 TAILQ_FOREACH(a, al, entries)
479 {
480 if (all_addr ^ p(a))
481 return !all_addr;
482 }
483 }
484 return all_addr;
485}
486
495bool mutt_is_subscribed_list_recipient(bool all_addr, struct Envelope *env)
496{
498}
499
508bool mutt_is_list_recipient(bool all_addr, struct Envelope *env)
509{
510 return mutt_is_predicate_recipient(all_addr, env, &mutt_is_mail_list);
511}
512
522static int match_user(bool all_addr, int n, ...)
523{
524 va_list ap;
525
526 va_start(ap, n);
527 while (n-- > 0)
528 {
529 struct AddressList *al = va_arg(ap, struct AddressList *);
530 struct Address *a = NULL;
531 TAILQ_FOREACH(a, al, entries)
532 {
533 if (all_addr ^ mutt_addr_is_user(a))
534 {
535 va_end(ap);
536 return !all_addr;
537 }
538 }
539 }
540 va_end(ap);
541 return all_addr;
542}
543
557static int match_threadcomplete(struct PatternList *pat, PatternExecFlags flags,
558 struct Mailbox *m, struct MuttThread *t,
559 int left, int up, int right, int down)
560{
561 if (!t)
562 return 0;
563
564 int a;
565 struct Email *e = t->message;
566 if (e)
567 if (mutt_pattern_exec(SLIST_FIRST(pat), flags, m, e, NULL))
568 return 1;
569
570 if (up && (a = match_threadcomplete(pat, flags, m, t->parent, 1, 1, 1, 0)))
571 return a;
572 if (right && t->parent && (a = match_threadcomplete(pat, flags, m, t->next, 0, 0, 1, 1)))
573 {
574 return a;
575 }
576 if (left && t->parent && (a = match_threadcomplete(pat, flags, m, t->prev, 1, 0, 0, 1)))
577 {
578 return a;
579 }
580 if (down && (a = match_threadcomplete(pat, flags, m, t->child, 1, 0, 1, 1)))
581 return a;
582 return 0;
583}
584
595static int match_threadparent(struct PatternList *pat, PatternExecFlags flags,
596 struct Mailbox *m, struct MuttThread *t)
597{
598 if (!t || !t->parent || !t->parent->message)
599 return 0;
600
601 return mutt_pattern_exec(SLIST_FIRST(pat), flags, m, t->parent->message, NULL);
602}
603
614static int match_threadchildren(struct PatternList *pat, PatternExecFlags flags,
615 struct Mailbox *m, struct MuttThread *t)
616{
617 if (!t || !t->child)
618 return 0;
619
620 for (t = t->child; t; t = t->next)
621 if (t->message && mutt_pattern_exec(SLIST_FIRST(pat), flags, m, t->message, NULL))
622 return 1;
623
624 return 0;
625}
626
634static bool match_content_type(const struct Pattern *pat, struct Body *b)
635{
636 if (!b)
637 return false;
638
639 char buf[256] = { 0 };
640 snprintf(buf, sizeof(buf), "%s/%s", TYPE(b), b->subtype);
641
642 if (patmatch(pat, buf))
643 return true;
644 if (match_content_type(pat, b->parts))
645 return true;
646 if (match_content_type(pat, b->next))
647 return true;
648 return false;
649}
650
659static bool match_mime_content_type(const struct Pattern *pat, struct Email *e, FILE *fp)
660{
662 return match_content_type(pat, e->body);
663}
664
671static bool match_update_dynamic_date(struct Pattern *pat)
672{
673 struct Buffer *err = buf_pool_get();
674
675 bool rc = eval_date_minmax(pat, pat->p.str, err);
676 buf_pool_release(&err);
677
678 return rc;
679}
680
688static void set_pattern_cache_value(int *cache_entry, int value)
689{
690 *cache_entry = (value != 0) ? 2 : 1;
691}
692
699static bool get_pattern_cache_value(int cache_entry)
700{
701 return cache_entry == 2;
702}
703
709static int is_pattern_cache_set(int cache_entry)
710{
711 return cache_entry != 0;
712}
713
722static int msg_search_sendmode(struct Email *e, struct Pattern *pat)
723{
724 bool match = false;
725 char *buf = NULL;
726 size_t blen = 0;
727 FILE *fp = NULL;
728
729 if ((pat->op == MUTT_PAT_HEADER) || (pat->op == MUTT_PAT_WHOLE_MSG))
730 {
731 struct Buffer *tempfile = buf_pool_get();
732 buf_mktemp(tempfile);
733 fp = mutt_file_fopen(buf_string(tempfile), "w+");
734 if (!fp)
735 {
736 mutt_perror("%s", buf_string(tempfile));
737 buf_pool_release(&tempfile);
738 return 0;
739 }
740
742 false, false, NeoMutt->sub);
743 fflush(fp);
744 if (mutt_file_seek(fp, 0, SEEK_SET))
745 {
746 while ((buf = mutt_file_read_line(buf, &blen, fp, NULL, MUTT_RL_NO_FLAGS)) != NULL)
747 {
748 if (patmatch(pat, buf) == 0)
749 {
750 match = true;
751 break;
752 }
753 }
754 }
755
756 FREE(&buf);
757 mutt_file_fclose(&fp);
758 unlink(buf_string(tempfile));
759 buf_pool_release(&tempfile);
760
761 if (match)
762 return match;
763 }
764
765 if ((pat->op == MUTT_PAT_BODY) || (pat->op == MUTT_PAT_WHOLE_MSG))
766 {
767 fp = mutt_file_fopen(e->body->filename, "r");
768 if (!fp)
769 {
770 mutt_perror("%s", e->body->filename);
771 return 0;
772 }
773
774 while ((buf = mutt_file_read_line(buf, &blen, fp, NULL, MUTT_RL_NO_FLAGS)) != NULL)
775 {
776 if (patmatch(pat, buf) == 0)
777 {
778 match = true;
779 break;
780 }
781 }
782
783 FREE(&buf);
784 mutt_file_fclose(&fp);
785 }
786
787 return match;
788}
789
797static bool pattern_needs_msg(const struct Mailbox *m, const struct Pattern *pat)
798{
799 if (!m)
800 {
801 return false;
802 }
803
804 if ((pat->op == MUTT_PAT_MIMETYPE) || (pat->op == MUTT_PAT_MIMEATTACH))
805 {
806 return true;
807 }
808
809 if ((pat->op == MUTT_PAT_WHOLE_MSG) || (pat->op == MUTT_PAT_BODY) || (pat->op == MUTT_PAT_HEADER))
810 {
811 return !((m->type == MUTT_IMAP) && pat->string_match);
812 }
813
814 if ((pat->op == MUTT_PAT_AND) || (pat->op == MUTT_PAT_OR))
815 {
816 struct Pattern *p = NULL;
817 SLIST_FOREACH(p, pat->child, entries)
818 {
819 if (pattern_needs_msg(m, p))
820 {
821 return true;
822 }
823 }
824 }
825
826 return false;
827}
828
844static bool pattern_exec(struct Pattern *pat, PatternExecFlags flags,
845 struct Mailbox *m, struct Email *e,
846 struct Message *msg, struct PatternCache *cache)
847{
848 switch (pat->op)
849 {
850 case MUTT_PAT_AND:
851 return pat->pat_not ^ (perform_and(pat->child, flags, m, e, msg, cache) > 0);
852 case MUTT_PAT_OR:
853 return pat->pat_not ^ (perform_or(pat->child, flags, m, e, msg, cache) > 0);
854 case MUTT_PAT_THREAD:
855 return pat->pat_not ^
856 match_threadcomplete(pat->child, flags, m, e->thread, 1, 1, 1, 1);
857 case MUTT_PAT_PARENT:
858 return pat->pat_not ^ match_threadparent(pat->child, flags, m, e->thread);
860 return pat->pat_not ^ match_threadchildren(pat->child, flags, m, e->thread);
861 case MUTT_ALL:
862 return !pat->pat_not;
863 case MUTT_EXPIRED:
864 return pat->pat_not ^ e->expired;
865 case MUTT_SUPERSEDED:
866 return pat->pat_not ^ e->superseded;
867 case MUTT_FLAG:
868 return pat->pat_not ^ e->flagged;
869 case MUTT_TAG:
870 return pat->pat_not ^ e->tagged;
871 case MUTT_NEW:
872 return pat->pat_not ? e->old || e->read : !(e->old || e->read);
873 case MUTT_UNREAD:
874 return pat->pat_not ? e->read : !e->read;
875 case MUTT_REPLIED:
876 return pat->pat_not ^ e->replied;
877 case MUTT_OLD:
878 return pat->pat_not ? (!e->old || e->read) : (e->old && !e->read);
879 case MUTT_READ:
880 return pat->pat_not ^ e->read;
881 case MUTT_DELETED:
882 return pat->pat_not ^ e->deleted;
883 case MUTT_PAT_MESSAGE:
884 return pat->pat_not ^
885 ((email_msgno(e) >= pat->min) && (email_msgno(e) <= pat->max));
886 case MUTT_PAT_DATE:
887 if (pat->dynamic)
889 return pat->pat_not ^ ((e->date_sent >= pat->min) && (e->date_sent <= pat->max));
891 if (pat->dynamic)
893 return pat->pat_not ^ ((e->received >= pat->min) && (e->received <= pat->max));
894 case MUTT_PAT_BODY:
895 case MUTT_PAT_HEADER:
897 if (pat->sendmode)
898 {
899 if (!e->body || !e->body->filename)
900 return false;
901 return pat->pat_not ^ msg_search_sendmode(e, pat);
902 }
903 /* m can be NULL in certain cases, such as when replying to a message
904 * from the attachment menu and the user has a reply-hook using "~e".
905 * This is also the case when message scoring. */
906 if (!m)
907 return false;
908 /* IMAP search sets e->matched at search compile time */
909 if ((m->type == MUTT_IMAP) && pat->string_match)
910 return e->matched;
911 return pat->pat_not ^ msg_search(pat, e, msg);
913 if (!m)
914 return false;
915 if (m->type == MUTT_IMAP)
916 {
917 return (pat->string_match) ? e->matched : false;
918 }
919 mutt_error(_("error: server custom search only supported with IMAP"));
920 return false;
921 case MUTT_PAT_SENDER:
922 if (!e->env)
923 return false;
924 return pat->pat_not ^ match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS),
925 1, &e->env->sender);
926 case MUTT_PAT_FROM:
927 if (!e->env)
928 return false;
929 return pat->pat_not ^
930 match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS), 1, &e->env->from);
931 case MUTT_PAT_TO:
932 if (!e->env)
933 return false;
934 return pat->pat_not ^
935 match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS), 1, &e->env->to);
936 case MUTT_PAT_CC:
937 if (!e->env)
938 return false;
939 return pat->pat_not ^
940 match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS), 1, &e->env->cc);
941 case MUTT_PAT_BCC:
942 if (!e->env)
943 return false;
944 return pat->pat_not ^
945 match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS), 1, &e->env->bcc);
946 case MUTT_PAT_SUBJECT:
947 if (!e->env)
948 return false;
949 return pat->pat_not ^ (e->env->subject && patmatch(pat, e->env->subject));
950 case MUTT_PAT_ID:
952 if (!e->env)
953 return false;
954 return pat->pat_not ^ (e->env->message_id && patmatch(pat, e->env->message_id));
955 case MUTT_PAT_SCORE:
956 return pat->pat_not ^ (e->score >= pat->min &&
957 (pat->max == MUTT_MAXRANGE || e->score <= pat->max));
958 case MUTT_PAT_SIZE:
959 return pat->pat_not ^ (e->body->length >= pat->min &&
960 (pat->max == MUTT_MAXRANGE || e->body->length <= pat->max));
962 if (!e->env)
963 return false;
964 return pat->pat_not ^ (match_reference(pat, &e->env->references) ||
965 match_reference(pat, &e->env->in_reply_to));
966 case MUTT_PAT_ADDRESS:
967 if (!e->env)
968 return false;
969 return pat->pat_not ^ match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS),
970 5, &e->env->from, &e->env->sender,
971 &e->env->to, &e->env->cc, &e->env->bcc);
973 if (!e->env)
974 return false;
975 return pat->pat_not ^ match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS), 3,
976 &e->env->to, &e->env->cc, &e->env->bcc);
977 case MUTT_PAT_LIST: /* known list, subscribed or not */
978 {
979 if (!e->env)
980 return false;
981
982 bool result;
983 if (cache)
984 {
985 int *cache_entry = pat->all_addr ? &cache->list_all : &cache->list_one;
986 if (!is_pattern_cache_set(*cache_entry))
987 {
988 set_pattern_cache_value(cache_entry,
990 }
991 result = get_pattern_cache_value(*cache_entry);
992 }
993 else
994 {
995 result = mutt_is_list_recipient(pat->all_addr, e->env);
996 }
997 return pat->pat_not ^ result;
998 }
1000 {
1001 if (!e->env)
1002 return false;
1003
1004 bool result;
1005 if (cache)
1006 {
1007 int *cache_entry = pat->all_addr ? &cache->sub_all : &cache->sub_one;
1008 if (!is_pattern_cache_set(*cache_entry))
1009 {
1010 set_pattern_cache_value(cache_entry,
1012 }
1013 result = get_pattern_cache_value(*cache_entry);
1014 }
1015 else
1016 {
1018 }
1019 return pat->pat_not ^ result;
1020 }
1022 {
1023 if (!e->env)
1024 return false;
1025
1026 bool result;
1027 if (cache)
1028 {
1029 int *cache_entry = pat->all_addr ? &cache->pers_recip_all : &cache->pers_recip_one;
1030 if (!is_pattern_cache_set(*cache_entry))
1031 {
1032 set_pattern_cache_value(cache_entry,
1033 match_user(pat->all_addr, 3, &e->env->to,
1034 &e->env->cc, &e->env->bcc));
1035 }
1036 result = get_pattern_cache_value(*cache_entry);
1037 }
1038 else
1039 {
1040 result = match_user(pat->all_addr, 3, &e->env->to, &e->env->cc, &e->env->bcc);
1041 }
1042 return pat->pat_not ^ result;
1043 }
1045 {
1046 if (!e->env)
1047 return false;
1048
1049 bool result;
1050 if (cache)
1051 {
1052 int *cache_entry = pat->all_addr ? &cache->pers_from_all : &cache->pers_from_one;
1053 if (!is_pattern_cache_set(*cache_entry))
1054 {
1055 set_pattern_cache_value(cache_entry,
1056 match_user(pat->all_addr, 1, &e->env->from));
1057 }
1058 result = get_pattern_cache_value(*cache_entry);
1059 }
1060 else
1061 {
1062 result = match_user(pat->all_addr, 1, &e->env->from);
1063 }
1064 return pat->pat_not ^ result;
1065 }
1066 case MUTT_PAT_COLLAPSED:
1067 return pat->pat_not ^ (e->collapsed && e->num_hidden > 1);
1069 if (!WithCrypto)
1070 {
1072 return false;
1073 }
1074 return pat->pat_not ^ ((e->security & SEC_SIGN) ? 1 : 0);
1076 if (!WithCrypto)
1077 {
1079 return false;
1080 }
1081 return pat->pat_not ^ ((e->security & SEC_GOODSIGN) ? 1 : 0);
1083 if (!WithCrypto)
1084 {
1086 return false;
1087 }
1088 return pat->pat_not ^ ((e->security & SEC_ENCRYPT) ? 1 : 0);
1089 case MUTT_PAT_PGP_KEY:
1090 if (!(WithCrypto & APPLICATION_PGP))
1091 {
1093 return false;
1094 }
1095 return pat->pat_not ^ ((e->security & PGP_KEY) == PGP_KEY);
1096 case MUTT_PAT_XLABEL:
1097 if (!e->env)
1098 return false;
1099 return pat->pat_not ^ (e->env->x_label && patmatch(pat, e->env->x_label));
1101 {
1102 return match_tags(pat, &e->tags);
1103 }
1104 case MUTT_PAT_HORMEL:
1105 if (!e->env)
1106 return false;
1107 return pat->pat_not ^ (e->env->spam.data && patmatch(pat, e->env->spam.data));
1109 return pat->pat_not ^ (e->thread && e->thread->duplicate_thread);
1111 {
1112 int count = msg ? mutt_count_body_parts(e, msg->fp) : 0;
1113 return pat->pat_not ^
1114 (count >= pat->min && (pat->max == MUTT_MAXRANGE || count <= pat->max));
1115 }
1116 case MUTT_PAT_MIMETYPE:
1117 if (!m || !msg)
1118 return false;
1119 return pat->pat_not ^ match_mime_content_type(pat, e, msg->fp);
1121 return pat->pat_not ^ (e->thread && !e->thread->child);
1122 case MUTT_PAT_BROKEN:
1123 return pat->pat_not ^ (e->thread && e->thread->fake_thread);
1125 if (!e->env)
1126 return false;
1127 return pat->pat_not ^ (e->env->newsgroups && patmatch(pat, e->env->newsgroups));
1128 }
1129 mutt_error(_("error: unknown op %d (report this error)"), pat->op);
1130 return false;
1131}
1132
1148 struct Mailbox *m, struct Email *e, struct PatternCache *cache)
1149{
1150 const bool needs_msg = pattern_needs_msg(m, pat);
1151 struct Message *msg = needs_msg ? mx_msg_open(m, e) : NULL;
1152 if (needs_msg && !msg)
1153 {
1154 return false;
1155 }
1156 const bool matched = pattern_exec(pat, flags, m, e, msg, cache);
1157 mx_msg_close(m, &msg);
1158 return matched;
1159}
1160
1175 struct AliasView *av, struct PatternCache *cache)
1176{
1177 switch (pat->op)
1178 {
1179 case MUTT_PAT_FROM: /* alias */
1180 if (!av->alias)
1181 return false;
1182 return pat->pat_not ^ (av->alias->name && patmatch(pat, av->alias->name));
1183 case MUTT_PAT_CC: /* comment */
1184 if (!av->alias)
1185 return false;
1186 return pat->pat_not ^ (av->alias->comment && patmatch(pat, av->alias->comment));
1187 case MUTT_PAT_TO: /* alias address list */
1188 if (!av->alias)
1189 return false;
1190 return pat->pat_not ^ match_addrlist(pat, (flags & MUTT_MATCH_FULL_ADDRESS),
1191 1, &av->alias->addr);
1193 if (!av->alias)
1194 return false;
1195 return match_tags(pat, &av->alias->tags);
1196 case MUTT_PAT_AND:
1197 return pat->pat_not ^ (perform_alias_and(pat->child, flags, av, cache) > 0);
1198 case MUTT_PAT_OR:
1199 return pat->pat_not ^ (perform_alias_or(pat->child, flags, av, cache) > 0);
1200 }
1201
1202 return false;
1203}
Email Address Handling.
bool(* addr_predicate_t)(const struct Address *a)
Definition: address.h:56
Email Aliases.
struct Address * alias_reverse_lookup(const struct Address *addr)
Does the user have an alias for the given address.
Definition: reverse.c:105
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:600
Representation of a single alias to an email address.
GUI display the mailboxes in a side panel.
void mutt_parse_mime_message(struct Email *e, FILE *fp)
Parse a MIME email.
Definition: attachments.c:596
int mutt_count_body_parts(struct Email *e, FILE *fp)
Count the MIME Body parts.
Definition: attachments.c:251
size_t buf_len(const struct Buffer *buf)
Calculate the length of a Buffer.
Definition: buffer.c:491
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
bool eval_date_minmax(struct Pattern *pat, const char *s, struct Buffer *err)
Evaluate a date-range pattern against 'now'.
Definition: compile.c:496
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.
int mutt_copy_header(FILE *fp_in, struct Email *e, FILE *fp_out, CopyHeaderFlags chflags, const char *prefix, int wraplen)
Copy Email header.
Definition: copy.c:424
Duplicate the structure of an entire email.
#define CH_DECODE
Do RFC2047 header decoding.
Definition: copy.h:56
#define CH_FROM
Retain the "From " message separator?
Definition: copy.h:58
Convenience wrapper for the core headers.
@ MUTT_IMAP
'IMAP' Mailbox type
Definition: mailbox.h:50
bool crypt_valid_passphrase(SecurityFlags flags)
Check that we have a usable passphrase, ask if not.
Definition: crypt.c:132
Structs that make up an email.
size_t mutt_rfc822_read_line(FILE *fp, struct Buffer *buf)
Read a header line from a file.
Definition: parse.c:1125
static bool msg_search(struct Pattern *pat, struct Email *e, struct Message *msg)
Search an email.
Definition: exec.c:113
static bool pattern_needs_msg(const struct Mailbox *m, const struct Pattern *pat)
Check whether a pattern needs a full message.
Definition: exec.c:797
static int match_user(bool all_addr, int n,...)
Matches the user's email Address.
Definition: exec.c:522
static int match_threadcomplete(struct PatternList *pat, PatternExecFlags flags, struct Mailbox *m, struct MuttThread *t, int left, int up, int right, int down)
Match a Pattern against an email thread.
Definition: exec.c:557
bool mutt_pattern_alias_exec(struct Pattern *pat, PatternExecFlags flags, struct AliasView *av, struct PatternCache *cache)
Match a pattern against an alias.
Definition: exec.c:1174
static void print_crypt_pattern_op_error(int op)
Print an error for a disabled crypto pattern.
Definition: exec.c:87
static int match_threadparent(struct PatternList *pat, PatternExecFlags flags, struct Mailbox *m, struct MuttThread *t)
Match Pattern against an email's parent.
Definition: exec.c:595
static bool match_content_type(const struct Pattern *pat, struct Body *b)
Match a Pattern against an Attachment's Content-Type.
Definition: exec.c:634
static bool perform_alias_and(struct PatternList *pat, PatternExecFlags flags, struct AliasView *av, struct PatternCache *cache)
Perform a logical AND on a set of Patterns.
Definition: exec.c:327
static bool match_mime_content_type(const struct Pattern *pat, struct Email *e, FILE *fp)
Match a Pattern against an email's Content-Type.
Definition: exec.c:659
static int match_threadchildren(struct PatternList *pat, PatternExecFlags flags, struct Mailbox *m, struct MuttThread *t)
Match Pattern against an email's children.
Definition: exec.c:614
static bool match_reference(struct Pattern *pat, struct ListHead *refs)
Match references against a Pattern.
Definition: exec.c:449
static int match_addrlist(struct Pattern *pat, bool match_personal, int n,...)
match a pattern against an address list
Definition: exec.c:418
static bool mutt_is_predicate_recipient(bool all_addr, struct Envelope *env, addr_predicate_t p)
Test an Envelopes Addresses using a predicate function.
Definition: exec.c:471
static bool patmatch(const struct Pattern *pat, const char *buf)
Compare a string to a Pattern.
Definition: exec.c:72
static int is_pattern_cache_set(int cache_entry)
Is a given Pattern cached?
Definition: exec.c:709
static int perform_alias_or(struct PatternList *pat, PatternExecFlags flags, struct AliasView *av, struct PatternCache *cache)
Perform a logical OR on a set of Patterns.
Definition: exec.c:376
static bool match_tags(struct Pattern *pat, struct TagList *tags)
match a pattern against a tags list
Definition: exec.c:397
bool mutt_is_subscribed_list_recipient(bool all_addr, struct Envelope *env)
Matches subscribed mailing lists.
Definition: exec.c:495
static int perform_or(struct PatternList *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct Message *msg, struct PatternCache *cache)
Perform a logical OR on a set of Patterns.
Definition: exec.c:352
bool mutt_is_list_recipient(bool all_addr, struct Envelope *env)
Matches known mailing lists.
Definition: exec.c:508
static bool match_update_dynamic_date(struct Pattern *pat)
Update a dynamic date pattern.
Definition: exec.c:671
static bool perform_and(struct PatternList *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct Message *msg, struct PatternCache *cache)
Perform a logical AND on a set of Patterns.
Definition: exec.c:303
static bool get_pattern_cache_value(int cache_entry)
Get pattern cache value.
Definition: exec.c:699
static bool pattern_exec(struct Pattern *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct Message *msg, struct PatternCache *cache)
Match a pattern against an email header.
Definition: exec.c:844
static void set_pattern_cache_value(int *cache_entry, int value)
Sets a value in the PatternCache cache entry.
Definition: exec.c:688
bool mutt_pattern_exec(struct Pattern *pat, PatternExecFlags flags, struct Mailbox *m, struct Email *e, struct PatternCache *cache)
Match a pattern against an email header.
Definition: exec.c:1147
static int msg_search_sendmode(struct Email *e, struct Pattern *pat)
Search in send-mode.
Definition: exec.c:722
char * mutt_file_read_line(char *line, size_t *size, FILE *fp, int *line_num, ReadLineFlags flags)
Read a line from a file.
Definition: file.c:808
bool mutt_file_seek(FILE *fp, LOFF_T offset, int whence)
Wrapper for fseeko with error handling.
Definition: file.c:778
#define mutt_file_fclose(FP)
Definition: file.h:138
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:137
#define MUTT_RL_NO_FLAGS
No flags are set.
Definition: file.h:40
bool mutt_group_match(struct Group *g, const char *s)
Does a string match an entry in a Group?
Definition: group.c:370
bool mutt_is_mail_list(const struct Address *addr)
Is this the email address of a mailing list? - Implements addr_predicate_t -.
Definition: maillist.c:44
bool mutt_is_subscribed_list(const struct Address *addr)
Is this the email address of a user-subscribed mailing list? - Implements addr_predicate_t -.
Definition: maillist.c:56
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_perror(...)
Definition: logging2.h:93
Shared code for the Alias and Query Dialogs.
int mutt_body_handler(struct Body *b, struct State *state)
Handler for the Body of an email.
Definition: handler.c:1632
Decide how to display email content.
int mutt_rfc822_write_header(FILE *fp, struct Envelope *env, struct Body *b, enum MuttWriteHeaderMode mode, bool privacy, bool hide_protected_subject, struct ConfigSubset *sub)
Write out one RFC822 header line.
Definition: header.c:577
@ MUTT_WRITE_HEADER_POSTPONE
A postponed Email, just the envelope info.
Definition: header.h:42
struct ListNode * mutt_list_find(const struct ListHead *h, const char *data)
Find a string in a List.
Definition: list.c:103
Handle mailing lists.
#define FREE(x)
Definition: memory.h:55
#define mutt_array_size(x)
Definition: memory.h:38
#define TYPE(body)
Definition: mime.h:89
Convenience wrapper for the library headers.
#define _(a)
Definition: message.h:28
#define STATE_CHARCONV
Do character set conversions.
Definition: state.h:37
const char * mutt_istr_find(const char *haystack, const char *needle)
Find first occurrence of string (ignoring case)
Definition: string.c:521
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
Many unsorted constants and some structs.
@ MUTT_ALL
All messages.
Definition: mutt.h:68
@ MUTT_SUPERSEDED
Superseded messages.
Definition: mutt.h:84
@ MUTT_EXPIRED
Expired messages.
Definition: mutt.h:83
@ MUTT_READ
Messages that have been read.
Definition: mutt.h:73
@ MUTT_OLD
Old messages.
Definition: mutt.h:71
@ MUTT_TAG
Tagged messages.
Definition: mutt.h:80
@ MUTT_FLAG
Flagged messages.
Definition: mutt.h:79
@ MUTT_DELETED
Deleted messages.
Definition: mutt.h:78
@ MUTT_NEW
New messages.
Definition: mutt.h:70
@ MUTT_UNREAD
Unread messages.
Definition: mutt.h:74
@ MUTT_REPLIED
Messages that have been replied to.
Definition: mutt.h:72
int mx_msg_close(struct Mailbox *m, struct Message **ptr)
Close a message.
Definition: mx.c:1180
struct Message * mx_msg_open(struct Mailbox *m, struct Email *e)
Return a stream pointer for a message.
Definition: mx.c:1134
API for mailboxes.
API for encryption/signing of emails.
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:86
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:96
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:84
#define PGP_KEY
Definition: lib.h:105
#define WithCrypto
Definition: lib.h:122
#define SEC_SIGN
Email is signed.
Definition: lib.h:85
const struct PatternFlags * lookup_op(int op)
Lookup the Pattern Flags for an op.
Definition: flags.c:211
@ MUTT_PAT_HEADER
Pattern matches email's header.
Definition: lib.h:156
@ MUTT_PAT_WHOLE_MSG
Pattern matches raw email text.
Definition: lib.h:158
@ MUTT_PAT_BROKEN
Message is part of a broken thread.
Definition: lib.h:152
@ MUTT_PAT_ID_EXTERNAL
Message-Id is among results from an external query.
Definition: lib.h:154
@ MUTT_PAT_OR
Either pattern can match.
Definition: lib.h:138
@ MUTT_PAT_CHILDREN
Pattern matches a child email.
Definition: lib.h:141
@ MUTT_PAT_PARENT
Pattern matches parent.
Definition: lib.h:140
@ MUTT_PAT_REFERENCE
Pattern matches 'References:' or 'In-Reply-To:' field.
Definition: lib.h:163
@ MUTT_PAT_FROM
Pattern matches 'From:' field.
Definition: lib.h:147
@ MUTT_PAT_DRIVER_TAGS
Pattern matches message tags.
Definition: lib.h:176
@ MUTT_PAT_COLLAPSED
Thread is collapsed.
Definition: lib.h:145
@ MUTT_PAT_CRYPT_VERIFIED
Message is crypographically verified.
Definition: lib.h:171
@ MUTT_PAT_HORMEL
Pattern matches email's spam score.
Definition: lib.h:157
@ MUTT_PAT_SUBJECT
Pattern matches 'Subject:' field.
Definition: lib.h:146
@ MUTT_PAT_LIST
Email is on mailing list.
Definition: lib.h:165
@ MUTT_PAT_NEWSGROUPS
Pattern matches newsgroup.
Definition: lib.h:179
@ MUTT_PAT_PERSONAL_RECIP
Email is addressed to the user.
Definition: lib.h:167
@ MUTT_PAT_CC
Pattern matches 'Cc:' field.
Definition: lib.h:143
@ MUTT_PAT_SUBSCRIBED_LIST
Email is on subscribed mailing list.
Definition: lib.h:166
@ MUTT_PAT_SERVERSEARCH
Server-side pattern matches.
Definition: lib.h:175
@ MUTT_PAT_RECIPIENT
User is a recipient of the email.
Definition: lib.h:164
@ MUTT_PAT_CRYPT_ENCRYPT
Message is encrypted.
Definition: lib.h:172
@ MUTT_PAT_UNREFERENCED
Message is unreferenced in the thread.
Definition: lib.h:151
@ MUTT_PAT_CRYPT_SIGN
Message is signed.
Definition: lib.h:170
@ MUTT_PAT_MESSAGE
Pattern matches message number.
Definition: lib.h:160
@ MUTT_PAT_AND
Both patterns must match.
Definition: lib.h:137
@ MUTT_PAT_DATE
Pattern matches 'Date:' field.
Definition: lib.h:148
@ MUTT_PAT_XLABEL
Pattern matches keyword/label.
Definition: lib.h:174
@ MUTT_PAT_SCORE
Pattern matches email's score.
Definition: lib.h:161
@ MUTT_PAT_MIMEATTACH
Pattern matches number of attachments.
Definition: lib.h:177
@ MUTT_PAT_DUPLICATED
Duplicate message.
Definition: lib.h:150
@ MUTT_PAT_PERSONAL_FROM
Email is from the user.
Definition: lib.h:168
@ MUTT_PAT_TO
Pattern matches 'To:' field.
Definition: lib.h:142
@ MUTT_PAT_BCC
Pattern matches 'Bcc:' field.
Definition: lib.h:144
@ MUTT_PAT_SENDER
Pattern matches sender.
Definition: lib.h:159
@ MUTT_PAT_DATE_RECEIVED
Pattern matches date received.
Definition: lib.h:149
@ MUTT_PAT_ADDRESS
Pattern matches any address field.
Definition: lib.h:169
@ MUTT_PAT_MIMETYPE
Pattern matches MIME type.
Definition: lib.h:178
@ MUTT_PAT_PGP_KEY
Message has PGP key.
Definition: lib.h:173
@ MUTT_PAT_ID
Pattern matches email's Message-Id.
Definition: lib.h:153
@ MUTT_PAT_THREAD
Pattern matches email thread.
Definition: lib.h:139
@ MUTT_PAT_SIZE
Pattern matches email's size.
Definition: lib.h:162
@ MUTT_PAT_BODY
Pattern matches email's body.
Definition: lib.h:155
#define MUTT_MATCH_FULL_ADDRESS
Match the full address.
Definition: lib.h:106
uint8_t PatternExecFlags
Flags for mutt_pattern_exec(), e.g. MUTT_MATCH_FULL_ADDRESS.
Definition: lib.h:104
#define MUTT_MAXRANGE
Definition: private.h:141
static int email_msgno(struct Email *e)
Helper to get the Email's message number.
Definition: private.h:136
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:82
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:96
#define SLIST_FOREACH(var, head, field)
Definition: queue.h:229
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:743
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define SLIST_FIRST(head)
Definition: queue.h:227
Convenience wrapper for the send headers.
GUI display the mailboxes in a side panel.
#define ASSERT(COND)
Definition: signal2.h:58
Key value store.
An email address.
Definition: address.h:36
struct Buffer * personal
Real name of address.
Definition: address.h:37
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
GUI data wrapping an Alias.
Definition: gui.h:38
struct Alias * alias
Alias.
Definition: gui.h:46
struct TagList tags
Tags.
Definition: alias.h:39
char * comment
Free-form comment string.
Definition: alias.h:38
char * name
Short name.
Definition: alias.h:36
struct AddressList addr
List of Addresses the Alias expands to.
Definition: alias.h:37
The body of an email.
Definition: body.h:36
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:73
LOFF_T offset
offset where the actual data begins
Definition: body.h:52
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53
struct Body * next
next attachment in the list
Definition: body.h:72
char * subtype
content-type subtype
Definition: body.h:61
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:59
String manipulation buffer.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:37
The envelope/body of an email.
Definition: email.h:39
bool read
Email is read.
Definition: email.h:50
bool matched
Search matches this Email.
Definition: email.h:102
struct Envelope * env
Envelope information.
Definition: email.h:68
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:120
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib....
Definition: email.h:43
struct Body * body
List of MIME parts.
Definition: email.h:69
bool old
Email is seen, but unread.
Definition: email.h:49
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:123
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:71
bool flagged
Marked important?
Definition: email.h:47
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:60
bool replied
Email has been replied to.
Definition: email.h:51
bool expired
Already expired?
Definition: email.h:46
struct TagList tags
For drivers that support server tagging.
Definition: email.h:72
int score
Message score.
Definition: email.h:113
bool deleted
Email is deleted.
Definition: email.h:78
bool tagged
Email is tagged.
Definition: email.h:107
bool superseded
Got superseded?
Definition: email.h:52
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:61
struct MuttThread * thread
Thread of Emails.
Definition: email.h:119
The header of an Email.
Definition: envelope.h:57
char *const subject
Email's subject.
Definition: envelope.h:70
struct AddressList to
Email's 'To' list.
Definition: envelope.h:60
char * message_id
Message ID.
Definition: envelope.h:73
char * newsgroups
List of newsgroups.
Definition: envelope.h:78
struct AddressList cc
Email's 'Cc' list.
Definition: envelope.h:61
struct AddressList sender
Email's sender.
Definition: envelope.h:63
struct ListHead references
message references (in reverse order)
Definition: envelope.h:83
struct Buffer spam
Spam header.
Definition: envelope.h:82
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:84
struct AddressList bcc
Email's 'Bcc' list.
Definition: envelope.h:62
char * x_label
X-Label.
Definition: envelope.h:76
struct AddressList from
Email's 'From' list.
Definition: envelope.h:59
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
A mailbox.
Definition: mailbox.h:79
enum MailboxType type
Mailbox type.
Definition: mailbox.h:102
A local copy of an email.
Definition: message.h:34
FILE * fp
pointer to the message data
Definition: message.h:35
struct Message::@0 flags
Flags for the Message.
An Email conversation.
Definition: thread.h:34
struct MuttThread * parent
Parent of this Thread.
Definition: thread.h:44
struct MuttThread * prev
Previous sibling Thread.
Definition: thread.h:47
bool fake_thread
Emails grouped by Subject.
Definition: thread.h:38
struct MuttThread * child
Child of this Thread.
Definition: thread.h:45
struct Email * message
Email this Thread refers to.
Definition: thread.h:49
bool duplicate_thread
Duplicated Email in Thread.
Definition: thread.h:37
struct MuttThread * next
Next sibling Thread.
Definition: thread.h:46
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
Cache commonly-used patterns.
Definition: lib.h:117
int pers_recip_all
^~p
Definition: lib.h:122
int list_one
~l
Definition: lib.h:119
int pers_from_one
~P
Definition: lib.h:125
int list_all
^~l
Definition: lib.h:118
int sub_all
^~u
Definition: lib.h:120
int pers_recip_one
~p
Definition: lib.h:123
int pers_from_all
^~P
Definition: lib.h:124
int sub_one
~u
Definition: lib.h:121
Mapping between user character and internal constant.
Definition: private.h:64
char tag
Character used to represent this operation, e.g. 'A' for '~A'.
Definition: private.h:65
int op
Operation to perform, e.g. MUTT_PAT_SCORE.
Definition: private.h:66
A simple (non-regex) pattern.
Definition: lib.h:77
bool group_match
Check a group of Addresses.
Definition: lib.h:82
union Pattern::@1 p
bool all_addr
All Addresses in the list must match.
Definition: lib.h:80
struct Group * group
Address group if group_match is set.
Definition: lib.h:93
struct PatternList * child
Arguments to logical operation.
Definition: lib.h:90
long min
Minimum for range checks.
Definition: lib.h:88
bool string_match
Check a string for a match.
Definition: lib.h:81
regex_t * regex
Compiled regex, for non-pattern matching.
Definition: lib.h:92
struct ListHead multi_cases
Multiple strings for ~I pattern.
Definition: lib.h:95
char * str
String, if string_match is set.
Definition: lib.h:94
bool is_alias
Is there an alias for this Address?
Definition: lib.h:84
bool ign_case
Ignore case for local string_match searches.
Definition: lib.h:83
long max
Maximum for range checks.
Definition: lib.h:89
bool dynamic
Evaluate date ranges at run time.
Definition: lib.h:85
short op
Operation, e.g. MUTT_PAT_SCORE.
Definition: lib.h:78
bool sendmode
Evaluate searches in send-mode.
Definition: lib.h:86
bool is_multi
Multiple case (only for ~I pattern now)
Definition: lib.h:87
bool pat_not
Pattern should be inverted (not)
Definition: lib.h:79
Keep track when processing files.
Definition: state.h:48
StateFlags flags
Flags, e.g. STATE_DISPLAY.
Definition: state.h:52
FILE * fp_out
File to write to.
Definition: state.h:50
FILE * fp_in
File to read from.
Definition: state.h:49
LinkedList Tag Element.
Definition: tags.h:42
char * name
Tag name.
Definition: tags.h:43
#define buf_mktemp(buf)
Definition: tmp.h:33
#define mutt_file_mkstemp()
Definition: tmp.h:36