projects / exim.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
TLS: refactor client-start interface
[exim.git] / src / src / sieve.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) Michael Haardt 2003 - 2015
6 * Copyright (c) The Exim Maintainers 2016 - 2018
7 * See the file NOTICE for conditions of use and distribution.
8 */
9
10 /* This code was contributed by Michael Haardt. */
11
12
13 /* Sieve mail filter. */
14
15 #include <ctype.h>
16 #include <errno.h>
17 #include <limits.h>
18 #include <stdlib.h>
19 #include <string.h>
20
21 #include "exim.h"
22
23 #if HAVE_ICONV
24 # include <iconv.h>
25 #endif
26
27 /* Define this for RFC compliant \r\n end-of-line terminators. */
28 /* Undefine it for UNIX-style \n end-of-line terminators (default). */
29 #undef RFC_EOL
30
31 /* Define this for development of the Sieve extension "encoded-character". */
32 #define ENCODED_CHARACTER
33
34 /* Define this for development of the Sieve extension "envelope-auth". */
35 #undef ENVELOPE_AUTH
36
37 /* Define this for development of the Sieve extension "enotify". */
38 #define ENOTIFY
39
40 /* Define this for the Sieve extension "subaddress". */
41 #define SUBADDRESS
42
43 /* Define this for the Sieve extension "vacation". */
44 #define VACATION
45
46 /* Must be >= 1 */
47 #define VACATION_MIN_DAYS 1
48 /* Must be >= VACATION_MIN_DAYS, must be > 7, should be > 30 */
49 #define VACATION_MAX_DAYS 31
50
51 /* Keep this at 75 to accept only RFC compliant MIME words. */
52 /* Increase it if you want to match headers from buggy MUAs. */
53 #define MIMEWORD_LENGTH 75
54
55 struct Sieve
56 {
57 uschar *filter;
58 const uschar *pc;
59 int line;
60 const uschar *errmsg;
61 int keep;
62 int require_envelope;
63 int require_fileinto;
64 #ifdef ENCODED_CHARACTER
65 int require_encoded_character;
66 #endif
67 #ifdef ENVELOPE_AUTH
68 int require_envelope_auth;
69 #endif
70 #ifdef ENOTIFY
71 int require_enotify;
72 struct Notification *notified;
73 #endif
74 uschar *enotify_mailto_owner;
75 #ifdef SUBADDRESS
76 int require_subaddress;
77 #endif
78 #ifdef VACATION
79 int require_vacation;
80 int vacation_ran;
81 #endif
82 uschar *vacation_directory;
83 const uschar *subaddress;
84 const uschar *useraddress;
85 int require_copy;
86 int require_iascii_numeric;
87 };
88
89 enum Comparator { COMP_OCTET, COMP_EN_ASCII_CASEMAP, COMP_ASCII_NUMERIC };
90 enum MatchType { MATCH_IS, MATCH_CONTAINS, MATCH_MATCHES };
91 #ifdef SUBADDRESS
92 enum AddressPart { ADDRPART_USER, ADDRPART_DETAIL, ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
93 #else
94 enum AddressPart { ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
95 #endif
96 enum RelOp { LT, LE, EQ, GE, GT, NE };
97
98 struct String
99 {
100 uschar *character;
101 int length;
102 };
103
104 struct Notification
105 {
106 struct String method;
107 struct String importance;
108 struct String message;
109 struct Notification *next;
110 };
111
112 /* This should be a complete list of supported extensions, so that an external
113 ManageSieve (RFC 5804) program can interrogate the current Exim binary for the
114 list of extensions and provide correct information to a client.
115
116 We'll emit the list in the order given here; keep it alphabetically sorted, so
117 that callers don't get surprised.
118
119 List *MUST* end with a NULL. Which at least makes ifdef-vs-comma easier. */
120
121 const uschar *exim_sieve_extension_list[] = {
122 CUS"comparator-i;ascii-numeric",
123 CUS"copy",
124 #ifdef ENCODED_CHARACTER
125 CUS"encoded-character",
126 #endif
127 #ifdef ENOTIFY
128 CUS"enotify",
129 #endif
130 CUS"envelope",
131 #ifdef ENVELOPE_AUTH
132 CUS"envelope-auth",
133 #endif
134 CUS"fileinto",
135 #ifdef SUBADDRESS
136 CUS"subaddress",
137 #endif
138 #ifdef VACATION
139 CUS"vacation",
140 #endif
141 NULL
142 };
143
144 static int eq_asciicase(const struct String *needle, const struct String *haystack, int match_prefix);
145 static int parse_test(struct Sieve *filter, int *cond, int exec);
146 static int parse_commands(struct Sieve *filter, int exec, address_item **generated);
147
148 static uschar str_from_c[]="From";
149 static const struct String str_from={ str_from_c, 4 };
150 static uschar str_to_c[]="To";
151 static const struct String str_to={ str_to_c, 2 };
152 static uschar str_cc_c[]="Cc";
153 static const struct String str_cc={ str_cc_c, 2 };
154 static uschar str_bcc_c[]="Bcc";
155 static const struct String str_bcc={ str_bcc_c, 3 };
156 #ifdef ENVELOPE_AUTH
157 static uschar str_auth_c[]="auth";
158 static const struct String str_auth={ str_auth_c, 4 };
159 #endif
160 static uschar str_sender_c[]="Sender";
161 static const struct String str_sender={ str_sender_c, 6 };
162 static uschar str_resent_from_c[]="Resent-From";
163 static const struct String str_resent_from={ str_resent_from_c, 11 };
164 static uschar str_resent_to_c[]="Resent-To";
165 static const struct String str_resent_to={ str_resent_to_c, 9 };
166 static uschar str_fileinto_c[]="fileinto";
167 static const struct String str_fileinto={ str_fileinto_c, 8 };
168 static uschar str_envelope_c[]="envelope";
169 static const struct String str_envelope={ str_envelope_c, 8 };
170 #ifdef ENCODED_CHARACTER
171 static uschar str_encoded_character_c[]="encoded-character";
172 static const struct String str_encoded_character={ str_encoded_character_c, 17 };
173 #endif
174 #ifdef ENVELOPE_AUTH
175 static uschar str_envelope_auth_c[]="envelope-auth";
176 static const struct String str_envelope_auth={ str_envelope_auth_c, 13 };
177 #endif
178 #ifdef ENOTIFY
179 static uschar str_enotify_c[]="enotify";
180 static const struct String str_enotify={ str_enotify_c, 7 };
181 static uschar str_online_c[]="online";
182 static const struct String str_online={ str_online_c, 6 };
183 static uschar str_maybe_c[]="maybe";
184 static const struct String str_maybe={ str_maybe_c, 5 };
185 static uschar str_auto_submitted_c[]="Auto-Submitted";
186 static const struct String str_auto_submitted={ str_auto_submitted_c, 14 };
187 #endif
188 #ifdef SUBADDRESS
189 static uschar str_subaddress_c[]="subaddress";
190 static const struct String str_subaddress={ str_subaddress_c, 10 };
191 #endif
192 #ifdef VACATION
193 static uschar str_vacation_c[]="vacation";
194 static const struct String str_vacation={ str_vacation_c, 8 };
195 static uschar str_subject_c[]="Subject";
196 static const struct String str_subject={ str_subject_c, 7 };
197 #endif
198 static uschar str_copy_c[]="copy";
199 static const struct String str_copy={ str_copy_c, 4 };
200 static uschar str_iascii_casemap_c[]="i;ascii-casemap";
201 static const struct String str_iascii_casemap={ str_iascii_casemap_c, 15 };
202 static uschar str_enascii_casemap_c[]="en;ascii-casemap";
203 static const struct String str_enascii_casemap={ str_enascii_casemap_c, 16 };
204 static uschar str_ioctet_c[]="i;octet";
205 static const struct String str_ioctet={ str_ioctet_c, 7 };
206 static uschar str_iascii_numeric_c[]="i;ascii-numeric";
207 static const struct String str_iascii_numeric={ str_iascii_numeric_c, 15 };
208 static uschar str_comparator_iascii_casemap_c[]="comparator-i;ascii-casemap";
209 static const struct String str_comparator_iascii_casemap={ str_comparator_iascii_casemap_c, 26 };
210 static uschar str_comparator_enascii_casemap_c[]="comparator-en;ascii-casemap";
211 static const struct String str_comparator_enascii_casemap={ str_comparator_enascii_casemap_c, 27 };
212 static uschar str_comparator_ioctet_c[]="comparator-i;octet";
213 static const struct String str_comparator_ioctet={ str_comparator_ioctet_c, 18 };
214 static uschar str_comparator_iascii_numeric_c[]="comparator-i;ascii-numeric";
215 static const struct String str_comparator_iascii_numeric={ str_comparator_iascii_numeric_c, 26 };
216
217
218 /*************************************************
219 * Encode to quoted-printable *
220 *************************************************/
221
222 /*
223 Arguments:
224 src UTF-8 string
225 dst US-ASCII string
226
227 Returns
228 dst
229 */
230
231 static struct String *
232 quoted_printable_encode(const struct String *src, struct String *dst)
233 {
234 uschar *new = NULL;
235 uschar ch;
236 size_t line;
237
238 /* Two passes: one to count output allocation size, second
239 to do the encoding */
240
241 for (int pass = 0; pass <= 1; pass++)
242 {
243 line=0;
244 if (pass==0)
245 dst->length=0;
246 else
247 {
248 dst->character=store_get(dst->length+1); /* plus one for \0 */
249 new=dst->character;
250 }
251 for (const uschar * start = src->character, * end = start + src->length;
252 start < end; ++start)
253 {
254 ch=*start;
255 if (line>=73) /* line length limit */
256 {
257 if (pass==0)
258 dst->length+=2;
259 else
260 {
261 *new++='='; /* line split */
262 *new++='\n';
263 }
264 line=0;
265 }
266 if ( (ch>='!' && ch<='<')
267 || (ch>='>' && ch<='~')
268 || ( (ch=='\t' || ch==' ')
269 && start+2<end
270 && (*(start+1)!='\r' || *(start+2)!='\n') /* CRLF */
271 )
272 )
273 {
274 if (pass==0)
275 ++dst->length;
276 else
277 *new++=*start; /* copy char */
278 ++line;
279 }
280 else if (ch=='\r' && start+1<end && *(start+1)=='\n') /* CRLF */
281 {
282 if (pass==0)
283 ++dst->length;
284 else
285 *new++='\n'; /* NL */
286 line=0;
287 ++start; /* consume extra input char */
288 }
289 else
290 {
291 if (pass==0)
292 dst->length+=3;
293 else
294 { /* encoded char */
295 new += sprintf(CS new,"=%02X",ch);
296 }
297 line+=3;
298 }
299 }
300 }
301 *new='\0'; /* not included in length, but nice */
302 return dst;
303 }
304
305
306 /*************************************************
307 * Check mail address for correct syntax *
308 *************************************************/
309
310 /*
311 Check mail address for being syntactically correct.
312
313 Arguments:
314 filter points to the Sieve filter including its state
315 address String containing one address
316
317 Returns
318 1 Mail address is syntactically OK
319 -1 syntax error
320 */
321
322 int check_mail_address(struct Sieve *filter, const struct String *address)
323 {
324 int start, end, domain;
325 uschar *error,*ss;
326
327 if (address->length>0)
328 {
329 ss = parse_extract_address(address->character, &error, &start, &end, &domain,
330 FALSE);
331 if (ss == NULL)
332 {
333 filter->errmsg=string_sprintf("malformed address \"%s\" (%s)",
334 address->character, error);
335 return -1;
336 }
337 else
338 return 1;
339 }
340 else
341 {
342 filter->errmsg=CUS "empty address";
343 return -1;
344 }
345 }
346
347
348 /*************************************************
349 * Decode URI encoded string *
350 *************************************************/
351
352 /*
353 Arguments:
354 str URI encoded string
355
356 Returns
357 0 Decoding successful
358 -1 Encoding error
359 */
360
361 #ifdef ENOTIFY
362 static int
363 uri_decode(struct String *str)
364 {
365 uschar *s,*t,*e;
366
367 if (str->length==0) return 0;
368 for (s=str->character,t=s,e=s+str->length; s<e; )
369 if (*s=='%')
370 {
371 if (s+2<e && isxdigit(*(s+1)) && isxdigit(*(s+2)))
372 {
373 *t++=((isdigit(*(s+1)) ? *(s+1)-'0' : tolower(*(s+1))-'a'+10)<<4)
374 | (isdigit(*(s+2)) ? *(s+2)-'0' : tolower(*(s+2))-'a'+10);
375 s+=3;
376 }
377 else return -1;
378 }
379 else
380 *t++=*s++;
381
382 *t='\0';
383 str->length=t-str->character;
384 return 0;
385 }
386
387
388 /*************************************************
389 * Parse mailto URI *
390 *************************************************/
391
392 /*
393 Parse mailto-URI.
394
395 mailtoURI = "mailto:" [ to ] [ headers ]
396 to = [ addr-spec *("%2C" addr-spec ) ]
397 headers = "?" header *( "&" header )
398 header = hname "=" hvalue
399 hname = *urlc
400 hvalue = *urlc
401
402 Arguments:
403 filter points to the Sieve filter including its state
404 uri URI, excluding scheme
405 recipient
406 body
407
408 Returns
409 1 URI is syntactically OK
410 0 Unknown URI scheme
411 -1 syntax error
412 */
413
414 static int
415 parse_mailto_uri(struct Sieve *filter, const uschar *uri,
416 string_item **recipient, struct String *header, struct String *subject,
417 struct String *body)
418 {
419 const uschar *start;
420 struct String to, hname;
421 struct String hvalue = {.character = NULL, .length = 0};
422 string_item *new;
423
424 if (Ustrncmp(uri,"mailto:",7))
425 {
426 filter->errmsg=US "Unknown URI scheme";
427 return 0;
428 }
429
430 uri+=7;
431 if (*uri && *uri!='?')
432 for (;;)
433 {
434 /* match to */
435 for (start=uri; *uri && *uri!='?' && (*uri!='%' || *(uri+1)!='2' || tolower(*(uri+2))!='c'); ++uri);
436 if (uri>start)
437 {
438 gstring * g = string_catn(NULL, start, uri-start);
439
440 to.character = string_from_gstring(g);
441 to.length = g->ptr;
442 if (uri_decode(&to)==-1)
443 {
444 filter->errmsg=US"Invalid URI encoding";
445 return -1;
446 }
447 new=store_get(sizeof(string_item));
448 new->text=store_get(to.length+1);
449 if (to.length) memcpy(new->text,to.character,to.length);
450 new->text[to.length]='\0';
451 new->next=*recipient;
452 *recipient=new;
453 }
454 else
455 {
456 filter->errmsg=US"Missing addr-spec in URI";
457 return -1;
458 }
459 if (*uri=='%') uri+=3;
460 else break;
461 }
462 if (*uri=='?')
463 {
464 ++uri;
465 for (;;)
466 {
467 /* match hname */
468 for (start=uri; *uri && (isalnum(*uri) || strchr("$-_.+!*'(),%",*uri)); ++uri);
469 if (uri>start)
470 {
471 gstring * g = string_catn(NULL, start, uri-start);
472
473 hname.character = string_from_gstring(g);
474 hname.length = g->ptr;
475 if (uri_decode(&hname)==-1)
476 {
477 filter->errmsg=US"Invalid URI encoding";
478 return -1;
479 }
480 }
481 /* match = */
482 if (*uri=='=')
483 ++uri;
484 else
485 {
486 filter->errmsg=US"Missing equal after hname";
487 return -1;
488 }
489 /* match hvalue */
490 for (start=uri; *uri && (isalnum(*uri) || strchr("$-_.+!*'(),%",*uri)); ++uri);
491 if (uri>start)
492 {
493 gstring * g = string_catn(NULL, start, uri-start);
494
495 hname.character = string_from_gstring(g);
496 hname.length = g->ptr;
497 if (uri_decode(&hvalue)==-1)
498 {
499 filter->errmsg=US"Invalid URI encoding";
500 return -1;
501 }
502 }
503 if (hname.length==2 && strcmpic(hname.character, US"to")==0)
504 {
505 new=store_get(sizeof(string_item));
506 new->text=store_get(hvalue.length+1);
507 if (hvalue.length) memcpy(new->text,hvalue.character,hvalue.length);
508 new->text[hvalue.length]='\0';
509 new->next=*recipient;
510 *recipient=new;
511 }
512 else if (hname.length==4 && strcmpic(hname.character, US"body")==0)
513 *body=hvalue;
514 else if (hname.length==7 && strcmpic(hname.character, US"subject")==0)
515 *subject=hvalue;
516 else
517 {
518 static struct String ignore[]=
519 {
520 {US"date",4},
521 {US"from",4},
522 {US"message-id",10},
523 {US"received",8},
524 {US"auto-submitted",14}
525 };
526 static struct String *end=ignore+sizeof(ignore)/sizeof(ignore[0]);
527 struct String *i;
528
529 for (i=ignore; i<end && !eq_asciicase(&hname,i,0); ++i);
530 if (i==end)
531 {
532 gstring * g;
533
534 if (header->length==-1) header->length = 0;
535
536 g = string_catn(NULL, header->character, header->length);
537 g = string_catn(g, hname.character, hname.length);
538 g = string_catn(g, CUS ": ", 2);
539 g = string_catn(g, hvalue.character, hvalue.length);
540 g = string_catn(g, CUS "\n", 1);
541
542 header->character = string_from_gstring(g);
543 header->length = g->ptr;
544 }
545 }
546 if (*uri=='&') ++uri;
547 else break;
548 }
549 }
550 if (*uri)
551 {
552 filter->errmsg=US"Syntactically invalid URI";
553 return -1;
554 }
555 return 1;
556 }
557 #endif
558
559
560 /*************************************************
561 * Octet-wise string comparison *
562 *************************************************/
563
564 /*
565 Arguments:
566 needle UTF-8 string to search ...
567 haystack ... inside the haystack
568 match_prefix 1 to compare if needle is a prefix of haystack
569
570 Returns: 0 needle not found in haystack
571 1 needle found
572 */
573
574 static int eq_octet(const struct String *needle,
575 const struct String *haystack, int match_prefix)
576 {
577 size_t nl,hl;
578 const uschar *n,*h;
579
580 nl=needle->length;
581 n=needle->character;
582 hl=haystack->length;
583 h=haystack->character;
584 while (nl>0 && hl>0)
585 {
586 #if !HAVE_ICONV
587 if (*n&0x80) return 0;
588 if (*h&0x80) return 0;
589 #endif
590 if (*n!=*h) return 0;
591 ++n;
592 ++h;
593 --nl;
594 --hl;
595 }
596 return (match_prefix ? nl==0 : nl==0 && hl==0);
597 }
598
599
600 /*************************************************
601 * ASCII case-insensitive string comparison *
602 *************************************************/
603
604 /*
605 Arguments:
606 needle UTF-8 string to search ...
607 haystack ... inside the haystack
608 match_prefix 1 to compare if needle is a prefix of haystack
609
610 Returns: 0 needle not found in haystack
611 1 needle found
612 */
613
614 static int eq_asciicase(const struct String *needle,
615 const struct String *haystack, int match_prefix)
616 {
617 size_t nl,hl;
618 const uschar *n,*h;
619 uschar nc,hc;
620
621 nl=needle->length;
622 n=needle->character;
623 hl=haystack->length;
624 h=haystack->character;
625 while (nl>0 && hl>0)
626 {
627 nc=*n;
628 hc=*h;
629 #if !HAVE_ICONV
630 if (nc&0x80) return 0;
631 if (hc&0x80) return 0;
632 #endif
633 /* tolower depends on the locale and only ASCII case must be insensitive */
634 if ((nc>='A' && nc<='Z' ? nc|0x20 : nc) != (hc>='A' && hc<='Z' ? hc|0x20 : hc)) return 0;
635 ++n;
636 ++h;
637 --nl;
638 --hl;
639 }
640 return (match_prefix ? nl==0 : nl==0 && hl==0);
641 }
642
643
644 /*************************************************
645 * Glob pattern search *
646 *************************************************/
647
648 /*
649 Arguments:
650 needle pattern to search ...
651 haystack ... inside the haystack
652 ascii_caseless ignore ASCII case
653 match_octet match octets, not UTF-8 multi-octet characters
654
655 Returns: 0 needle not found in haystack
656 1 needle found
657 -1 pattern error
658 */
659
660 static int eq_glob(const struct String *needle,
661 const struct String *haystack, int ascii_caseless, int match_octet)
662 {
663 const uschar *n,*h,*nend,*hend;
664 int may_advance=0;
665
666 n=needle->character;
667 h=haystack->character;
668 nend=n+needle->length;
669 hend=h+haystack->length;
670 while (n<nend)
671 {
672 if (*n=='*')
673 {
674 ++n;
675 may_advance=1;
676 }
677 else
678 {
679 const uschar *npart,*hpart;
680
681 /* Try to match a non-star part of the needle at the current */
682 /* position in the haystack. */
683 match_part:
684 npart=n;
685 hpart=h;
686 while (npart<nend && *npart!='*') switch (*npart)
687 {
688 case '?':
689 {
690 if (hpart==hend) return 0;
691 if (match_octet)
692 ++hpart;
693 else
694 {
695 /* Match one UTF8 encoded character */
696 if ((*hpart&0xc0)==0xc0)
697 {
698 ++hpart;
699 while (hpart<hend && ((*hpart&0xc0)==0x80)) ++hpart;
700 }
701 else
702 ++hpart;
703 }
704 ++npart;
705 break;
706 }
707 case '\\':
708 {
709 ++npart;
710 if (npart==nend) return -1;
711 /* FALLTHROUGH */
712 }
713 default:
714 {
715 if (hpart==hend) return 0;
716 /* tolower depends on the locale, but we need ASCII */
717 if
718 (
719 #if !HAVE_ICONV
720 (*hpart&0x80) || (*npart&0x80) ||
721 #endif
722 ascii_caseless
723 ? ((*npart>='A' && *npart<='Z' ? *npart|0x20 : *npart) != (*hpart>='A' && *hpart<='Z' ? *hpart|0x20 : *hpart))
724 : *hpart!=*npart
725 )
726 {
727 if (may_advance)
728 /* string match after a star failed, advance and try again */
729 {
730 ++h;
731 goto match_part;
732 }
733 else return 0;
734 }
735 else
736 {
737 ++npart;
738 ++hpart;
739 };
740 }
741 }
742 /* at this point, a part was matched successfully */
743 if (may_advance && npart==nend && hpart<hend)
744 /* needle ends, but haystack does not: if there was a star before, advance and try again */
745 {
746 ++h;
747 goto match_part;
748 }
749 h=hpart;
750 n=npart;
751 may_advance=0;
752 }
753 }
754 return (h==hend ? 1 : may_advance);
755 }
756
757
758 /*************************************************
759 * ASCII numeric comparison *
760 *************************************************/
761
762 /*
763 Arguments:
764 a first numeric string
765 b second numeric string
766 relop relational operator
767
768 Returns: 0 not (a relop b)
769 1 a relop b
770 */
771
772 static int eq_asciinumeric(const struct String *a,
773 const struct String *b, enum RelOp relop)
774 {
775 size_t al,bl;
776 const uschar *as,*aend,*bs,*bend;
777 int cmp;
778
779 as=a->character;
780 aend=a->character+a->length;
781 bs=b->character;
782 bend=b->character+b->length;
783
784 while (*as>='0' && *as<='9' && as<aend) ++as;
785 al=as-a->character;
786 while (*bs>='0' && *bs<='9' && bs<bend) ++bs;
787 bl=bs-b->character;
788
789 if (al && bl==0) cmp=-1;
790 else if (al==0 && bl==0) cmp=0;
791 else if (al==0 && bl) cmp=1;
792 else
793 {
794 cmp=al-bl;
795 if (cmp==0) cmp=memcmp(a->character,b->character,al);
796 }
797 switch (relop)
798 {
799 case LT: return cmp<0;
800 case LE: return cmp<=0;
801 case EQ: return cmp==0;
802 case GE: return cmp>=0;
803 case GT: return cmp>0;
804 case NE: return cmp!=0;
805 }
806 /*NOTREACHED*/
807 return -1;
808 }
809
810
811 /*************************************************
812 * Compare strings *
813 *************************************************/
814
815 /*
816 Arguments:
817 filter points to the Sieve filter including its state
818 needle UTF-8 pattern or string to search ...
819 haystack ... inside the haystack
820 co comparator to use
821 mt match type to use
822
823 Returns: 0 needle not found in haystack
824 1 needle found
825 -1 comparator does not offer matchtype
826 */
827
828 static int compare(struct Sieve *filter, const struct String *needle, const struct String *haystack,
829 enum Comparator co, enum MatchType mt)
830 {
831 int r=0;
832
833 if ((filter_test != FTEST_NONE && debug_selector != 0) ||
834 (debug_selector & D_filter) != 0)
835 {
836 debug_printf("String comparison (match ");
837 switch (mt)
838 {
839 case MATCH_IS: debug_printf(":is"); break;
840 case MATCH_CONTAINS: debug_printf(":contains"); break;
841 case MATCH_MATCHES: debug_printf(":matches"); break;
842 }
843 debug_printf(", comparison \"");
844 switch (co)
845 {
846 case COMP_OCTET: debug_printf("i;octet"); break;
847 case COMP_EN_ASCII_CASEMAP: debug_printf("en;ascii-casemap"); break;
848 case COMP_ASCII_NUMERIC: debug_printf("i;ascii-numeric"); break;
849 }
850 debug_printf("\"):\n");
851 debug_printf(" Search = %s (%d chars)\n", needle->character,needle->length);
852 debug_printf(" Inside = %s (%d chars)\n", haystack->character,haystack->length);
853 }
854 switch (mt)
855 {
856 case MATCH_IS:
857 switch (co)
858 {
859 case COMP_OCTET:
860 if (eq_octet(needle,haystack,0)) r=1;
861 break;
862 case COMP_EN_ASCII_CASEMAP:
863 if (eq_asciicase(needle,haystack,0)) r=1;
864 break;
865 case COMP_ASCII_NUMERIC:
866 if (!filter->require_iascii_numeric)
867 {
868 filter->errmsg=CUS "missing previous require \"comparator-i;ascii-numeric\";";
869 return -1;
870 }
871 if (eq_asciinumeric(needle,haystack,EQ)) r=1;
872 break;
873 }
874 break;
875
876 case MATCH_CONTAINS:
877 {
878 struct String h;
879
880 switch (co)
881 {
882 case COMP_OCTET:
883 for (h = *haystack; h.length; ++h.character,--h.length)
884 if (eq_octet(needle,&h,1)) { r=1; break; }
885 break;
886 case COMP_EN_ASCII_CASEMAP:
887 for (h = *haystack; h.length; ++h.character, --h.length)
888 if (eq_asciicase(needle,&h,1)) { r=1; break; }
889 break;
890 default:
891 filter->errmsg=CUS "comparator does not offer specified matchtype";
892 return -1;
893 }
894 break;
895 }
896
897 case MATCH_MATCHES:
898 switch (co)
899 {
900 case COMP_OCTET:
901 if ((r=eq_glob(needle,haystack,0,1))==-1)
902 {
903 filter->errmsg=CUS "syntactically invalid pattern";
904 return -1;
905 }
906 break;
907 case COMP_EN_ASCII_CASEMAP:
908 if ((r=eq_glob(needle,haystack,1,1))==-1)
909 {
910 filter->errmsg=CUS "syntactically invalid pattern";
911 return -1;
912 }
913 break;
914 default:
915 filter->errmsg=CUS "comparator does not offer specified matchtype";
916 return -1;
917 }
918 break;
919 }
920 if ((filter_test != FTEST_NONE && debug_selector != 0) ||
921 (debug_selector & D_filter) != 0)
922 debug_printf(" Result %s\n",r?"true":"false");
923 return r;
924 }
925
926
927 /*************************************************
928 * Check header field syntax *
929 *************************************************/
930
931 /*
932 RFC 2822, section 3.6.8 says:
933
934 field-name = 1*ftext
935
936 ftext = %d33-57 / ; Any character except
937 %d59-126 ; controls, SP, and
938 ; ":".
939
940 That forbids 8-bit header fields. This implementation accepts them, since
941 all of Exim is 8-bit clean, so it adds %d128-%d255.
942
943 Arguments:
944 header header field to quote for suitable use in Exim expansions
945
946 Returns: 0 string is not a valid header field
947 1 string is a value header field
948 */
949
950 static int is_header(const struct String *header)
951 {
952 size_t l;
953 const uschar *h;
954
955 l=header->length;
956 h=header->character;
957 if (l==0) return 0;
958 while (l)
959 {
960 if (((unsigned char)*h)<33 || ((unsigned char)*h)==':' || ((unsigned char)*h)==127) return 0;
961 else
962 {
963 ++h;
964 --l;
965 }
966 }
967 return 1;
968 }
969
970
971 /*************************************************
972 * Quote special characters string *
973 *************************************************/
974
975 /*
976 Arguments:
977 header header field to quote for suitable use in Exim expansions
978 or as debug output
979
980 Returns: quoted string
981 */
982
983 static const uschar *
984 quote(const struct String *header)
985 {
986 gstring * quoted = NULL;
987 size_t l;
988 const uschar *h;
989
990 l=header->length;
991 h=header->character;
992 while (l)
993 {
994 switch (*h)
995 {
996 case '\0':
997 quoted = string_catn(quoted, CUS "\\0", 2);
998 break;
999 case '$':
1000 case '{':
1001 case '}':
1002 quoted = string_catn(quoted, CUS "\\", 1);
1003 default:
1004 quoted = string_catn(quoted, h, 1);
1005 }
1006 ++h;
1007 --l;
1008 }
1009 quoted = string_catn(quoted, CUS "", 1);
1010 return string_from_gstring(quoted);
1011 }
1012
1013
1014 /*************************************************
1015 * Add address to list of generated addresses *
1016 *************************************************/
1017
1018 /*
1019 According to RFC 5228, duplicate delivery to the same address must
1020 not happen, so the list is first searched for the address.
1021
1022 Arguments:
1023 generated list of generated addresses
1024 addr new address to add
1025 file address denotes a file
1026
1027 Returns: nothing
1028 */
1029
1030 static void
1031 add_addr(address_item **generated, uschar *addr, int file, int maxage, int maxmessages, int maxstorage)
1032 {
1033 address_item *new_addr;
1034
1035 for (new_addr = *generated; new_addr; new_addr = new_addr->next)
1036 if ( Ustrcmp(new_addr->address,addr) == 0
1037 && ( !file
1038 || testflag(new_addr, af_pfr)
1039 || testflag(new_addr, af_file)
1040 )
1041 )
1042 {
1043 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
1044 debug_printf("Repeated %s `%s' ignored.\n",file ? "fileinto" : "redirect", addr);
1045
1046 return;
1047 }
1048
1049 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
1050 debug_printf("%s `%s'\n",file ? "fileinto" : "redirect", addr);
1051
1052 new_addr = deliver_make_addr(addr,TRUE);
1053 if (file)
1054 {
1055 setflag(new_addr, af_pfr);
1056 setflag(new_addr, af_file);
1057 new_addr->mode = 0;
1058 }
1059 new_addr->prop.errors_address = NULL;
1060 new_addr->next = *generated;
1061 *generated = new_addr;
1062 }
1063
1064
1065 /*************************************************
1066 * Return decoded header field *
1067 *************************************************/
1068
1069 /*
1070 Unfold the header field as described in RFC 2822 and remove all
1071 leading and trailing white space, then perform MIME decoding and
1072 translate the header field to UTF-8.
1073
1074 Arguments:
1075 value returned value of the field
1076 header name of the header field
1077
1078 Returns: nothing The expanded string is empty
1079 in case there is no such header
1080 */
1081
1082 static void expand_header(struct String *value, const struct String *header)
1083 {
1084 uschar *s,*r,*t;
1085 uschar *errmsg;
1086
1087 value->length=0;
1088 value->character=(uschar*)0;
1089
1090 t=r=s=expand_string(string_sprintf("$rheader_%s",quote(header)));
1091 while (*r==' ' || *r=='\t') ++r;
1092 while (*r)
1093 {
1094 if (*r=='\n')
1095 ++r;
1096 else
1097 *t++=*r++;
1098 }
1099 while (t>s && (*(t-1)==' ' || *(t-1)=='\t')) --t;
1100 *t='\0';
1101 value->character=rfc2047_decode(s,check_rfc2047_length,US"utf-8",'\0',&value->length,&errmsg);
1102 }
1103
1104
1105 /*************************************************
1106 * Parse remaining hash comment *
1107 *************************************************/
1108
1109 /*
1110 Token definition:
1111 Comment up to terminating CRLF
1112
1113 Arguments:
1114 filter points to the Sieve filter including its state
1115
1116 Returns: 1 success
1117 -1 syntax error
1118 */
1119
1120 static int parse_hashcomment(struct Sieve *filter)
1121 {
1122 ++filter->pc;
1123 while (*filter->pc)
1124 {
1125 #ifdef RFC_EOL
1126 if (*filter->pc=='\r' && *(filter->pc+1)=='\n')
1127 #else
1128 if (*filter->pc=='\n')
1129 #endif
1130 {
1131 #ifdef RFC_EOL
1132 filter->pc+=2;
1133 #else
1134 ++filter->pc;
1135 #endif
1136 ++filter->line;
1137 return 1;
1138 }
1139 else ++filter->pc;
1140 }
1141 filter->errmsg=CUS "missing end of comment";
1142 return -1;
1143 }
1144
1145
1146 /*************************************************
1147 * Parse remaining C-style comment *
1148 *************************************************/
1149
1150 /*
1151 Token definition:
1152 Everything up to star slash
1153
1154 Arguments:
1155 filter points to the Sieve filter including its state
1156
1157 Returns: 1 success
1158 -1 syntax error
1159 */
1160
1161 static int parse_comment(struct Sieve *filter)
1162 {
1163 filter->pc+=2;
1164 while (*filter->pc)
1165 {
1166 if (*filter->pc=='*' && *(filter->pc+1)=='/')
1167 {
1168 filter->pc+=2;
1169 return 1;
1170 }
1171 else ++filter->pc;
1172 }
1173 filter->errmsg=CUS "missing end of comment";
1174 return -1;
1175 }
1176
1177
1178 /*************************************************
1179 * Parse optional white space *
1180 *************************************************/
1181
1182 /*
1183 Token definition:
1184 Spaces, tabs, CRLFs, hash comments or C-style comments
1185
1186 Arguments:
1187 filter points to the Sieve filter including its state
1188
1189 Returns: 1 success
1190 -1 syntax error
1191 */
1192
1193 static int parse_white(struct Sieve *filter)
1194 {
1195 while (*filter->pc)
1196 {
1197 if (*filter->pc==' ' || *filter->pc=='\t') ++filter->pc;
1198 #ifdef RFC_EOL
1199 else if (*filter->pc=='\r' && *(filter->pc+1)=='\n')
1200 #else
1201 else if (*filter->pc=='\n')
1202 #endif
1203 {
1204 #ifdef RFC_EOL
1205 filter->pc+=2;
1206 #else
1207 ++filter->pc;
1208 #endif
1209 ++filter->line;
1210 }
1211 else if (*filter->pc=='#')
1212 {
1213 if (parse_hashcomment(filter)==-1) return -1;
1214 }
1215 else if (*filter->pc=='/' && *(filter->pc+1)=='*')
1216 {
1217 if (parse_comment(filter)==-1) return -1;
1218 }
1219 else break;
1220 }
1221 return 1;
1222 }
1223
1224
1225 #ifdef ENCODED_CHARACTER
1226 /*************************************************
1227 * Decode hex-encoded-character string *
1228 *************************************************/
1229
1230 /*
1231 Encoding definition:
1232 blank = SP / TAB / CRLF
1233 hex-pair-seq = *blank hex-pair *(1*blank hex-pair) *blank
1234 hex-pair = 1*2HEXDIG
1235
1236 Arguments:
1237 src points to a hex-pair-seq
1238 end points to its end
1239 dst points to the destination of the decoded octets,
1240 optionally to (uschar*)0 for checking only
1241
1242 Returns: >=0 number of decoded octets
1243 -1 syntax error
1244 */
1245
1246 static int hex_decode(uschar *src, uschar *end, uschar *dst)
1247 {
1248 int decoded=0;
1249
1250 while (*src==' ' || *src=='\t' || *src=='\n') ++src;
1251 do
1252 {
1253 int x,d,n;
1254
1255 for (x = 0, d = 0;
1256 d<2 && src<end && isxdigit(n=tolower(*src));
1257 x=(x<<4)|(n>='0' && n<='9' ? n-'0' : 10+(n-'a')) ,++d, ++src) ;
1258 if (d==0) return -1;
1259 if (dst) *dst++=x;
1260 ++decoded;
1261 if (src==end) return decoded;
1262 if (*src==' ' || *src=='\t' || *src=='\n')
1263 while (*src==' ' || *src=='\t' || *src=='\n') ++src;
1264 else
1265 return -1;
1266 }
1267 while (src<end);
1268 return decoded;
1269 }
1270
1271
1272 /*************************************************
1273 * Decode unicode-encoded-character string *
1274 *************************************************/
1275
1276 /*
1277 Encoding definition:
1278 blank = SP / TAB / CRLF
1279 unicode-hex-seq = *blank unicode-hex *(blank unicode-hex) *blank
1280 unicode-hex = 1*HEXDIG
1281
1282 It is an error for a script to use a hexadecimal value that isn't in
1283 either the range 0 to D7FF or the range E000 to 10FFFF.
1284
1285 At this time, strings are already scanned, thus the CRLF is converted
1286 to the internally used \n (should RFC_EOL have been used).
1287
1288 Arguments:
1289 src points to a unicode-hex-seq
1290 end points to its end
1291 dst points to the destination of the decoded octets,
1292 optionally to (uschar*)0 for checking only
1293
1294 Returns: >=0 number of decoded octets
1295 -1 syntax error
1296 -2 semantic error (character range violation)
1297 */
1298
1299 static int
1300 unicode_decode(uschar *src, uschar *end, uschar *dst)
1301 {
1302 int decoded=0;
1303
1304 while (*src==' ' || *src=='\t' || *src=='\n') ++src;
1305 do
1306 {
1307 uschar *hex_seq;
1308 int c,d,n;
1309
1310 unicode_hex:
1311 for (hex_seq = src; src < end && *src=='0'; ) src++;
1312 for (c = 0, d = 0;
1313 d < 7 && src < end && isxdigit(n=tolower(*src));
1314 c=(c<<4)|(n>='0' && n<='9' ? n-'0' : 10+(n-'a')), ++d, ++src) ;
1315 if (src == hex_seq) return -1;
1316 if (d==7 || (!((c>=0 && c<=0xd7ff) || (c>=0xe000 && c<=0x10ffff)))) return -2;
1317 if (c<128)
1318 {
1319 if (dst) *dst++=c;
1320 ++decoded;
1321 }
1322 else if (c>=0x80 && c<=0x7ff)
1323 {
1324 if (dst)
1325 {
1326 *dst++=192+(c>>6);
1327 *dst++=128+(c&0x3f);
1328 }
1329 decoded+=2;
1330 }
1331 else if (c>=0x800 && c<=0xffff)
1332 {
1333 if (dst)
1334 {
1335 *dst++=224+(c>>12);
1336 *dst++=128+((c>>6)&0x3f);
1337 *dst++=128+(c&0x3f);
1338 }
1339 decoded+=3;
1340 }
1341 else if (c>=0x10000 && c<=0x1fffff)
1342 {
1343 if (dst)
1344 {
1345 *dst++=240+(c>>18);
1346 *dst++=128+((c>>10)&0x3f);
1347 *dst++=128+((c>>6)&0x3f);
1348 *dst++=128+(c&0x3f);
1349 }
1350 decoded+=4;
1351 }
1352 if (*src==' ' || *src=='\t' || *src=='\n')
1353 {
1354 while (*src==' ' || *src=='\t' || *src=='\n') ++src;
1355 if (src==end) return decoded;
1356 goto unicode_hex;
1357 }
1358 }
1359 while (src<end);
1360 return decoded;
1361 }
1362
1363
1364 /*************************************************
1365 * Decode encoded-character string *
1366 *************************************************/
1367
1368 /*
1369 Encoding definition:
1370 encoded-arb-octets = "${hex:" hex-pair-seq "}"
1371 encoded-unicode-char = "${unicode:" unicode-hex-seq "}"
1372
1373 Arguments:
1374 encoded points to an encoded string, returns decoded string
1375 filter points to the Sieve filter including its state
1376
1377 Returns: 1 success
1378 -1 syntax error
1379 */
1380
1381 static int string_decode(struct Sieve *filter, struct String *data)
1382 {
1383 uschar *src,*dst,*end;
1384
1385 src=data->character;
1386 dst=src;
1387 end=data->character+data->length;
1388 while (src<end)
1389 {
1390 uschar *brace;
1391
1392 if (
1393 strncmpic(src,US "${hex:",6)==0
1394 && (brace=Ustrchr(src+6,'}'))!=(uschar*)0
1395 && (hex_decode(src+6,brace,(uschar*)0))>=0
1396 )
1397 {
1398 dst+=hex_decode(src+6,brace,dst);
1399 src=brace+1;
1400 }
1401 else if (
1402 strncmpic(src,US "${unicode:",10)==0
1403 && (brace=Ustrchr(src+10,'}'))!=(uschar*)0
1404 )
1405 {
1406 switch (unicode_decode(src+10,brace,(uschar*)0))
1407 {
1408 case -2:
1409 {
1410 filter->errmsg=CUS "unicode character out of range";
1411 return -1;
1412 }
1413 case -1:
1414 {
1415 *dst++=*src++;
1416 break;
1417 }
1418 default:
1419 {
1420 dst+=unicode_decode(src+10,brace,dst);
1421 src=brace+1;
1422 }
1423 }
1424 }
1425 else *dst++=*src++;
1426 }
1427 data->length=dst-data->character;
1428 *dst='\0';
1429 return 1;
1430 }
1431 #endif
1432
1433
1434 /*************************************************
1435 * Parse an optional string *
1436 *************************************************/
1437
1438 /*
1439 Token definition:
1440 quoted-string = DQUOTE *CHAR DQUOTE
1441 ;; in general, \ CHAR inside a string maps to CHAR
1442 ;; so \" maps to " and \\ maps to \
1443 ;; note that newlines and other characters are all allowed
1444 ;; in strings
1445
1446 multi-line = "text:" *(SP / HTAB) (hash-comment / CRLF)
1447 *(multi-line-literal / multi-line-dotstuff)
1448 "." CRLF
1449 multi-line-literal = [CHAR-NOT-DOT *CHAR-NOT-CRLF] CRLF
1450 multi-line-dotstuff = "." 1*CHAR-NOT-CRLF CRLF
1451 ;; A line containing only "." ends the multi-line.
1452 ;; Remove a leading '.' if followed by another '.'.
1453 string = quoted-string / multi-line
1454
1455 Arguments:
1456 filter points to the Sieve filter including its state
1457 id specifies identifier to match
1458
1459 Returns: 1 success
1460 -1 syntax error
1461 0 identifier not matched
1462 */
1463
1464 static int
1465 parse_string(struct Sieve *filter, struct String *data)
1466 {
1467 gstring * g = NULL;
1468
1469 data->length = 0;
1470 data->character = NULL;
1471
1472 if (*filter->pc=='"') /* quoted string */
1473 {
1474 ++filter->pc;
1475 while (*filter->pc)
1476 {
1477 if (*filter->pc=='"') /* end of string */
1478 {
1479 ++filter->pc;
1480
1481 if (g)
1482 {
1483 data->character = string_from_gstring(g);
1484 data->length = g->ptr;
1485 }
1486 else
1487 data->character = US"\0";
1488 /* that way, there will be at least one character allocated */
1489
1490 #ifdef ENCODED_CHARACTER
1491 if (filter->require_encoded_character
1492 && string_decode(filter,data)==-1)
1493 return -1;
1494 #endif
1495 return 1;
1496 }
1497 else if (*filter->pc=='\\' && *(filter->pc+1)) /* quoted character */
1498 {
1499 g = string_catn(g, filter->pc+1, 1);
1500 filter->pc+=2;
1501 }
1502 else /* regular character */
1503 {
1504 #ifdef RFC_EOL
1505 if (*filter->pc=='\r' && *(filter->pc+1)=='\n') ++filter->line;
1506 #else
1507 if (*filter->pc=='\n')
1508 {
1509 g = string_catn(g, US"\r", 1);
1510 ++filter->line;
1511 }
1512 #endif
1513 g = string_catn(g, filter->pc, 1);
1514 filter->pc++;
1515 }
1516 }
1517 filter->errmsg=CUS "missing end of string";
1518 return -1;
1519 }
1520 else if (Ustrncmp(filter->pc,CUS "text:",5)==0) /* multiline string */
1521 {
1522 filter->pc+=5;
1523 /* skip optional white space followed by hashed comment or CRLF */
1524 while (*filter->pc==' ' || *filter->pc=='\t') ++filter->pc;
1525 if (*filter->pc=='#')
1526 {
1527 if (parse_hashcomment(filter)==-1) return -1;
1528 }
1529 #ifdef RFC_EOL
1530 else if (*filter->pc=='\r' && *(filter->pc+1)=='\n')
1531 #else
1532 else if (*filter->pc=='\n')
1533 #endif
1534 {
1535 #ifdef RFC_EOL
1536 filter->pc+=2;
1537 #else
1538 ++filter->pc;
1539 #endif
1540 ++filter->line;
1541 }
1542 else
1543 {
1544 filter->errmsg=CUS "syntax error";
1545 return -1;
1546 }
1547 while (*filter->pc)
1548 {
1549 #ifdef RFC_EOL
1550 if (*filter->pc=='\r' && *(filter->pc+1)=='\n') /* end of line */
1551 #else
1552 if (*filter->pc=='\n') /* end of line */
1553 #endif
1554 {
1555 g = string_catn(g, CUS "\r\n", 2);
1556 #ifdef RFC_EOL
1557 filter->pc+=2;
1558 #else
1559 ++filter->pc;
1560 #endif
1561 ++filter->line;
1562 #ifdef RFC_EOL
1563 if (*filter->pc=='.' && *(filter->pc+1)=='\r' && *(filter->pc+2)=='\n') /* end of string */
1564 #else
1565 if (*filter->pc=='.' && *(filter->pc+1)=='\n') /* end of string */
1566 #endif
1567 {
1568 if (g)
1569 {
1570 data->character = string_from_gstring(g);
1571 data->length = g->ptr;
1572 }
1573 else
1574 data->character = US"\0";
1575 /* that way, there will be at least one character allocated */
1576
1577 #ifdef RFC_EOL
1578 filter->pc+=3;
1579 #else
1580 filter->pc+=2;
1581 #endif
1582 ++filter->line;
1583 #ifdef ENCODED_CHARACTER
1584 if (filter->require_encoded_character
1585 && string_decode(filter,data)==-1)
1586 return -1;
1587 #endif
1588 return 1;
1589 }
1590 else if (*filter->pc=='.' && *(filter->pc+1)=='.') /* remove dot stuffing */
1591 {
1592 g = string_catn(g, CUS ".", 1);
1593 filter->pc+=2;
1594 }
1595 }
1596 else /* regular character */
1597 {
1598 g = string_catn(g, filter->pc, 1);
1599 filter->pc++;
1600 }
1601 }
1602 filter->errmsg=CUS "missing end of multi line string";
1603 return -1;
1604 }
1605 else return 0;
1606 }
1607
1608
1609 /*************************************************
1610 * Parse a specific identifier *
1611 *************************************************/
1612
1613 /*
1614 Token definition:
1615 identifier = (ALPHA / "_") *(ALPHA DIGIT "_")
1616
1617 Arguments:
1618 filter points to the Sieve filter including its state
1619 id specifies identifier to match
1620
1621 Returns: 1 success
1622 0 identifier not matched
1623 */
1624
1625 static int parse_identifier(struct Sieve *filter, const uschar *id)
1626 {
1627 size_t idlen=Ustrlen(id);
1628
1629 if (strncmpic(US filter->pc,US id,idlen)==0)
1630 {
1631 uschar next=filter->pc[idlen];
1632
1633 if ((next>='A' && next<='Z') || (next>='a' && next<='z') || next=='_' || (next>='0' && next<='9')) return 0;
1634 filter->pc+=idlen;
1635 return 1;
1636 }
1637 else return 0;
1638 }
1639
1640
1641 /*************************************************
1642 * Parse a number *
1643 *************************************************/
1644
1645 /*
1646 Token definition:
1647 number = 1*DIGIT [QUANTIFIER]
1648 QUANTIFIER = "K" / "M" / "G"
1649
1650 Arguments:
1651 filter points to the Sieve filter including its state
1652 data returns value
1653
1654 Returns: 1 success
1655 -1 no string list found
1656 */
1657
1658 static int parse_number(struct Sieve *filter, unsigned long *data)
1659 {
1660 unsigned long d,u;
1661
1662 if (*filter->pc>='0' && *filter->pc<='9')
1663 {
1664 uschar *e;
1665
1666 errno=0;
1667 d=Ustrtoul(filter->pc,&e,10);
1668 if (errno==ERANGE)
1669 {
1670 filter->errmsg=CUstrerror(ERANGE);
1671 return -1;
1672 }
1673 filter->pc=e;
1674 u=1;
1675 if (*filter->pc=='K') { u=1024; ++filter->pc; }
1676 else if (*filter->pc=='M') { u=1024*1024; ++filter->pc; }
1677 else if (*filter->pc=='G') { u=1024*1024*1024; ++filter->pc; }
1678 if (d>(ULONG_MAX/u))
1679 {
1680 filter->errmsg=CUstrerror(ERANGE);
1681 return -1;
1682 }
1683 d*=u;
1684 *data=d;
1685 return 1;
1686 }
1687 else
1688 {
1689 filter->errmsg=CUS "missing number";
1690 return -1;
1691 }
1692 }
1693
1694
1695 /*************************************************
1696 * Parse a string list *
1697 *************************************************/
1698
1699 /*
1700 Grammar:
1701 string-list = "[" string *("," string) "]" / string
1702
1703 Arguments:
1704 filter points to the Sieve filter including its state
1705 data returns string list
1706
1707 Returns: 1 success
1708 -1 no string list found
1709 */
1710
1711 static int
1712 parse_stringlist(struct Sieve *filter, struct String **data)
1713 {
1714 const uschar *orig=filter->pc;
1715 int dataCapacity = 0;
1716 int dataLength = 0;
1717 struct String *d = NULL;
1718 int m;
1719
1720 if (*filter->pc=='[') /* string list */
1721 {
1722 ++filter->pc;
1723 for (;;)
1724 {
1725 if (parse_white(filter)==-1) goto error;
1726 if (dataLength+1 >= dataCapacity) /* increase buffer */
1727 {
1728 struct String *new;
1729
1730 dataCapacity = dataCapacity ? dataCapacity * 2 : 4;
1731 new = store_get(sizeof(struct String) * dataCapacity);
1732
1733 if (d) memcpy(new,d,sizeof(struct String)*dataLength);
1734 d = new;
1735 }
1736
1737 m=parse_string(filter,&d[dataLength]);
1738 if (m==0)
1739 {
1740 if (dataLength==0) break;
1741 else
1742 {
1743 filter->errmsg=CUS "missing string";
1744 goto error;
1745 }
1746 }
1747 else if (m==-1) goto error;
1748 else ++dataLength;
1749 if (parse_white(filter)==-1) goto error;
1750 if (*filter->pc==',') ++filter->pc;
1751 else break;
1752 }
1753 if (*filter->pc==']')
1754 {
1755 d[dataLength].character=(uschar*)0;
1756 d[dataLength].length=-1;
1757 ++filter->pc;
1758 *data=d;
1759 return 1;
1760 }
1761 else
1762 {
1763 filter->errmsg=CUS "missing closing bracket";
1764 goto error;
1765 }
1766 }
1767 else /* single string */
1768 {
1769 if ((d=store_get(sizeof(struct String)*2))==(struct String*)0)
1770 {
1771 return -1;
1772 }
1773 m=parse_string(filter,&d[0]);
1774 if (m==-1)
1775 {
1776 return -1;
1777 }
1778 else if (m==0)
1779 {
1780 filter->pc=orig;
1781 return 0;
1782 }
1783 else
1784 {
1785 d[1].character=(uschar*)0;
1786 d[1].length=-1;
1787 *data=d;
1788 return 1;
1789 }
1790 }
1791 error:
1792 filter->errmsg=CUS "missing string list";
1793 return -1;
1794 }
1795
1796
1797 /*************************************************
1798 * Parse an optional address part specifier *
1799 *************************************************/
1800
1801 /*
1802 Grammar:
1803 address-part = ":localpart" / ":domain" / ":all"
1804 address-part =/ ":user" / ":detail"
1805
1806 Arguments:
1807 filter points to the Sieve filter including its state
1808 a returns address part specified
1809
1810 Returns: 1 success
1811 0 no comparator found
1812 -1 syntax error
1813 */
1814
1815 static int parse_addresspart(struct Sieve *filter, enum AddressPart *a)
1816 {
1817 #ifdef SUBADDRESS
1818 if (parse_identifier(filter,CUS ":user")==1)
1819 {
1820 if (!filter->require_subaddress)
1821 {
1822 filter->errmsg=CUS "missing previous require \"subaddress\";";
1823 return -1;
1824 }
1825 *a=ADDRPART_USER;
1826 return 1;
1827 }
1828 else if (parse_identifier(filter,CUS ":detail")==1)
1829 {
1830 if (!filter->require_subaddress)
1831 {
1832 filter->errmsg=CUS "missing previous require \"subaddress\";";
1833 return -1;
1834 }
1835 *a=ADDRPART_DETAIL;
1836 return 1;
1837 }
1838 else
1839 #endif
1840 if (parse_identifier(filter,CUS ":localpart")==1)
1841 {
1842 *a=ADDRPART_LOCALPART;
1843 return 1;
1844 }
1845 else if (parse_identifier(filter,CUS ":domain")==1)
1846 {
1847 *a=ADDRPART_DOMAIN;
1848 return 1;
1849 }
1850 else if (parse_identifier(filter,CUS ":all")==1)
1851 {
1852 *a=ADDRPART_ALL;
1853 return 1;
1854 }
1855 else return 0;
1856 }
1857
1858
1859 /*************************************************
1860 * Parse an optional comparator *
1861 *************************************************/
1862
1863 /*
1864 Grammar:
1865 comparator = ":comparator" <comparator-name: string>
1866
1867 Arguments:
1868 filter points to the Sieve filter including its state
1869 c returns comparator
1870
1871 Returns: 1 success
1872 0 no comparator found
1873 -1 incomplete comparator found
1874 */
1875
1876 static int parse_comparator(struct Sieve *filter, enum Comparator *c)
1877 {
1878 struct String comparator_name;
1879
1880 if (parse_identifier(filter,CUS ":comparator")==0) return 0;
1881 if (parse_white(filter)==-1) return -1;
1882 switch (parse_string(filter,&comparator_name))
1883 {
1884 case -1: return -1;
1885 case 0:
1886 {
1887 filter->errmsg=CUS "missing comparator";
1888 return -1;
1889 }
1890 default:
1891 {
1892 int match;
1893
1894 if (eq_asciicase(&comparator_name,&str_ioctet,0))
1895 {
1896 *c=COMP_OCTET;
1897 match=1;
1898 }
1899 else if (eq_asciicase(&comparator_name,&str_iascii_casemap,0))
1900 {
1901 *c=COMP_EN_ASCII_CASEMAP;
1902 match=1;
1903 }
1904 else if (eq_asciicase(&comparator_name,&str_enascii_casemap,0))
1905 {
1906 *c=COMP_EN_ASCII_CASEMAP;
1907 match=1;
1908 }
1909 else if (eq_asciicase(&comparator_name,&str_iascii_numeric,0))
1910 {
1911 *c=COMP_ASCII_NUMERIC;
1912 match=1;
1913 }
1914 else
1915 {
1916 filter->errmsg=CUS "invalid comparator";
1917 match=-1;
1918 }
1919 return match;
1920 }
1921 }
1922 }
1923
1924
1925 /*************************************************
1926 * Parse an optional match type *
1927 *************************************************/
1928
1929 /*
1930 Grammar:
1931 match-type = ":is" / ":contains" / ":matches"
1932
1933 Arguments:
1934 filter points to the Sieve filter including its state
1935 m returns match type
1936
1937 Returns: 1 success
1938 0 no match type found
1939 */
1940
1941 static int parse_matchtype(struct Sieve *filter, enum MatchType *m)
1942 {
1943 if (parse_identifier(filter,CUS ":is")==1)
1944 {
1945 *m=MATCH_IS;
1946 return 1;
1947 }
1948 else if (parse_identifier(filter,CUS ":contains")==1)
1949 {
1950 *m=MATCH_CONTAINS;
1951 return 1;
1952 }
1953 else if (parse_identifier(filter,CUS ":matches")==1)
1954 {
1955 *m=MATCH_MATCHES;
1956 return 1;
1957 }
1958 else return 0;
1959 }
1960
1961
1962 /*************************************************
1963 * Parse and interpret an optional test list *
1964 *************************************************/
1965
1966 /*
1967 Grammar:
1968 test-list = "(" test *("," test) ")"
1969
1970 Arguments:
1971 filter points to the Sieve filter including its state
1972 n total number of tests
1973 num_true number of passed tests
1974 exec Execute parsed statements
1975
1976 Returns: 1 success
1977 0 no test list found
1978 -1 syntax or execution error
1979 */
1980
1981 static int parse_testlist(struct Sieve *filter, int *n, int *num_true, int exec)
1982 {
1983 if (parse_white(filter)==-1) return -1;
1984 if (*filter->pc=='(')
1985 {
1986 ++filter->pc;
1987 *n=0;
1988 *num_true=0;
1989 for (;;)
1990 {
1991 int cond;
1992
1993 switch (parse_test(filter,&cond,exec))
1994 {
1995 case -1: return -1;
1996 case 0: filter->errmsg=CUS "missing test"; return -1;
1997 default: ++*n; if (cond) ++*num_true; break;
1998 }
1999 if (parse_white(filter)==-1) return -1;
2000 if (*filter->pc==',') ++filter->pc;
2001 else break;
2002 }
2003 if (*filter->pc==')')
2004 {
2005 ++filter->pc;
2006 return 1;
2007 }
2008 else
2009 {
2010 filter->errmsg=CUS "missing closing paren";
2011 return -1;
2012 }
2013 }
2014 else return 0;
2015 }
2016
2017
2018 /*************************************************
2019 * Parse and interpret an optional test *
2020 *************************************************/
2021
2022 /*
2023 Arguments:
2024 filter points to the Sieve filter including its state
2025 cond returned condition status
2026 exec Execute parsed statements
2027
2028 Returns: 1 success
2029 0 no test found
2030 -1 syntax or execution error
2031 */
2032
2033 static int
2034 parse_test(struct Sieve *filter, int *cond, int exec)
2035 {
2036 if (parse_white(filter)==-1) return -1;
2037 if (parse_identifier(filter,CUS "address"))
2038 {
2039 /*
2040 address-test = "address" { [address-part] [comparator] [match-type] }
2041 <header-list: string-list> <key-list: string-list>
2042
2043 header-list From, To, Cc, Bcc, Sender, Resent-From, Resent-To
2044 */
2045
2046 enum AddressPart addressPart=ADDRPART_ALL;
2047 enum Comparator comparator=COMP_EN_ASCII_CASEMAP;
2048 enum MatchType matchType=MATCH_IS;
2049 struct String *hdr,*key;
2050 int m;
2051 int ap=0,co=0,mt=0;
2052
2053 for (;;)
2054 {
2055 if (parse_white(filter)==-1) return -1;
2056 if ((m=parse_addresspart(filter,&addressPart))!=0)
2057 {
2058 if (m==-1) return -1;
2059 if (ap)
2060 {
2061 filter->errmsg=CUS "address part already specified";
2062 return -1;
2063 }
2064 else ap=1;
2065 }
2066 else if ((m=parse_comparator(filter,&comparator))!=0)
2067 {
2068 if (m==-1) return -1;
2069 if (co)
2070 {
2071 filter->errmsg=CUS "comparator already specified";
2072 return -1;
2073 }
2074 else co=1;
2075 }
2076 else if ((m=parse_matchtype(filter,&matchType))!=0)
2077 {
2078 if (m==-1) return -1;
2079 if (mt)
2080 {
2081 filter->errmsg=CUS "match type already specified";
2082 return -1;
2083 }
2084 else mt=1;
2085 }
2086 else break;
2087 }
2088 if (parse_white(filter)==-1) return -1;
2089 if ((m=parse_stringlist(filter,&hdr))!=1)
2090 {
2091 if (m==0) filter->errmsg=CUS "header string list expected";
2092 return -1;
2093 }
2094 if (parse_white(filter)==-1) return -1;
2095 if ((m=parse_stringlist(filter,&key))!=1)
2096 {
2097 if (m==0) filter->errmsg=CUS "key string list expected";
2098 return -1;
2099 }
2100 *cond=0;
2101 for (struct String * h = hdr; h->length!=-1 && !*cond; ++h)
2102 {
2103 uschar *header_value=(uschar*)0,*extracted_addr,*end_addr;
2104
2105 if
2106 (
2107 !eq_asciicase(h,&str_from,0)
2108 && !eq_asciicase(h,&str_to,0)
2109 && !eq_asciicase(h,&str_cc,0)
2110 && !eq_asciicase(h,&str_bcc,0)
2111 && !eq_asciicase(h,&str_sender,0)
2112 && !eq_asciicase(h,&str_resent_from,0)
2113 && !eq_asciicase(h,&str_resent_to,0)
2114 )
2115 {
2116 filter->errmsg=CUS "invalid header field";
2117 return -1;
2118 }
2119 if (exec)
2120 {
2121 /* We are only interested in addresses below, so no MIME decoding */
2122 header_value=expand_string(string_sprintf("$rheader_%s",quote(h)));
2123 if (header_value == NULL)
2124 {
2125 filter->errmsg=CUS "header string expansion failed";
2126 return -1;
2127 }
2128 f.parse_allow_group = TRUE;
2129 while (*header_value && !*cond)
2130 {
2131 uschar *error;
2132 int start, end, domain;
2133 int saveend;
2134 uschar *part=NULL;
2135
2136 end_addr = parse_find_address_end(header_value, FALSE);
2137 saveend = *end_addr;
2138 *end_addr = 0;
2139 extracted_addr = parse_extract_address(header_value, &error, &start, &end, &domain, FALSE);
2140
2141 if (extracted_addr) switch (addressPart)
2142 {
2143 case ADDRPART_ALL: part=extracted_addr; break;
2144 #ifdef SUBADDRESS
2145 case ADDRPART_USER:
2146 #endif
2147 case ADDRPART_LOCALPART: part=extracted_addr; part[domain-1]='\0'; break;
2148 case ADDRPART_DOMAIN: part=extracted_addr+domain; break;
2149 #ifdef SUBADDRESS
2150 case ADDRPART_DETAIL: part=NULL; break;
2151 #endif
2152 }
2153
2154 *end_addr = saveend;
2155 if (part)
2156 {
2157 for (struct String * k = key; k->length !=- 1; ++k)
2158 {
2159 struct String partStr = {.character = part, .length = Ustrlen(part)};
2160
2161 if (extracted_addr)
2162 {
2163 *cond=compare(filter,k,&partStr,comparator,matchType);
2164 if (*cond==-1) return -1;
2165 if (*cond) break;
2166 }
2167 }
2168 }
2169 if (saveend == 0) break;
2170 header_value = end_addr + 1;
2171 }
2172 f.parse_allow_group = FALSE;
2173 f.parse_found_group = FALSE;
2174 }
2175 }
2176 return 1;
2177 }
2178 else if (parse_identifier(filter,CUS "allof"))
2179 {
2180 /*
2181 allof-test = "allof" <tests: test-list>
2182 */
2183
2184 int n,num_true;
2185
2186 switch (parse_testlist(filter,&n,&num_true,exec))
2187 {
2188 case -1: return -1;
2189 case 0: filter->errmsg=CUS "missing test list"; return -1;
2190 default: *cond=(n==num_true); return 1;
2191 }
2192 }
2193 else if (parse_identifier(filter,CUS "anyof"))
2194 {
2195 /*
2196 anyof-test = "anyof" <tests: test-list>
2197 */
2198
2199 int n,num_true;
2200
2201 switch (parse_testlist(filter,&n,&num_true,exec))
2202 {
2203 case -1: return -1;
2204 case 0: filter->errmsg=CUS "missing test list"; return -1;
2205 default: *cond=(num_true>0); return 1;
2206 }
2207 }
2208 else if (parse_identifier(filter,CUS "exists"))
2209 {
2210 /*
2211 exists-test = "exists" <header-names: string-list>
2212 */
2213
2214 struct String *hdr;
2215 int m;
2216
2217 if (parse_white(filter)==-1) return -1;
2218 if ((m=parse_stringlist(filter,&hdr))!=1)
2219 {
2220 if (m==0) filter->errmsg=CUS "header string list expected";
2221 return -1;
2222 }
2223 if (exec)
2224 {
2225 *cond=1;
2226 for (struct String * h = hdr; h->length != -1 && *cond; ++h)
2227 {
2228 uschar *header_def;
2229
2230 header_def=expand_string(string_sprintf("${if def:header_%s {true}{false}}",quote(h)));
2231 if (header_def == NULL)
2232 {
2233 filter->errmsg=CUS "header string expansion failed";
2234 return -1;
2235 }
2236 if (Ustrcmp(header_def,"false")==0) *cond=0;
2237 }
2238 }
2239 return 1;
2240 }
2241 else if (parse_identifier(filter,CUS "false"))
2242 {
2243 /*
2244 false-test = "false"
2245 */
2246
2247 *cond=0;
2248 return 1;
2249 }
2250 else if (parse_identifier(filter,CUS "header"))
2251 {
2252 /*
2253 header-test = "header" { [comparator] [match-type] }
2254 <header-names: string-list> <key-list: string-list>
2255 */
2256
2257 enum Comparator comparator=COMP_EN_ASCII_CASEMAP;
2258 enum MatchType matchType=MATCH_IS;
2259 struct String *hdr,*key;
2260 int m;
2261 int co=0,mt=0;
2262
2263 for (;;)
2264 {
2265 if (parse_white(filter)==-1) return -1;
2266 if ((m=parse_comparator(filter,&comparator))!=0)
2267 {
2268 if (m==-1) return -1;
2269 if (co)
2270 {
2271 filter->errmsg=CUS "comparator already specified";
2272 return -1;
2273 }
2274 else co=1;
2275 }
2276 else if ((m=parse_matchtype(filter,&matchType))!=0)
2277 {
2278 if (m==-1) return -1;
2279 if (mt)
2280 {
2281 filter->errmsg=CUS "match type already specified";
2282 return -1;
2283 }
2284 else mt=1;
2285 }
2286 else break;
2287 }
2288 if (parse_white(filter)==-1) return -1;
2289 if ((m=parse_stringlist(filter,&hdr))!=1)
2290 {
2291 if (m==0) filter->errmsg=CUS "header string list expected";
2292 return -1;
2293 }
2294 if (parse_white(filter)==-1) return -1;
2295 if ((m=parse_stringlist(filter,&key))!=1)
2296 {
2297 if (m==0) filter->errmsg=CUS "key string list expected";
2298 return -1;
2299 }
2300 *cond=0;
2301 for (struct String * h = hdr; h->length != -1 && !*cond; ++h)
2302 {
2303 if (!is_header(h))
2304 {
2305 filter->errmsg=CUS "invalid header field";
2306 return -1;
2307 }
2308 if (exec)
2309 {
2310 struct String header_value;
2311 uschar *header_def;
2312
2313 expand_header(&header_value,h);
2314 header_def=expand_string(string_sprintf("${if def:header_%s {true}{false}}",quote(h)));
2315 if (header_value.character == NULL || header_def == NULL)
2316 {
2317 filter->errmsg=CUS "header string expansion failed";
2318 return -1;
2319 }
2320 for (struct String * k = key; k->length != -1; ++k)
2321 if (Ustrcmp(header_def,"true")==0)
2322 {
2323 *cond=compare(filter,k,&header_value,comparator,matchType);
2324 if (*cond==-1) return -1;
2325 if (*cond) break;
2326 }
2327 }
2328 }
2329 return 1;
2330 }
2331 else if (parse_identifier(filter,CUS "not"))
2332 {
2333 if (parse_white(filter)==-1) return -1;
2334 switch (parse_test(filter,cond,exec))
2335 {
2336 case -1: return -1;
2337 case 0: filter->errmsg=CUS "missing test"; return -1;
2338 default: *cond=!*cond; return 1;
2339 }
2340 }
2341 else if (parse_identifier(filter,CUS "size"))
2342 {
2343 /*
2344 relop = ":over" / ":under"
2345 size-test = "size" relop <limit: number>
2346 */
2347
2348 unsigned long limit;
2349 int overNotUnder;
2350
2351 if (parse_white(filter)==-1) return -1;
2352 if (parse_identifier(filter,CUS ":over")) overNotUnder=1;
2353 else if (parse_identifier(filter,CUS ":under")) overNotUnder=0;
2354 else
2355 {
2356 filter->errmsg=CUS "missing :over or :under";
2357 return -1;
2358 }
2359 if (parse_white(filter)==-1) return -1;
2360 if (parse_number(filter,&limit)==-1) return -1;
2361 *cond=(overNotUnder ? (message_size>limit) : (message_size<limit));
2362 return 1;
2363 }
2364 else if (parse_identifier(filter,CUS "true"))
2365 {
2366 *cond=1;
2367 return 1;
2368 }
2369 else if (parse_identifier(filter,CUS "envelope"))
2370 {
2371 /*
2372 envelope-test = "envelope" { [comparator] [address-part] [match-type] }
2373 <envelope-part: string-list> <key-list: string-list>
2374
2375 envelope-part is case insensitive "from" or "to"
2376 #ifdef ENVELOPE_AUTH
2377 envelope-part =/ "auth"
2378 #endif
2379 */
2380
2381 enum Comparator comparator=COMP_EN_ASCII_CASEMAP;
2382 enum AddressPart addressPart=ADDRPART_ALL;
2383 enum MatchType matchType=MATCH_IS;
2384 struct String *env,*key;
2385 int m;
2386 int co=0,ap=0,mt=0;
2387
2388 if (!filter->require_envelope)
2389 {
2390 filter->errmsg=CUS "missing previous require \"envelope\";";
2391 return -1;
2392 }
2393 for (;;)
2394 {
2395 if (parse_white(filter)==-1) return -1;
2396 if ((m=parse_comparator(filter,&comparator))!=0)
2397 {
2398 if (m==-1) return -1;
2399 if (co)
2400 {
2401 filter->errmsg=CUS "comparator already specified";
2402 return -1;
2403 }
2404 else co=1;
2405 }
2406 else if ((m=parse_addresspart(filter,&addressPart))!=0)
2407 {
2408 if (m==-1) return -1;
2409 if (ap)
2410 {
2411 filter->errmsg=CUS "address part already specified";
2412 return -1;
2413 }
2414 else ap=1;
2415 }
2416 else if ((m=parse_matchtype(filter,&matchType))!=0)
2417 {
2418 if (m==-1) return -1;
2419 if (mt)
2420 {
2421 filter->errmsg=CUS "match type already specified";
2422 return -1;
2423 }
2424 else mt=1;
2425 }
2426 else break;
2427 }
2428 if (parse_white(filter)==-1) return -1;
2429 if ((m=parse_stringlist(filter,&env))!=1)
2430 {
2431 if (m==0) filter->errmsg=CUS "envelope string list expected";
2432 return -1;
2433 }
2434 if (parse_white(filter)==-1) return -1;
2435 if ((m=parse_stringlist(filter,&key))!=1)
2436 {
2437 if (m==0) filter->errmsg=CUS "key string list expected";
2438 return -1;
2439 }
2440 *cond=0;
2441 for (struct String * e = env; e->length != -1 && !*cond; ++e)
2442 {
2443 const uschar *envelopeExpr=CUS 0;
2444 uschar *envelope=US 0;
2445
2446 if (eq_asciicase(e,&str_from,0))
2447 {
2448 switch (addressPart)
2449 {
2450 case ADDRPART_ALL: envelopeExpr=CUS "$sender_address"; break;
2451 #ifdef SUBADDRESS
2452 case ADDRPART_USER:
2453 #endif
2454 case ADDRPART_LOCALPART: envelopeExpr=CUS "${local_part:$sender_address}"; break;
2455 case ADDRPART_DOMAIN: envelopeExpr=CUS "${domain:$sender_address}"; break;
2456 #ifdef SUBADDRESS
2457 case ADDRPART_DETAIL: envelopeExpr=CUS 0; break;
2458 #endif
2459 }
2460 }
2461 else if (eq_asciicase(e,&str_to,0))
2462 {
2463 switch (addressPart)
2464 {
2465 case ADDRPART_ALL: envelopeExpr=CUS "$local_part_prefix$local_part$local_part_suffix@$domain"; break;
2466 #ifdef SUBADDRESS
2467 case ADDRPART_USER: envelopeExpr=filter->useraddress; break;
2468 case ADDRPART_DETAIL: envelopeExpr=filter->subaddress; break;
2469 #endif
2470 case ADDRPART_LOCALPART: envelopeExpr=CUS "$local_part_prefix$local_part$local_part_suffix"; break;
2471 case ADDRPART_DOMAIN: envelopeExpr=CUS "$domain"; break;
2472 }
2473 }
2474 #ifdef ENVELOPE_AUTH
2475 else if (eq_asciicase(e,&str_auth,0))
2476 {
2477 switch (addressPart)
2478 {
2479 case ADDRPART_ALL: envelopeExpr=CUS "$authenticated_sender"; break;
2480 #ifdef SUBADDRESS
2481 case ADDRPART_USER:
2482 #endif
2483 case ADDRPART_LOCALPART: envelopeExpr=CUS "${local_part:$authenticated_sender}"; break;
2484 case ADDRPART_DOMAIN: envelopeExpr=CUS "${domain:$authenticated_sender}"; break;
2485 #ifdef SUBADDRESS
2486 case ADDRPART_DETAIL: envelopeExpr=CUS 0; break;
2487 #endif
2488 }
2489 }
2490 #endif
2491 else
2492 {
2493 filter->errmsg=CUS "invalid envelope string";
2494 return -1;
2495 }
2496 if (exec && envelopeExpr)
2497 {
2498 if ((envelope=expand_string(US envelopeExpr)) == NULL)
2499 {
2500 filter->errmsg=CUS "header string expansion failed";
2501 return -1;
2502 }
2503 for (struct String * k = key; k->length != -1; ++k)
2504 {
2505 struct String envelopeStr = {.character = envelope, .length = Ustrlen(envelope)};
2506
2507 *cond=compare(filter,k,&envelopeStr,comparator,matchType);
2508 if (*cond==-1) return -1;
2509 if (*cond) break;
2510 }
2511 }
2512 }
2513 return 1;
2514 }
2515 #ifdef ENOTIFY
2516 else if (parse_identifier(filter,CUS "valid_notify_method"))
2517 {
2518 /*
2519 valid_notify_method = "valid_notify_method"
2520 <notification-uris: string-list>
2521 */
2522
2523 struct String *uris;
2524 int m;
2525
2526 if (!filter->require_enotify)
2527 {
2528 filter->errmsg=CUS "missing previous require \"enotify\";";
2529 return -1;
2530 }
2531 if (parse_white(filter)==-1) return -1;
2532 if ((m=parse_stringlist(filter,&uris))!=1)
2533 {
2534 if (m==0) filter->errmsg=CUS "URI string list expected";
2535 return -1;
2536 }
2537 if (exec)
2538 {
2539 *cond=1;
2540 for (struct String * u = uris; u->length != -1 && *cond; ++u)
2541 {
2542 string_item *recipient;
2543 struct String header,subject,body;
2544
2545 recipient=NULL;
2546 header.length=-1;
2547 header.character=(uschar*)0;
2548 subject.length=-1;
2549 subject.character=(uschar*)0;
2550 body.length=-1;
2551 body.character=(uschar*)0;
2552 if (parse_mailto_uri(filter,u->character,&recipient,&header,&subject,&body)!=1)
2553 *cond=0;
2554 }
2555 }
2556 return 1;
2557 }
2558 else if (parse_identifier(filter,CUS "notify_method_capability"))
2559 {
2560 /*
2561 notify_method_capability = "notify_method_capability" [COMPARATOR] [MATCH-TYPE]
2562 <notification-uri: string>
2563 <notification-capability: string>
2564 <key-list: string-list>
2565 */
2566
2567 int m;
2568 int co=0,mt=0;
2569
2570 enum Comparator comparator=COMP_EN_ASCII_CASEMAP;
2571 enum MatchType matchType=MATCH_IS;
2572 struct String uri,capa,*keys;
2573
2574 if (!filter->require_enotify)
2575 {
2576 filter->errmsg=CUS "missing previous require \"enotify\";";
2577 return -1;
2578 }
2579 for (;;)
2580 {
2581 if (parse_white(filter)==-1) return -1;
2582 if ((m=parse_comparator(filter,&comparator))!=0)
2583 {
2584 if (m==-1) return -1;
2585 if (co)
2586 {
2587 filter->errmsg=CUS "comparator already specified";
2588 return -1;
2589 }
2590 else co=1;
2591 }
2592 else if ((m=parse_matchtype(filter,&matchType))!=0)
2593 {
2594 if (m==-1) return -1;
2595 if (mt)
2596 {
2597 filter->errmsg=CUS "match type already specified";
2598 return -1;
2599 }
2600 else mt=1;
2601 }
2602 else break;
2603 }
2604 if ((m=parse_string(filter,&uri))!=1)
2605 {
2606 if (m==0) filter->errmsg=CUS "missing notification URI string";
2607 return -1;
2608 }
2609 if (parse_white(filter)==-1) return -1;
2610 if ((m=parse_string(filter,&capa))!=1)
2611 {
2612 if (m==0) filter->errmsg=CUS "missing notification capability string";
2613 return -1;
2614 }
2615 if (parse_white(filter)==-1) return -1;
2616 if ((m=parse_stringlist(filter,&keys))!=1)
2617 {
2618 if (m==0) filter->errmsg=CUS "missing key string list";
2619 return -1;
2620 }
2621 if (exec)
2622 {
2623 string_item *recipient;
2624 struct String header,subject,body;
2625
2626 *cond=0;
2627 recipient=NULL;
2628 header.length=-1;
2629 header.character=(uschar*)0;
2630 subject.length=-1;
2631 subject.character=(uschar*)0;
2632 body.length=-1;
2633 body.character=(uschar*)0;
2634 if (parse_mailto_uri(filter,uri.character,&recipient,&header,&subject,&body)==1)
2635 if (eq_asciicase(&capa,&str_online,0)==1)
2636 for (struct String * k = keys; k->length != -1; ++k)
2637 {
2638 *cond=compare(filter,k,&str_maybe,comparator,matchType);
2639 if (*cond==-1) return -1;
2640 if (*cond) break;
2641 }
2642 }
2643 return 1;
2644 }
2645 #endif
2646 else return 0;
2647 }
2648
2649
2650 /*************************************************
2651 * Parse and interpret an optional block *
2652 *************************************************/
2653
2654 /*
2655 Arguments:
2656 filter points to the Sieve filter including its state
2657 exec Execute parsed statements
2658 generated where to hang newly-generated addresses
2659
2660 Returns: 2 success by stop
2661 1 other success
2662 0 no block command found
2663 -1 syntax or execution error
2664 */
2665
2666 static int parse_block(struct Sieve *filter, int exec,
2667 address_item **generated)
2668 {
2669 int r;
2670
2671 if (parse_white(filter)==-1) return -1;
2672 if (*filter->pc=='{')
2673 {
2674 ++filter->pc;
2675 if ((r=parse_commands(filter,exec,generated))==-1 || r==2) return r;
2676 if (*filter->pc=='}')
2677 {
2678 ++filter->pc;
2679 return 1;
2680 }
2681 else
2682 {
2683 filter->errmsg=CUS "expecting command or closing brace";
2684 return -1;
2685 }
2686 }
2687 else return 0;
2688 }
2689
2690
2691 /*************************************************
2692 * Match a semicolon *
2693 *************************************************/
2694
2695 /*
2696 Arguments:
2697 filter points to the Sieve filter including its state
2698
2699 Returns: 1 success
2700 -1 syntax error
2701 */
2702
2703 static int parse_semicolon(struct Sieve *filter)
2704 {
2705 if (parse_white(filter)==-1) return -1;
2706 if (*filter->pc==';')
2707 {
2708 ++filter->pc;
2709 return 1;
2710 }
2711 else
2712 {
2713 filter->errmsg=CUS "missing semicolon";
2714 return -1;
2715 }
2716 }
2717
2718
2719 /*************************************************
2720 * Parse and interpret a Sieve command *
2721 *************************************************/
2722
2723 /*
2724 Arguments:
2725 filter points to the Sieve filter including its state
2726 exec Execute parsed statements
2727 generated where to hang newly-generated addresses
2728
2729 Returns: 2 success by stop
2730 1 other success
2731 -1 syntax or execution error
2732 */
2733 static int
2734 parse_commands(struct Sieve *filter, int exec, address_item **generated)
2735 {
2736 while (*filter->pc)
2737 {
2738 if (parse_white(filter)==-1) return -1;
2739 if (parse_identifier(filter,CUS "if"))
2740 {
2741 /*
2742 if-command = "if" test block *( "elsif" test block ) [ else block ]
2743 */
2744
2745 int cond,m,unsuccessful;
2746
2747 /* test block */
2748 if (parse_white(filter)==-1) return -1;
2749 if ((m=parse_test(filter,&cond,exec))==-1) return -1;
2750 if (m==0)
2751 {
2752 filter->errmsg=CUS "missing test";
2753 return -1;
2754 }
2755 if ((filter_test != FTEST_NONE && debug_selector != 0) ||
2756 (debug_selector & D_filter) != 0)
2757 {
2758 if (exec) debug_printf("if %s\n",cond?"true":"false");
2759 }
2760 m=parse_block(filter,exec ? cond : 0, generated);
2761 if (m==-1 || m==2) return m;
2762 if (m==0)
2763 {
2764 filter->errmsg=CUS "missing block";
2765 return -1;
2766 }
2767 unsuccessful = !cond;
2768 for (;;) /* elsif test block */
2769 {
2770 if (parse_white(filter)==-1) return -1;
2771 if (parse_identifier(filter,CUS "elsif"))
2772 {
2773 if (parse_white(filter)==-1) return -1;
2774 m=parse_test(filter,&cond,exec && unsuccessful);
2775 if (m==-1 || m==2) return m;
2776 if (m==0)
2777 {
2778 filter->errmsg=CUS "missing test";
2779 return -1;
2780 }
2781 if ((filter_test != FTEST_NONE && debug_selector != 0) ||
2782 (debug_selector & D_filter) != 0)
2783 {
2784 if (exec) debug_printf("elsif %s\n",cond?"true":"false");
2785 }
2786 m=parse_block(filter,exec && unsuccessful ? cond : 0, generated);
2787 if (m==-1 || m==2) return m;
2788 if (m==0)
2789 {
2790 filter->errmsg=CUS "missing block";
2791 return -1;
2792 }
2793 if (exec && unsuccessful && cond) unsuccessful = 0;
2794 }
2795 else break;
2796 }
2797 /* else block */
2798 if (parse_white(filter)==-1) return -1;
2799 if (parse_identifier(filter,CUS "else"))
2800 {
2801 m=parse_block(filter,exec && unsuccessful, generated);
2802 if (m==-1 || m==2) return m;
2803 if (m==0)
2804 {
2805 filter->errmsg=CUS "missing block";
2806 return -1;
2807 }
2808 }
2809 }
2810 else if (parse_identifier(filter,CUS "stop"))
2811 {
2812 /*
2813 stop-command = "stop" { stop-options } ";"
2814 stop-options =
2815 */
2816
2817 if (parse_semicolon(filter)==-1) return -1;
2818 if (exec)
2819 {
2820 filter->pc+=Ustrlen(filter->pc);
2821 return 2;
2822 }
2823 }
2824 else if (parse_identifier(filter,CUS "keep"))
2825 {
2826 /*
2827 keep-command = "keep" { keep-options } ";"
2828 keep-options =
2829 */
2830
2831 if (parse_semicolon(filter)==-1) return -1;
2832 if (exec)
2833 {
2834 add_addr(generated,US"inbox",1,0,0,0);
2835 filter->keep = 0;
2836 }
2837 }
2838 else if (parse_identifier(filter,CUS "discard"))
2839 {
2840 /*
2841 discard-command = "discard" { discard-options } ";"
2842 discard-options =
2843 */
2844
2845 if (parse_semicolon(filter)==-1) return -1;
2846 if (exec) filter->keep=0;
2847 }
2848 else if (parse_identifier(filter,CUS "redirect"))
2849 {
2850 /*
2851 redirect-command = "redirect" redirect-options "string" ";"
2852 redirect-options =
2853 redirect-options =) ":copy"
2854 */
2855
2856 struct String recipient;
2857 int m;
2858 int copy=0;
2859
2860 for (;;)
2861 {
2862 if (parse_white(filter)==-1) return -1;
2863 if (parse_identifier(filter,CUS ":copy")==1)
2864 {
2865 if (!filter->require_copy)
2866 {
2867 filter->errmsg=CUS "missing previous require \"copy\";";
2868 return -1;
2869 }
2870 copy=1;
2871 }
2872 else break;
2873 }
2874 if (parse_white(filter)==-1) return -1;
2875 if ((m=parse_string(filter,&recipient))!=1)
2876 {
2877 if (m==0) filter->errmsg=CUS "missing redirect recipient string";
2878 return -1;
2879 }
2880 if (strchr(CCS recipient.character,'@')==(char*)0)
2881 {
2882 filter->errmsg=CUS "unqualified recipient address";
2883 return -1;
2884 }
2885 if (exec)
2886 {
2887 add_addr(generated,recipient.character,0,0,0,0);
2888 if (!copy) filter->keep = 0;
2889 }
2890 if (parse_semicolon(filter)==-1) return -1;
2891 }
2892 else if (parse_identifier(filter,CUS "fileinto"))
2893 {
2894 /*
2895 fileinto-command = "fileinto" { fileinto-options } string ";"
2896 fileinto-options =
2897 fileinto-options =) [ ":copy" ]
2898 */
2899
2900 struct String folder;
2901 uschar *s;
2902 int m;
2903 unsigned long maxage, maxmessages, maxstorage;
2904 int copy=0;
2905
2906 maxage = maxmessages = maxstorage = 0;
2907 if (!filter->require_fileinto)
2908 {
2909 filter->errmsg=CUS "missing previous require \"fileinto\";";
2910 return -1;
2911 }
2912 for (;;)
2913 {
2914 if (parse_white(filter)==-1) return -1;
2915 if (parse_identifier(filter,CUS ":copy")==1)
2916 {
2917 if (!filter->require_copy)
2918 {
2919 filter->errmsg=CUS "missing previous require \"copy\";";
2920 return -1;
2921 }
2922 copy=1;
2923 }
2924 else break;
2925 }
2926 if (parse_white(filter)==-1) return -1;
2927 if ((m=parse_string(filter,&folder))!=1)
2928 {
2929 if (m==0) filter->errmsg=CUS "missing fileinto folder string";
2930 return -1;
2931 }
2932 m=0; s=folder.character;
2933 if (folder.length==0) m=1;
2934 if (Ustrcmp(s,"..")==0 || Ustrncmp(s,"../",3)==0) m=1;
2935 else while (*s)
2936 {
2937 if (Ustrcmp(s,"/..")==0 || Ustrncmp(s,"/../",4)==0) { m=1; break; }
2938 ++s;
2939 }
2940 if (m)
2941 {
2942 filter->errmsg=CUS "invalid folder";
2943 return -1;
2944 }
2945 if (exec)
2946 {
2947 add_addr(generated, folder.character, 1, maxage, maxmessages, maxstorage);
2948 if (!copy) filter->keep = 0;
2949 }
2950 if (parse_semicolon(filter)==-1) return -1;
2951 }
2952 #ifdef ENOTIFY
2953 else if (parse_identifier(filter,CUS "notify"))
2954 {
2955 /*
2956 notify-command = "notify" { notify-options } <method: string> ";"
2957 notify-options = [":from" string]
2958 [":importance" <"1" / "2" / "3">]
2959 [":options" 1*(string-list / number)]
2960 [":message" string]
2961 */
2962
2963 int m;
2964 struct String from;
2965 struct String importance;
2966 struct String message;
2967 struct String method;
2968 struct Notification *already;
2969 string_item *recipient;
2970 struct String header;
2971 struct String subject;
2972 struct String body;
2973 uschar *envelope_from;
2974 struct String auto_submitted_value;
2975 uschar *auto_submitted_def;
2976
2977 if (!filter->require_enotify)
2978 {
2979 filter->errmsg=CUS "missing previous require \"enotify\";";
2980 return -1;
2981 }
2982 from.character=(uschar*)0;
2983 from.length=-1;
2984 importance.character=(uschar*)0;
2985 importance.length=-1;
2986 message.character=(uschar*)0;
2987 message.length=-1;
2988 recipient=NULL;
2989 header.length=-1;
2990 header.character=(uschar*)0;
2991 subject.length=-1;
2992 subject.character=(uschar*)0;
2993 body.length=-1;
2994 body.character=(uschar*)0;
2995 envelope_from=(sender_address && sender_address[0]) ? expand_string(US"$local_part_prefix$local_part$local_part_suffix@$domain") : US "";
2996 for (;;)
2997 {
2998 if (parse_white(filter)==-1) return -1;
2999 if (parse_identifier(filter,CUS ":from")==1)
3000 {
3001 if (parse_white(filter)==-1) return -1;
3002 if ((m=parse_string(filter,&from))!=1)
3003 {
3004 if (m==0) filter->errmsg=CUS "from string expected";
3005 return -1;
3006 }
3007 }
3008 else if (parse_identifier(filter,CUS ":importance")==1)
3009 {
3010 if (parse_white(filter)==-1) return -1;
3011 if ((m=parse_string(filter,&importance))!=1)
3012 {
3013 if (m==0) filter->errmsg=CUS "importance string expected";
3014 return -1;
3015 }
3016 if (importance.length!=1 || importance.character[0]<'1' || importance.character[0]>'3')
3017 {
3018 filter->errmsg=CUS "invalid importance";
3019 return -1;
3020 }
3021 }
3022 else if (parse_identifier(filter,CUS ":options")==1)
3023 {
3024 if (parse_white(filter)==-1) return -1;
3025 }
3026 else if (parse_identifier(filter,CUS ":message")==1)
3027 {
3028 if (parse_white(filter)==-1) return -1;
3029 if ((m=parse_string(filter,&message))!=1)
3030 {
3031 if (m==0) filter->errmsg=CUS "message string expected";
3032 return -1;
3033 }
3034 }
3035 else break;
3036 }
3037 if (parse_white(filter)==-1) return -1;
3038 if ((m=parse_string(filter,&method))!=1)
3039 {
3040 if (m==0) filter->errmsg=CUS "missing method string";
3041 return -1;
3042 }
3043 if (parse_semicolon(filter)==-1) return -1;
3044 if (parse_mailto_uri(filter,method.character,&recipient,&header,&subject,&body)!=1)
3045 return -1;
3046 if (exec)
3047 {
3048 if (message.length==-1) message=subject;
3049 if (message.length==-1) expand_header(&message,&str_subject);
3050 expand_header(&auto_submitted_value,&str_auto_submitted);
3051 auto_submitted_def=expand_string(string_sprintf("${if def:header_auto-submitted {true}{false}}"));
3052 if (auto_submitted_value.character == NULL || auto_submitted_def == NULL)
3053 {
3054 filter->errmsg=CUS "header string expansion failed";
3055 return -1;
3056 }
3057 if (Ustrcmp(auto_submitted_def,"true")!=0 || Ustrcmp(auto_submitted_value.character,"no")==0)
3058 {
3059 for (already=filter->notified; already; already=already->next)
3060 {
3061 if (already->method.length==method.length
3062 && (method.length==-1 || Ustrcmp(already->method.character,method.character)==0)
3063 && already->importance.length==importance.length
3064 && (importance.length==-1 || Ustrcmp(already->importance.character,importance.character)==0)
3065 && already->message.length==message.length
3066 && (message.length==-1 || Ustrcmp(already->message.character,message.character)==0))
3067 break;
3068 }
3069 if (!already)
3070 /* New notification, process it */
3071 {
3072 struct Notification *sent;
3073 sent=store_get(sizeof(struct Notification));
3074 sent->method=method;
3075 sent->importance=importance;
3076 sent->message=message;
3077 sent->next=filter->notified;
3078 filter->notified=sent;
3079 #ifndef COMPILE_SYNTAX_CHECKER
3080 if (filter_test == FTEST_NONE)
3081 {
3082 int pid, fd;
3083
3084 if ((pid = child_open_exim2(&fd,envelope_from,envelope_from))>=1)
3085 {
3086 FILE *f;
3087 uschar *buffer;
3088 int buffer_capacity;
3089
3090 f = fdopen(fd, "wb");
3091 fprintf(f,"From: %s\n",from.length==-1 ? expand_string(US"$local_part_prefix$local_part$local_part_suffix@$domain") : from.character);
3092 for (string_item * p = recipient; p; p=p->next)
3093 fprintf(f,"To: %s\n",p->text);
3094 fprintf(f,"Auto-Submitted: auto-notified; %s\n",filter->enotify_mailto_owner);
3095 if (header.length>0) fprintf(f,"%s",header.character);
3096 if (message.length==-1)
3097 {
3098 message.character=US"Notification";
3099 message.length=Ustrlen(message.character);
3100 }
3101 /* Allocation is larger than necessary, but enough even for split MIME words */
3102 buffer_capacity=32+4*message.length;
3103 buffer=store_get(buffer_capacity);
3104 if (message.length!=-1) fprintf(f,"Subject: %s\n",parse_quote_2047(message.character, message.length, US"utf-8", buffer, buffer_capacity, TRUE));
3105 fprintf(f,"\n");
3106 if (body.length>0) fprintf(f,"%s\n",body.character);
3107 fflush(f);
3108 (void)fclose(f);
3109 (void)child_close(pid, 0);
3110 }
3111 }
3112 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
3113 {
3114 debug_printf("Notification to `%s': '%s'.\n",method.character,message.length!=-1 ? message.character : CUS "");
3115 }
3116 #endif
3117 }
3118 else
3119 {
3120 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
3121 {
3122 debug_printf("Repeated notification to `%s' ignored.\n",method.character);
3123 }
3124 }
3125 }
3126 else
3127 {
3128 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
3129 {
3130 debug_printf("Ignoring notification, triggering message contains Auto-submitted: field.\n");
3131 }
3132 }
3133 }
3134 }
3135 #endif
3136 #ifdef VACATION
3137 else if (parse_identifier(filter,CUS "vacation"))
3138 {
3139 /*
3140 vacation-command = "vacation" { vacation-options } <reason: string> ";"
3141 vacation-options = [":days" number]
3142 [":subject" string]
3143 [":from" string]
3144 [":addresses" string-list]
3145 [":mime"]
3146 [":handle" string]
3147 */
3148
3149 int m;
3150 unsigned long days;
3151 struct String subject;
3152 struct String from;
3153 struct String *addresses;
3154 int reason_is_mime;
3155 string_item *aliases;
3156 struct String handle;
3157 struct String reason;
3158
3159 if (!filter->require_vacation)
3160 {
3161 filter->errmsg=CUS "missing previous require \"vacation\";";
3162 return -1;
3163 }
3164 if (exec)
3165 {
3166 if (filter->vacation_ran)
3167 {
3168 filter->errmsg=CUS "trying to execute vacation more than once";
3169 return -1;
3170 }
3171 filter->vacation_ran=1;
3172 }
3173 days=VACATION_MIN_DAYS>7 ? VACATION_MIN_DAYS : 7;
3174 subject.character=(uschar*)0;
3175 subject.length=-1;
3176 from.character=(uschar*)0;
3177 from.length=-1;
3178 addresses=(struct String*)0;
3179 aliases=NULL;
3180 reason_is_mime=0;
3181 handle.character=(uschar*)0;
3182 handle.length=-1;
3183 for (;;)
3184 {
3185 if (parse_white(filter)==-1) return -1;
3186 if (parse_identifier(filter,CUS ":days")==1)
3187 {
3188 if (parse_white(filter)==-1) return -1;
3189 if (parse_number(filter,&days)==-1) return -1;
3190 if (days<VACATION_MIN_DAYS) days=VACATION_MIN_DAYS;
3191 else if (days>VACATION_MAX_DAYS) days=VACATION_MAX_DAYS;
3192 }
3193 else if (parse_identifier(filter,CUS ":subject")==1)
3194 {
3195 if (parse_white(filter)==-1) return -1;
3196 if ((m=parse_string(filter,&subject))!=1)
3197 {
3198 if (m==0) filter->errmsg=CUS "subject string expected";
3199 return -1;
3200 }
3201 }
3202 else if (parse_identifier(filter,CUS ":from")==1)
3203 {
3204 if (parse_white(filter)==-1) return -1;
3205 if ((m=parse_string(filter,&from))!=1)
3206 {
3207 if (m==0) filter->errmsg=CUS "from string expected";
3208 return -1;
3209 }
3210 if (check_mail_address(filter,&from)!=1)
3211 return -1;
3212 }
3213 else if (parse_identifier(filter,CUS ":addresses")==1)
3214 {
3215 if (parse_white(filter)==-1) return -1;
3216 if ((m=parse_stringlist(filter,&addresses))!=1)
3217 {
3218 if (m==0) filter->errmsg=CUS "addresses string list expected";
3219 return -1;
3220 }
3221 for (struct String * a = addresses; a->length != -1; ++a)
3222 {
3223 string_item * new = store_get(sizeof(string_item));
3224
3225 new->text=store_get(a->length+1);
3226 if (a->length) memcpy(new->text,a->character,a->length);
3227 new->text[a->length]='\0';
3228 new->next=aliases;
3229 aliases=new;
3230 }
3231 }
3232 else if (parse_identifier(filter,CUS ":mime")==1)
3233 reason_is_mime=1;
3234 else if (parse_identifier(filter,CUS ":handle")==1)
3235 {
3236 if (parse_white(filter)==-1) return -1;
3237 if ((m=parse_string(filter,&from))!=1)
3238 {
3239 if (m==0) filter->errmsg=CUS "handle string expected";
3240 return -1;
3241 }
3242 }
3243 else break;
3244 }
3245 if (parse_white(filter)==-1) return -1;
3246 if ((m=parse_string(filter,&reason))!=1)
3247 {
3248 if (m==0) filter->errmsg=CUS "missing reason string";
3249 return -1;
3250 }
3251 if (reason_is_mime)
3252 {
3253 uschar *s,*end;
3254
3255 for (s = reason.character, end = reason.character + reason.length;
3256 s<end && (*s&0x80)==0; ) s++;
3257 if (s<end)
3258 {
3259 filter->errmsg=CUS "MIME reason string contains 8bit text";
3260 return -1;
3261 }
3262 }
3263 if (parse_semicolon(filter)==-1) return -1;
3264
3265 if (exec)
3266 {
3267 address_item *addr;
3268 uschar *buffer;
3269 int buffer_capacity;
3270 md5 base;
3271 uschar digest[16];
3272 uschar hexdigest[33];
3273 gstring * once;
3274
3275 if (filter_personal(aliases,TRUE))
3276 {
3277 if (filter_test == FTEST_NONE)
3278 {
3279 /* ensure oncelog directory exists; failure will be detected later */
3280
3281 (void)directory_make(NULL, filter->vacation_directory, 0700, FALSE);
3282 }
3283 /* build oncelog filename */
3284
3285 md5_start(&base);
3286
3287 if (handle.length==-1)
3288 {
3289 gstring * key = NULL;
3290 if (subject.length!=-1) key =string_catn(key, subject.character, subject.length);
3291 if (from.length!=-1) key = string_catn(key, from.character, from.length);
3292 key = string_catn(key, reason_is_mime?US"1":US"0", 1);
3293 key = string_catn(key, reason.character, reason.length);
3294 md5_end(&base, key->s, key->ptr, digest);
3295 }
3296 else
3297 md5_end(&base, handle.character, handle.length, digest);
3298
3299 for (int i = 0; i < 16; i++) sprintf(CS (hexdigest+2*i), "%02X", digest[i]);
3300
3301 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
3302 debug_printf("Sieve: mail was personal, vacation file basename: %s\n", hexdigest);
3303
3304 if (filter_test == FTEST_NONE)
3305 {
3306 once = string_cat (NULL, filter->vacation_directory);
3307 once = string_catn(once, US"/", 1);
3308 once = string_catn(once, hexdigest, 33);
3309
3310 /* process subject */
3311
3312 if (subject.length==-1)
3313 {
3314 uschar *subject_def;
3315
3316 subject_def=expand_string(US"${if def:header_subject {true}{false}}");
3317 if (Ustrcmp(subject_def,"true")==0)
3318 {
3319 gstring * g = string_catn(NULL, US"Auto: ", 6);
3320
3321 expand_header(&subject,&str_subject);
3322 g = string_catn(g, subject.character, subject.length);
3323 subject.character = string_from_gstring(g);
3324 subject.length = g->ptr;
3325 }
3326 else
3327 {
3328 subject.character=US"Automated reply";
3329 subject.length=Ustrlen(subject.character);
3330 }
3331 }
3332
3333 /* add address to list of generated addresses */
3334
3335 addr = deliver_make_addr(string_sprintf(">%.256s", sender_address), FALSE);
3336 setflag(addr, af_pfr);
3337 addr->prop.ignore_error = TRUE;
3338 addr->next = *generated;
3339 *generated = addr;
3340 addr->reply = store_get(sizeof(reply_item));
3341 memset(addr->reply,0,sizeof(reply_item)); /* XXX */
3342 addr->reply->to = string_copy(sender_address);
3343 if (from.length==-1)
3344 addr->reply->from = expand_string(US"$local_part@$domain");
3345 else
3346 addr->reply->from = from.character;
3347 /* Allocation is larger than necessary, but enough even for split MIME words */
3348 buffer_capacity=32+4*subject.length;
3349 buffer=store_get(buffer_capacity);
3350 /* deconst cast safe as we pass in a non-const item */
3351 addr->reply->subject = US parse_quote_2047(subject.character, subject.length, US"utf-8", buffer, buffer_capacity, TRUE);
3352 addr->reply->oncelog = string_from_gstring(once);
3353 addr->reply->once_repeat=days*86400;
3354
3355 /* build body and MIME headers */
3356
3357 if (reason_is_mime)
3358 {
3359 uschar *mime_body,*reason_end;
3360 static const uschar nlnl[]="\r\n\r\n";
3361
3362 for
3363 (
3364 mime_body = reason.character, reason_end = reason.character + reason.length;
3365 mime_body < (reason_end-(sizeof(nlnl)-1)) && memcmp(mime_body, nlnl, (sizeof(nlnl)-1));
3366 ) mime_body++;
3367
3368 addr->reply->headers = string_copyn(reason.character, mime_body-reason.character);
3369
3370 if (mime_body+(sizeof(nlnl)-1)<reason_end) mime_body+=(sizeof(nlnl)-1);
3371 else mime_body=reason_end-1;
3372 addr->reply->text = string_copyn(mime_body, reason_end-mime_body);
3373 }
3374 else
3375 {
3376 struct String qp = { .character = NULL, .length = 0 }; /* Keep compiler happy (PH) */
3377
3378 addr->reply->headers = US"MIME-Version: 1.0\n"
3379 "Content-Type: text/plain;\n"
3380 "\tcharset=\"utf-8\"\n"
3381 "Content-Transfer-Encoding: quoted-printable";
3382 addr->reply->text = quoted_printable_encode(&reason,&qp)->character;
3383 }
3384 }
3385 }
3386 else if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
3387 debug_printf("Sieve: mail was not personal, vacation would ignore it\n");
3388 }
3389 }
3390 else break;
3391 #endif
3392 }
3393 return 1;
3394 }
3395
3396
3397 /*************************************************
3398 * Parse and interpret a sieve filter *
3399 *************************************************/
3400
3401 /*
3402 Arguments:
3403 filter points to the Sieve filter including its state
3404 exec Execute parsed statements
3405 generated where to hang newly-generated addresses
3406
3407 Returns: 1 success
3408 -1 syntax or execution error
3409 */
3410
3411 static int
3412 parse_start(struct Sieve *filter, int exec, address_item **generated)
3413 {
3414 filter->pc=filter->filter;
3415 filter->line=1;
3416 filter->keep=1;
3417 filter->require_envelope=0;
3418 filter->require_fileinto=0;
3419 #ifdef ENCODED_CHARACTER
3420 filter->require_encoded_character=0;
3421 #endif
3422 #ifdef ENVELOPE_AUTH
3423 filter->require_envelope_auth=0;
3424 #endif
3425 #ifdef ENOTIFY
3426 filter->require_enotify=0;
3427 filter->notified=(struct Notification*)0;
3428 #endif
3429 #ifdef SUBADDRESS
3430 filter->require_subaddress=0;
3431 #endif
3432 #ifdef VACATION
3433 filter->require_vacation=0;
3434 filter->vacation_ran=0;
3435 #endif
3436 filter->require_copy=0;
3437 filter->require_iascii_numeric=0;
3438
3439 if (parse_white(filter)==-1) return -1;
3440
3441 if (exec && filter->vacation_directory != NULL && filter_test == FTEST_NONE)
3442 {
3443 DIR *oncelogdir;
3444 struct dirent *oncelog;
3445 struct stat properties;
3446 time_t now;
3447
3448 /* clean up old vacation log databases */
3449
3450 oncelogdir=opendir(CS filter->vacation_directory);
3451
3452 if (oncelogdir ==(DIR*)0 && errno != ENOENT)
3453 {
3454 filter->errmsg=CUS "unable to open vacation directory";
3455 return -1;
3456 }
3457
3458 if (oncelogdir != NULL)
3459 {
3460 time(&now);
3461
3462 while ((oncelog=readdir(oncelogdir))!=(struct dirent*)0)
3463 {
3464 if (strlen(oncelog->d_name)==32)
3465 {
3466 uschar *s=string_sprintf("%s/%s",filter->vacation_directory,oncelog->d_name);
3467 if (Ustat(s,&properties)==0 && (properties.st_mtime+VACATION_MAX_DAYS*86400)<now)
3468 Uunlink(s);
3469 }
3470 }
3471 closedir(oncelogdir);
3472 }
3473 }
3474
3475 while (parse_identifier(filter,CUS "require"))
3476 {
3477 /*
3478 require-command = "require" <capabilities: string-list>
3479 */
3480
3481 struct String *cap;
3482 int m;
3483
3484 if (parse_white(filter)==-1) return -1;
3485 if ((m=parse_stringlist(filter,&cap))!=1)
3486 {
3487 if (m==0) filter->errmsg=CUS "capability string list expected";
3488 return -1;
3489 }
3490 for (struct String * check = cap; check->character; ++check)
3491 {
3492 if (eq_octet(check,&str_envelope,0)) filter->require_envelope=1;
3493 else if (eq_octet(check,&str_fileinto,0)) filter->require_fileinto=1;
3494 #ifdef ENCODED_CHARACTER
3495 else if (eq_octet(check,&str_encoded_character,0)) filter->require_encoded_character=1;
3496 #endif
3497 #ifdef ENVELOPE_AUTH
3498 else if (eq_octet(check,&str_envelope_auth,0)) filter->require_envelope_auth=1;
3499 #endif
3500 #ifdef ENOTIFY
3501 else if (eq_octet(check,&str_enotify,0))
3502 {
3503 if (filter->enotify_mailto_owner == NULL)
3504 {
3505 filter->errmsg=CUS "enotify disabled";
3506 return -1;
3507 }
3508 filter->require_enotify=1;
3509 }
3510 #endif
3511 #ifdef SUBADDRESS
3512 else if (eq_octet(check,&str_subaddress,0)) filter->require_subaddress=1;
3513 #endif
3514 #ifdef VACATION
3515 else if (eq_octet(check,&str_vacation,0))
3516 {
3517 if (filter_test == FTEST_NONE && filter->vacation_directory == NULL)
3518 {
3519 filter->errmsg=CUS "vacation disabled";
3520 return -1;
3521 }
3522 filter->require_vacation=1;
3523 }
3524 #endif
3525 else if (eq_octet(check,&str_copy,0)) filter->require_copy=1;
3526 else if (eq_octet(check,&str_comparator_ioctet,0)) ;
3527 else if (eq_octet(check,&str_comparator_iascii_casemap,0)) ;
3528 else if (eq_octet(check,&str_comparator_enascii_casemap,0)) ;
3529 else if (eq_octet(check,&str_comparator_iascii_numeric,0)) filter->require_iascii_numeric=1;
3530 else
3531 {
3532 filter->errmsg=CUS "unknown capability";
3533 return -1;
3534 }
3535 }
3536 if (parse_semicolon(filter)==-1) return -1;
3537 }
3538 if (parse_commands(filter,exec,generated)==-1) return -1;
3539 if (*filter->pc)
3540 {
3541 filter->errmsg=CUS "syntax error";
3542 return -1;
3543 }
3544 return 1;
3545 }
3546
3547
3548 /*************************************************
3549 * Interpret a sieve filter file *
3550 *************************************************/
3551
3552 /*
3553 Arguments:
3554 filter points to the entire file, read into store as a single string
3555 options controls whether various special things are allowed, and requests
3556 special actions (not currently used)
3557 vacation_directory where to store vacation "once" files
3558 enotify_mailto_owner owner of mailto notifications
3559 useraddress string expression for :user part of address
3560 subaddress string expression for :subaddress part of address
3561 generated where to hang newly-generated addresses
3562 error where to pass back an error text
3563
3564 Returns: FF_DELIVERED success, a significant action was taken
3565 FF_NOTDELIVERED success, no significant action
3566 FF_DEFER defer requested
3567 FF_FAIL fail requested
3568 FF_FREEZE freeze requested
3569 FF_ERROR there was a problem
3570 */
3571
3572 int
3573 sieve_interpret(uschar *filter, int options, uschar *vacation_directory,
3574 uschar *enotify_mailto_owner, uschar *useraddress, uschar *subaddress,
3575 address_item **generated, uschar **error)
3576 {
3577 struct Sieve sieve;
3578 int r;
3579 uschar *msg;
3580
3581 options = options; /* Keep picky compilers happy */
3582 error = error;
3583
3584 DEBUG(D_route) debug_printf("Sieve: start of processing\n");
3585 sieve.filter=filter;
3586
3587 if (vacation_directory == NULL)
3588 sieve.vacation_directory = NULL;
3589 else
3590 {
3591 sieve.vacation_directory=expand_string(vacation_directory);
3592 if (sieve.vacation_directory == NULL)
3593 {
3594 *error = string_sprintf("failed to expand \"%s\" "
3595 "(sieve_vacation_directory): %s", vacation_directory,
3596 expand_string_message);
3597 return FF_ERROR;
3598 }
3599 }
3600
3601 if (enotify_mailto_owner == NULL)
3602 sieve.enotify_mailto_owner = NULL;
3603 else
3604 {
3605 sieve.enotify_mailto_owner=expand_string(enotify_mailto_owner);
3606 if (sieve.enotify_mailto_owner == NULL)
3607 {
3608 *error = string_sprintf("failed to expand \"%s\" "
3609 "(sieve_enotify_mailto_owner): %s", enotify_mailto_owner,
3610 expand_string_message);
3611 return FF_ERROR;
3612 }
3613 }
3614
3615 sieve.useraddress = useraddress == NULL ? CUS "$local_part_prefix$local_part$local_part_suffix" : useraddress;
3616 sieve.subaddress = subaddress;
3617
3618 #ifdef COMPILE_SYNTAX_CHECKER
3619 if (parse_start(&sieve,0,generated)==1)
3620 #else
3621 if (parse_start(&sieve,1,generated)==1)
3622 #endif
3623 {
3624 if (sieve.keep)
3625 {
3626 add_addr(generated,US"inbox",1,0,0,0);
3627 msg = string_sprintf("Implicit keep");
3628 r = FF_DELIVERED;
3629 }
3630 else
3631 {
3632 msg = string_sprintf("No implicit keep");
3633 r = FF_DELIVERED;
3634 }
3635 }
3636 else
3637 {
3638 msg = string_sprintf("Sieve error: %s in line %d",sieve.errmsg,sieve.line);
3639 #ifdef COMPILE_SYNTAX_CHECKER
3640 r = FF_ERROR;
3641 *error = msg;
3642 #else
3643 add_addr(generated,US"inbox",1,0,0,0);
3644 r = FF_DELIVERED;
3645 #endif
3646 }
3647
3648 #ifndef COMPILE_SYNTAX_CHECKER
3649 if (filter_test != FTEST_NONE) printf("%s\n", (const char*) msg);
3650 else debug_printf("%s\n", msg);
3651 #endif
3652
3653 DEBUG(D_route) debug_printf("Sieve: end of processing\n");
3654 return r;
3655 }
Unnamed repository; edit this file 'description' to name the repository.