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