projects / exim.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
(1) Fixed the cipher preference order for GnuTLS client usage.
[exim.git] / src / src / sieve.c
CommitLineData
f05da2e8 1/* $Cambridge: exim/src/src/sieve.c,v 1.2 2004/11/25 13:54:31 ph10 Exp $ */
059ec3d9
PH		 2
3/*************************************************
4* Exim - an Internet mail transport agent *
5*************************************************/
6
7/* Copyright (c) Michael Haardt 2003,2004 */
8/* See the file NOTICE for conditions of use and distribution. */
9
10/* This code was contributed by Michael Haardt. */
11
12
13/* Sieve mail filter. */
14
15#include <ctype.h>
16#include <errno.h>
17#include <limits.h>
18#include <stdlib.h>
19#include <string.h>
20
21#include "exim.h"
22
23#if HAVE_ICONV
24#include <iconv.h>
25#endif
26
27/* Define this for RFC compliant \r\n end-of-line terminators. */
28/* Undefine it for UNIX-style \n end-of-line terminators (default). */
29#undef RFC_EOL
30
31/* Define this for development of the subaddress Sieve extension. */
32/* The code is currently broken. */
33#undef SUBADDRESS
34
35/* Define this for development of the vacation Sieve extension. */
36/* The code is not yet finished. */
37#define VACATION
38
39/* Must be >= 1 */
40#define VACATION_MIN_DAYS 1
41/* Must be >= VACATION_MIN_DAYS, must be > 7, should be > 30 */
42#define VACATION_MAX_DAYS 31
43
44/* Keep this at 75 to accept only RFC compliant MIME words. */
45/* Increase it if you want to match headers from buggy MUAs. */
46#define MIMEWORD_LENGTH 75
47
48struct Sieve
49 {
50 uschar *filter;
51 const uschar *pc;
52 int line;
53 const uschar *errmsg;
54 int keep;
55 int require_envelope;
56 int require_fileinto;
57#ifdef SUBADDRESS
58 int require_subaddress;
59#endif
60#ifdef VACATION
61 int require_vacation;
62 int vacation_ran;
63#endif
64 uschar *vacation_directory;
65 int require_copy;
66 int require_iascii_numeric;
67 };
68
69enum Comparator { COMP_OCTET, COMP_ASCII_CASEMAP, COMP_ASCII_NUMERIC };
70enum MatchType { MATCH_IS, MATCH_CONTAINS, MATCH_MATCHES };
71#ifdef SUBADDRESS
72enum AddressPart { ADDRPART_USER, ADDRPART_DETAIL, ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
73#else
74enum AddressPart { ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
75#endif
76enum RelOp { LT, LE, EQ, GE, GT, NE };
77
78struct String
79 {
80 uschar *character;
81 int length;
82 };
83
84static int parse_test(struct Sieve *filter, int *cond, int exec);
85static int parse_commands(struct Sieve *filter, int exec, address_item **generated);
86
87static uschar str_from_c[]="From";
88static const struct String str_from={ str_from_c, 4 };
89static uschar str_to_c[]="To";
90static const struct String str_to={ str_to_c, 2 };
91static uschar str_cc_c[]="Cc";
92static const struct String str_cc={ str_cc_c, 2 };
93static uschar str_bcc_c[]="Bcc";
94static const struct String str_bcc={ str_bcc_c, 3 };
95static uschar str_sender_c[]="Sender";
96static const struct String str_sender={ str_sender_c, 6 };
97static uschar str_resent_from_c[]="Resent-From";
98static const struct String str_resent_from={ str_resent_from_c, 11 };
99static uschar str_resent_to_c[]="Resent-To";
100static const struct String str_resent_to={ str_resent_to_c, 9 };
101static uschar str_fileinto_c[]="fileinto";
102static const struct String str_fileinto={ str_fileinto_c, 8 };
103static uschar str_envelope_c[]="envelope";
104static const struct String str_envelope={ str_envelope_c, 8 };
105#ifdef SUBADDRESS
106static uschar str_subaddress_c[]="subaddress";
107static const struct String str_subaddress={ str_subaddress_c, 10 };
108#endif
109#ifdef VACATION
110static uschar str_vacation_c[]="vacation";
111static const struct String str_vacation={ str_vacation_c, 8 };
112static uschar str_subject_c[]="Subject";
113static const struct String str_subject={ str_subject_c, 7 };
114#endif
115static uschar str_copy_c[]="copy";
116static const struct String str_copy={ str_copy_c, 4 };
117static uschar str_iascii_casemap_c[]="i;ascii-casemap";
118static const struct String str_iascii_casemap={ str_iascii_casemap_c, 15 };
119static uschar str_ioctet_c[]="i;octet";
120static const struct String str_ioctet={ str_ioctet_c, 7 };
121static uschar str_iascii_numeric_c[]="i;ascii-numeric";
122static const struct String str_iascii_numeric={ str_iascii_numeric_c, 15 };
123static uschar str_comparator_iascii_casemap_c[]="comparator-i;ascii-casemap";
124static const struct String str_comparator_iascii_casemap={ str_comparator_iascii_casemap_c, 26 };
125static uschar str_comparator_ioctet_c[]="comparator-i;octet";
126static const struct String str_comparator_ioctet={ str_comparator_ioctet_c, 18 };
127static uschar str_comparator_iascii_numeric_c[]="comparator-i;ascii-numeric";
128static const struct String str_comparator_iascii_numeric={ str_comparator_iascii_numeric_c, 26 };
129
130
131/*************************************************
132* Encode to quoted-printable *
133*************************************************/
134
135/*
136Arguments:
137 src UTF-8 string
138*/
139
140static struct String *quoted_printable_encode(const struct String *src, struct String *dst)
141{
142int pass;
143const uschar *start,*end;
144uschar *new = NULL;
145uschar ch;
146size_t line;
147
148for (pass=0; pass<=1; ++pass)
149 {
150 line=0;
151 if (pass==0)
152 dst->length=0;
153 else
154 {
155 dst->character=store_get(dst->length+1); /* plus one for \0 */
156 new=dst->character;
157 }
158 for (start=src->character,end=start+src->length; start<end; ++start)
159 {
160 ch=*start;
161 if (line>=73)
162 {
163 if (pass==0)
164 dst->length+=2;
165 else
166 {
167 *new++='=';
168 *new++='\n';
169 }
170 line=0;
171 }
172 if
173 (
174 (ch>=33 && ch<=60)
175 || (ch>=62 && ch<=126)
176 ||
177 (
178 (ch==9 || ch==32)
179#ifdef RFC_EOL
180 && start+2<end
181 && (*(start+1)!='\r' || *(start+2)!='\n')
182#else
183 && start+1<end
184 && *(start+1)!='\n'
185#endif
186 )
187 )
188 {
189 if (pass==0)
190 ++dst->length;
191 else
192 *new++=*start;
193 ++line;
194 }
195#ifdef RFC_EOL
196 else if (ch=='\r' && start+1<end && *(start+1)=='\n')
197 {
198 if (pass==0)
199 {
200 ++dst->length;
201 line=0;
202 ++start;
203 }
204 else
205 *new++='\n';
206 line=0;
207 }
208#else
209 else if (ch=='\n')
210 {
211 if (pass==0)
212 ++dst->length;
213 else
214 *new++=*start;
215 ++line;
216 }
217#endif
218 else
219 {
220 if (pass==0)
221 dst->length+=3;
222 else
223 {
224 sprintf(CS new,"=%02X",ch);
225 new+=3;
226 }
227 line+=3;
228 }
229 }
230 }
231 *new='\0'; /* not included in length, but nice */
232 return dst;
233}
234
235
236/*************************************************
237* Octet-wise string comparison *
238*************************************************/
239
240/*
241Arguments:
242 needle UTF-8 string to search ...
243 haystack ... inside the haystack
244 match_prefix 1 to compare if needle is a prefix of haystack
245
246Returns: 0 needle not found in haystack
247 1 needle found
248*/
249
250static int eq_octet(const struct String *needle,
251 const struct String *haystack, int match_prefix)
252{
253size_t nl,hl;
254const uschar *n,*h;
255
256nl=needle->length;
257n=needle->character;
258hl=haystack->length;
259h=haystack->character;
260while (nl>0 && hl>0)
261 {
262#if !HAVE_ICONV
263 if (*n&0x80) return 0;
264 if (*h&0x80) return 0;
265#endif
266 if (*n!=*h) return 0;
267 ++n;
268 ++h;
269 --nl;
270 --hl;
271 }
272return (match_prefix ? nl==0 : nl==0 && hl==0);
273}
274
275
276/*************************************************
277* ASCII case-insensitive string comparison *
278*************************************************/
279
280/*
281Arguments:
282 needle UTF-8 string to search ...
283 haystack ... inside the haystack
284 match_prefix 1 to compare if needle is a prefix of haystack
285
286Returns: 0 needle not found in haystack
287 1 needle found
288*/
289
290static int eq_asciicase(const struct String *needle,
291 const struct String *haystack, int match_prefix)
292{
293size_t nl,hl;
294const uschar *n,*h;
295uschar nc,hc;
296
297nl=needle->length;
298n=needle->character;
299hl=haystack->length;
300h=haystack->character;
301while (nl>0 && hl>0)
302 {
303 nc=*n;
304 hc=*h;
305#if !HAVE_ICONV
306 if (nc&0x80) return 0;
307 if (hc&0x80) return 0;
308#endif
309 /* tolower depends on the locale and only ASCII case must be insensitive */
310 if ((nc&0x80) || (hc&0x80)) { if (nc!=hc) return 0; }
311 else if ((nc>='A' && nc<='Z' ? nc|0x20 : nc) != (hc>='A' && hc<='Z' ? hc|0x20 : hc)) return 0;
312 ++n;
313 ++h;
314 --nl;
315 --hl;
316 }
317return (match_prefix ? nl==0 : nl==0 && hl==0);
318}
319
320
321/*************************************************
322* Octet-wise glob pattern search *
323*************************************************/
324
325/*
326Arguments:
327 needle pattern to search ...
328 haystack ... inside the haystack
329
330Returns: 0 needle not found in haystack
331 1 needle found
332*/
333
334static int eq_octetglob(const struct String *needle,
335 const struct String *haystack)
336{
337struct String n,h;
338
339n=*needle;
340h=*haystack;
341while (n.length)
342 {
343 switch (n.character[0])
344 {
345 case '*':
346 {
347 int currentLength;
348
349 ++n.character;
350 --n.length;
351 /* The greedy match is not yet well tested. Some day we may */
352 /* need to refer to the matched parts, so the code is already */
353 /* prepared for that. */
354#if 1
355 /* greedy match */
356 currentLength=h.length;
357 h.character+=h.length;
358 h.length=0;
359 while (h.length<=currentLength)
360 {
361 if (eq_octetglob(&n,&h)) return 1;
362 else /* go back one octet */
363 {
364 --h.character;
365 ++h.length;
366 }
367 }
368 return 0;
369#else
370 /* minimal match */
371 while (h.length)
372 {
373 if (eq_octetglob(&n,&h)) return 1;
374 else /* advance one octet */
375 {
376 ++h.character;
377 --h.length;
378 }
379 }
380 break;
381#endif
382 }
383 case '?':
384 {
385 if (h.length)
386 {
387 ++h.character;
388 --h.length;
389 ++n.character;
390 --n.length;
391 }
392 else return 0;
393 break;
394 }
395 case '\\':
396 {
397 ++n.character;
398 --n.length;
399 /* FALLTHROUGH */
400 }
401 default:
402 {
403 if
404 (
405 h.length==0 ||
406#if !HAVE_ICONV
407 (h.character[0]&0x80) || (n.character[0]&0x80) ||
408#endif
409 h.character[0]!=n.character[0]
410 ) return 0;
411 else
412 {
413 ++h.character;
414 --h.length;
415 ++n.character;
416 --n.length;
417 };
418 }
419 }
420 }
421return (h.length==0);
422}
423
424
425/*************************************************
426* ASCII case-insensitive glob pattern search *
427*************************************************/
428
429/*
430Arguments:
431 needle UTF-8 pattern to search ...
432 haystack ... inside the haystack
433
434Returns: 0 needle not found in haystack
435 1 needle found
436*/
437
438static int eq_asciicaseglob(const struct String *needle,
439 const struct String *haystack)
440{
441struct String n,h;
442
443n=*needle;
444h=*haystack;
445while (n.length)
446 {
447 switch (n.character[0])
448 {
449 case '*':
450 {
451 int currentLength;
452
453 ++n.character;
454 --n.length;
455 /* The greedy match is not yet well tested. Some day we may */
456 /* need to refer to the matched parts, so the code is already */
457 /* prepared for that. */
458#if 1
459 /* greedy match */
460 currentLength=h.length;
461 h.character+=h.length;
462 h.length=0;
463 while (h.length<=currentLength)
464 {
465 if (eq_asciicaseglob(&n,&h)) return 1;
466 else /* go back one UTF-8 character */
467 {
468 if (h.length==currentLength) return 0;
469 --h.character;
470 ++h.length;
471 if (h.character[0]&0x80)
472 {
473 while (h.length<currentLength && (*(h.character-1)&0x80))
474 {
475 --h.character;
476 ++h.length;
477 }
478 }
479 }
480 }
481 /* NOTREACHED */
482#else
483 while (h.length)
484 {
485 if (eq_asciicaseglob(&n,&h)) return 1;
486 else /* advance one UTF-8 character */
487 {
488 if (h.character[0]&0x80)
489 {
490 while (h.length && (h.character[0]&0x80))
491 {
492 ++h.character;
493 --h.length;
494 }
495 }
496 else
497 {
498 ++h.character;
499 --h.length;
500 }
501 }
502 }
503 break;
504#endif
505 }
506 case '?':
507 {
508 if (h.length)
509 {
510 ++n.character;
511 --n.length;
512 /* advance one UTF-8 character */
513 if (h.character[0]&0x80)
514 {
515 while (h.length && (h.character[0]&0x80))
516 {
517 ++h.character;
518 --h.length;
519 }
520 }
521 else
522 {
523 ++h.character;
524 --h.length;
525 }
526 }
527 else return 0;
528 break;
529 }
530 case '\\':
531 {
532 ++n.character;
533 --n.length;
534 /* FALLTHROUGH */
535 }
536 default:
537 {
538 char nc,hc;
539
540 if (h.length==0) return 0;
541 nc=n.character[0];
542 hc=h.character[0];
543#if !HAVE_ICONV
544 if ((hc&0x80) || (nc&0x80)) return 0;
545#endif
546 /* tolower depends on the locale and only ASCII case must be insensitive */
547 if ((nc&0x80) || (hc&0x80)) { if (nc!=hc) return 0; }
548 else if ((nc>='A' && nc<='Z' ? nc|0x20 : nc) != (hc>='A' && hc<='Z' ? hc|0x20 : hc)) return 0;
549 ++h.character;
550 --h.length;
551 ++n.character;
552 --n.length;
553 }
554 }
555 }
556return (h.length==0);
557}
558
559
560/*************************************************
561* ASCII numeric comparison *
562*************************************************/
563
564/*
565Arguments:
566 a first numeric string
567 b second numeric string
568 relop relational operator
569
570Returns: 0 not (a relop b)
571 1 a relop b
572*/
573
574static int eq_asciinumeric(const struct String *a,
575 const struct String *b, enum RelOp relop)
576{
577size_t al,bl;
578const uschar *as,*aend,*bs,*bend;
579int cmp;
580
581as=a->character;
582aend=a->character+a->length;
583bs=b->character;
584bend=b->character+b->length;
585
586while (*as>='0' && *as<='9' && as<aend) ++as;
587al=as-a->character;
588while (*bs>='0' && *bs<='9' && bs<bend) ++bs;
589bl=bs-b->character;
590
591if (al && bl==0) cmp=-1;
592else if (al==0 && bl==0) cmp=0;
593else if (al==0 && bl) cmp=1;
594else
595 {
596 cmp=al-bl;
597 if (cmp==0) cmp=memcmp(a->character,b->character,al);
598 }
599switch (relop)
600 {
601 case LT: return cmp<0;
602 case LE: return cmp<=0;
603 case EQ: return cmp==0;
604 case GE: return cmp>=0;
605 case GT: return cmp>0;
606 case NE: return cmp!=0;
607 }
608 /*NOTREACHED*/
609 return -1;
610}
611
612
613/*************************************************
614* Compare strings *
615*************************************************/
616
617/*
618Arguments:
619 needle UTF-8 pattern or string to search ...
620 haystack ... inside the haystack
621 co comparator to use
622 mt match type to use
623
624Returns: 0 needle not found in haystack
625 1 needle found
626 -1 comparator does not offer matchtype
627*/
628
629static int compare(struct Sieve *filter, const struct String *needle, const struct String *haystack,
630 enum Comparator co, enum MatchType mt)
631{
632int r=0;
633
f05da2e8 634if ((filter_test != FTEST_NONE && debug_selector != 0) ||
059ec3d9
PH		 635 (debug_selector & D_filter) != 0)
636 {
637 debug_printf("String comparison (match ");
638 switch (mt)
639 {
640 case MATCH_IS: debug_printf(":is"); break;
641 case MATCH_CONTAINS: debug_printf(":contains"); break;
642 case MATCH_MATCHES: debug_printf(":matches"); break;
643 }
644 debug_printf(", comparison \"");
645 switch (co)
646 {
647 case COMP_OCTET: debug_printf("i;octet"); break;
648 case COMP_ASCII_CASEMAP: debug_printf("i;ascii-casemap"); break;
649 case COMP_ASCII_NUMERIC: debug_printf("i;ascii-numeric"); break;
650 }
651 debug_printf("\"):\n");
652 debug_printf(" Search = %s (%d chars)\n", needle->character,needle->length);
653 debug_printf(" Inside = %s (%d chars)\n", haystack->character,haystack->length);
654 }
655switch (mt)
656 {
657 case MATCH_IS:
658 {
659 switch (co)
660 {
661 case COMP_OCTET:
662 {
663 if (eq_octet(needle,haystack,0)) r=1;
664 break;
665 }
666 case COMP_ASCII_CASEMAP:
667 {
668 if (eq_asciicase(needle,haystack,0)) r=1;
669 break;
670 }
671 case COMP_ASCII_NUMERIC:
672 {
673 if (!filter->require_iascii_numeric)
674 {
675 filter->errmsg=CUS "missing previous require \"comparator-i;ascii-numeric\";";
676 return -1;
677 }
678 if (eq_asciinumeric(needle,haystack,EQ)) r=1;
679 break;
680 }
681 }
682 break;
683 }
684 case MATCH_CONTAINS:
685 {
686 struct String h;
687
688 switch (co)
689 {
690 case COMP_OCTET:
691 {
692 for (h=*haystack; h.length; ++h.character,--h.length) if (eq_octet(needle,&h,1)) { r=1; break; }
693 break;
694 }
695 case COMP_ASCII_CASEMAP:
696 {
697 for (h=*haystack; h.length; ++h.character,--h.length) if (eq_asciicase(needle,&h,1)) { r=1; break; }
698 break;
699 }
700 default:
701 {
702 filter->errmsg=CUS "comparator does not offer specified matchtype";
703 return -1;
704 }
705 }
706 break;
707 }
708 case MATCH_MATCHES:
709 {
710 switch (co)
711 {
712 case COMP_OCTET:
713 {
714 if (eq_octetglob(needle,haystack)) r=1;
715 break;
716 }
717 case COMP_ASCII_CASEMAP:
718 {
719 if (eq_asciicaseglob(needle,haystack)) r=1;
720 break;
721 }
722 default:
723 {
724 filter->errmsg=CUS "comparator does not offer specified matchtype";
725 return -1;
726 }
727 }
728 break;
729 }
730 }
f05da2e8 731if ((filter_test != FTEST_NONE && debug_selector != 0) ||
059ec3d9
PH		 732 (debug_selector & D_filter) != 0)
733 debug_printf(" Result %s\n",r?"true":"false");
734return r;
735}
736
737
738/*************************************************
739* Check header field syntax *
740*************************************************/
741
742/*
743RFC 2822, section 3.6.8 says:
744
745 field-name = 1*ftext
746
747 ftext = %d33-57 / ; Any character except
748 %d59-126 ; controls, SP, and
749 ; ":".
750
751That forbids 8-bit header fields. This implementation accepts them, since
752all of Exim is 8-bit clean, so it adds %d128-%d255.
753
754Arguments:
755 header header field to quote for suitable use in Exim expansions
756
757Returns: 0 string is not a valid header field
758 1 string is a value header field
759*/
760
761static int is_header(const struct String *header)
762{
763size_t l;
764const uschar *h;
765
766l=header->length;
767h=header->character;
768if (l==0) return 0;
769while (l)
770 {
771 if (((unsigned char)*h)<33 || ((unsigned char)*h)==':' || ((unsigned char)*h)==127) return 0;
772 else
773 {
774 ++h;
775 --l;
776 }
777 }
778return 1;
779}
780
781
782/*************************************************
783* Quote special characters string *
784*************************************************/
785
786/*
787Arguments:
788 header header field to quote for suitable use in Exim expansions
789 or as debug output
790
791Returns: quoted string
792*/
793
794static const uschar *quote(const struct String *header)
795{
796uschar *quoted=NULL;
797int size=0,ptr=0;
798size_t l;
799const uschar *h;
800
801l=header->length;
802h=header->character;
803while (l)
804 {
805 switch (*h)
806 {
807 case '\0':
808 {
809 quoted=string_cat(quoted,&size,&ptr,CUS "\\0",2);
810 break;
811 }
812 case '$':
813 case '{':
814 case '}':
815 {
816 quoted=string_cat(quoted,&size,&ptr,CUS "\\",1);
817 }
818 default:
819 {
820 quoted=string_cat(quoted,&size,&ptr,h,1);
821 }
822 }
823 ++h;
824 --l;
825 }
826quoted=string_cat(quoted,&size,&ptr,CUS "",1);
827return quoted;
828}
829
830
831/*************************************************
832* Add address to list of generated addresses *
833*************************************************/
834
835/*
836According to RFC 3028, duplicate delivery to the same address must
837not happen, so the list is first searched for the address.
838
839Arguments:
840 generated list of generated addresses
841 addr new address to add
842 file address denotes a file
843
844Returns: nothing
845*/
846
847static void add_addr(address_item **generated, uschar *addr, int file, int maxage, int maxmessages, int maxstorage)
848{
849address_item *new_addr;
850
851for (new_addr=*generated; new_addr; new_addr=new_addr->next)
852 {
853 if (Ustrcmp(new_addr->address,addr)==0 && (file ? testflag(new_addr, af_pfr|af_file) : 1))
854 {
f05da2e8 855 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
059ec3d9
PH		 856 {
857 debug_printf("Repeated %s `%s' ignored.\n",file ? "fileinto" : "redirect", addr);
858 }
859 return;
860 }
861 }
862
f05da2e8 863if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
059ec3d9
PH		 864 {
865 debug_printf("%s `%s'\n",file ? "fileinto" : "redirect", addr);
866 }
867new_addr=deliver_make_addr(addr,TRUE);
868if (file)
869 {
870 setflag(new_addr, af_pfr|af_file);
871 new_addr->mode = 0;
872 }
873new_addr->p.errors_address = NULL;
874new_addr->next = *generated;
875*generated = new_addr;
876}
877
878
879/*************************************************
880* Return decoded header field *
881*************************************************/
882
883/*
884Arguments:
885 value returned value of the field
886 header name of the header field
887
888Returns: nothing The expanded string is empty
889 in case there is no such header
890*/
891
892static void expand_header(struct String *value, const struct String *header)
893{
894uschar *s,*r,*t;
895uschar *errmsg;
896
897value->length=0;
898value->character=(uschar*)0;
899
900t=r=s=expand_string(string_sprintf("$rheader_%s",quote(header)));
901while (*r==' ') ++r;
902while (*r)
903 {
904 if (*r=='\n')
905 {
906 ++r;
907 while (*r==' ' || *r=='\t') ++r;
908 if (*r) *t++=' ';
909 }
910 else
911 *t++=*r++;
912 }
913*t++='\0';
914value->character=rfc2047_decode(s,TRUE,US"utf-8",'\0',&value->length,&errmsg);
915}
916
917
918/*************************************************
919* Parse remaining hash comment *
920*************************************************/
921
922/*
923Token definition:
924 Comment up to terminating CRLF
925
926Arguments:
927 filter points to the Sieve filter including its state
928
929Returns: 1 success
930 -1 syntax error
931*/
932
933static int parse_hashcomment(struct Sieve *filter)
934{
935++filter->pc;
936while (*filter->pc)
937 {
938#ifdef RFC_EOL
939 if (*filter->pc=='\r' && *(filter->pc+1)=='\n')
940#else
941 if (*filter->pc=='\n')
942#endif
943 {
944#ifdef RFC_EOL
945 filter->pc+=2;
946#else
947 ++filter->pc;
948#endif
949 ++filter->line;
950 return 1;
951 }
952 else ++filter->pc;
953 }
954filter->errmsg=CUS "missing end of comment";
955return -1;
956}
957
958
959/*************************************************
960* Parse remaining C-style comment *
961*************************************************/
962
963/*
964Token definition:
965 Everything up to star slash
966
967Arguments:
968 filter points to the Sieve filter including its state
969
970Returns: 1 success
971 -1 syntax error
972*/
973
974static int parse_comment(struct Sieve *filter)
975{
976 filter->pc+=2;
977 while (*filter->pc)
978 {
979 if (*filter->pc=='*' && *(filter->pc+1)=='/')
980 {
981 filter->pc+=2;
982 return 1;
983 }
984 else ++filter->pc;
985 }
986 filter->errmsg=CUS "missing end of comment";
987 return -1;
988}
989
990
991/*************************************************
992* Parse optional white space *
993*************************************************/
994
995/*
996Token definition:
997 Spaces, tabs, CRLFs, hash comments or C-style comments
998
999Arguments:
1000 filter points to the Sieve filter including its state
1001
1002Returns: 1 success
1003 -1 syntax error
1004*/
1005
1006static int parse_white(struct Sieve *filter)
1007{
1008while (*filter->pc)
1009 {
1010 if (*filter->pc==' ' || *filter->pc=='\t') ++filter->pc;
1011#ifdef RFC_EOL
1012 else if (*filter->pc=='\r' && *(filter->pc+1)=='\n')
1013#else
1014 else if (*filter->pc=='\n')
1015#endif
1016 {
1017#ifdef RFC_EOL
1018 filter->pc+=2;
1019#else
1020 ++filter->pc;
1021#endif
1022 ++filter->line;
1023 }
1024 else if (*filter->pc=='#')
1025 {
1026 if (parse_hashcomment(filter)==-1) return -1;
1027 }
1028 else if (*filter->pc=='/' && *(filter->pc+1)=='*')
1029 {
1030 if (parse_comment(filter)==-1) return -1;
1031 }
1032 else break;
1033 }
1034return 1;
1035}
1036
1037
1038/*************************************************
1039* Parse a optional string *
1040*************************************************/
1041
1042/*
1043Token definition:
1044 quoted-string = DQUOTE *CHAR DQUOTE
1045 ;; in general, \ CHAR inside a string maps to CHAR
1046 ;; so \" maps to " and \\ maps to \
1047 ;; note that newlines and other characters are all allowed
1048 ;; in strings
1049
1050 multi-line = "text:" *(SP / HTAB) (hash-comment / CRLF)
1051 *(multi-line-literal / multi-line-dotstuff)
1052 "." CRLF
1053 multi-line-literal = [CHAR-NOT-DOT *CHAR-NOT-CRLF] CRLF
1054 multi-line-dotstuff = "." 1*CHAR-NOT-CRLF CRLF
1055 ;; A line containing only "." ends the multi-line.
1056 ;; Remove a leading '.' if followed by another '.'.
1057 string = quoted-string / multi-line
1058
1059Arguments:
1060 filter points to the Sieve filter including its state
1061 id specifies identifier to match
1062
1063Returns: 1 success
1064 -1 syntax error
1065 0 identifier not matched
1066*/
1067
1068static int parse_string(struct Sieve *filter, struct String *data)
1069{
1070int dataCapacity=0;
1071
1072data->length=0;
1073data->character=(uschar*)0;
1074if (*filter->pc=='"') /* quoted string */
1075 {
1076 ++filter->pc;
1077 while (*filter->pc)
1078 {
1079 if (*filter->pc=='"') /* end of string */
1080 {
1081 int foo=data->length;
1082
1083 ++filter->pc;
1084 data->character=string_cat(data->character,&dataCapacity,&foo,CUS "",1);
1085 return 1;
1086 }
1087 else if (*filter->pc=='\\' && *(filter->pc+1)) /* quoted character */
1088 {
1089 if (*(filter->pc+1)=='0') data->character=string_cat(data->character,&dataCapacity,&data->length,CUS "",1);
1090 else data->character=string_cat(data->character,&dataCapacity,&data->length,filter->pc+1,1);
1091 filter->pc+=2;
1092 }
1093 else /* regular character */
1094 {
1095 data->character=string_cat(data->character,&dataCapacity,&data->length,filter->pc,1);
1096 filter->pc++;
1097 }
1098 }
1099 filter->errmsg=CUS "missing end of string";
1100 return -1;
1101 }
1102else if (Ustrncmp(filter->pc,CUS "text:",5)==0) /* multiline string */
1103 {
1104 filter->pc+=5;
1105 /* skip optional white space followed by hashed comment or CRLF */
1106 while (*filter->pc==' ' || *filter->pc=='\t') ++filter->pc;
1107 if (*filter->pc=='#')
1108 {
1109 if (parse_hashcomment(filter)==-1) return -1;
1110 }
1111#ifdef RFC_EOL
1112 else if (*filter->pc=='\r' && *(filter->pc+1)=='\n')
1113#else
1114 else if (*filter->pc=='\n')
1115#endif
1116 {
1117#ifdef RFC_EOL
1118 filter->pc+=2;
1119#else
1120 ++filter->pc;
1121#endif
1122 ++filter->line;
1123 }
1124 else
1125 {
1126 filter->errmsg=CUS "syntax error";
1127 return -1;
1128 }
1129 while (*filter->pc)
1130 {
1131#ifdef RFC_EOL
1132 if (*filter->pc=='\r' && *(filter->pc+1)=='\n') /* end of line */
1133#else
1134 if (*filter->pc=='\n') /* end of line */
1135#endif
1136 {
1137 data->character=string_cat(data->character,&dataCapacity,&data->length,CUS "\r\n",2);
1138#ifdef RFC_EOL
1139 filter->pc+=2;
1140#else
1141 ++filter->pc;
1142#endif
1143 ++filter->line;
1144#ifdef RFC_EOL
1145 if (*filter->pc=='.' && *(filter->pc+1)=='\r' && *(filter->pc+2)=='\n') /* end of string */
1146#else
1147 if (*filter->pc=='.' && *(filter->pc+1)=='\n') /* end of string */
1148#endif
1149 {
1150 data->character=string_cat(data->character,&dataCapacity,&data->length,CUS "",1);
1151#ifdef RFC_EOL
1152 filter->pc+=3;
1153#else
1154 filter->pc+=2;
1155#endif
1156 ++filter->line;
1157 return 1;
1158 }
1159 else if (*filter->pc=='.' && *(filter->pc+1)=='.') /* remove dot stuffing */
1160 {
1161 data->character=string_cat(data->character,&dataCapacity,&data->length,CUS ".",1);
1162 filter->pc+=2;
1163 }
1164 }
1165 else /* regular character */
1166 {
1167 data->character=string_cat(data->character,&dataCapacity,&data->length,filter->pc,1);
1168 filter->pc++;
1169 }
1170 }
1171 filter->errmsg=CUS "missing end of multi line string";
1172 return -1;
1173 }
1174else return 0;
1175}
1176
1177
1178/*************************************************
1179* Parse a specific identifier *
1180*************************************************/
1181
1182/*
1183Token definition:
1184 identifier = (ALPHA / "_") *(ALPHA DIGIT "_")
1185
1186Arguments:
1187 filter points to the Sieve filter including its state
1188 id specifies identifier to match
1189
1190Returns: 1 success
1191 0 identifier not matched
1192*/
1193
1194static int parse_identifier(struct Sieve *filter, const uschar *id)
1195{
1196 size_t idlen=Ustrlen(id);
1197
1198 if (Ustrncmp(filter->pc,id,idlen)==0)
1199 {
1200 uschar next=filter->pc[idlen];
1201
1202 if ((next>='A' && next<='Z') || (next>='a' && next<='z') || next=='_' || (next>='0' && next<='9')) return 0;
1203 filter->pc+=idlen;
1204 return 1;
1205 }
1206 else return 0;
1207}
1208
1209
1210/*************************************************
1211* Parse a number *
1212*************************************************/
1213
1214/*
1215Token definition:
1216 number = 1*DIGIT [QUANTIFIER]
1217 QUANTIFIER = "K" / "M" / "G"
1218
1219Arguments:
1220 filter points to the Sieve filter including its state
1221 data returns value
1222
1223Returns: 1 success
1224 -1 no string list found
1225*/
1226
1227static int parse_number(struct Sieve *filter, unsigned long *data)
1228{
1229unsigned long d,u;
1230
1231if (*filter->pc>='0' && *filter->pc<='9')
1232 {
1233 uschar *e;
1234
1235 errno=0;
1236 d=Ustrtoul(filter->pc,&e,10);
1237 if (errno==ERANGE)
1238 {
1239 filter->errmsg=CUstrerror(ERANGE);
1240 return -1;
1241 }
1242 filter->pc=e;
1243 u=1;
1244 if (*filter->pc=='K') { u=1024; ++filter->pc; }
1245 else if (*filter->pc=='M') { u=1024*1024; ++filter->pc; }
1246 else if (*filter->pc=='G') { u=1024*1024*1024; ++filter->pc; }
1247 if (d>(ULONG_MAX/u))
1248 {
1249 filter->errmsg=CUstrerror(ERANGE);
1250 return -1;
1251 }
1252 d*=u;
1253 *data=d;
1254 return 1;
1255 }
1256else
1257 {
1258 filter->errmsg=CUS "missing number";
1259 return -1;
1260 }
1261}
1262
1263
1264/*************************************************
1265* Parse a string list *
1266*************************************************/
1267
1268/*
1269Grammar:
1270 string-list = "[" string *("," string) "]" / string
1271
1272Arguments:
1273 filter points to the Sieve filter including its state
1274 data returns string list
1275
1276Returns: 1 success
1277 -1 no string list found
1278*/
1279
1280static int parse_stringlist(struct Sieve *filter, struct String **data)
1281{
1282const uschar *orig=filter->pc;
1283int dataCapacity=0;
1284int dataLength=0;
1285struct String *d=(struct String*)0;
1286int m;
1287
1288if (*filter->pc=='[') /* string list */
1289 {
1290 ++filter->pc;
1291 for (;;)
1292 {
1293 if (parse_white(filter)==-1) goto error;
1294 if ((dataLength+1)>=dataCapacity) /* increase buffer */
1295 {
1296 struct String *new;
1297 int newCapacity; /* Don't amalgamate with next line; some compilers grumble */
1298 newCapacity=dataCapacity?(dataCapacity*=2):(dataCapacity=4);
1299 if ((new=(struct String*)store_get(sizeof(struct String)*newCapacity))==(struct String*)0)
1300 {
1301 filter->errmsg=CUstrerror(errno);
1302 goto error;
1303 }
1304 if (d) memcpy(new,d,sizeof(struct String)*dataLength);
1305 d=new;
1306 dataCapacity=newCapacity;
1307 }
1308 m=parse_string(filter,&d[dataLength]);
1309 if (m==0)
1310 {
1311 if (dataLength==0) break;
1312 else
1313 {
1314 filter->errmsg=CUS "missing string";
1315 goto error;
1316 }
1317 }
1318 else if (m==-1) goto error;
1319 else ++dataLength;
1320 if (parse_white(filter)==-1) goto error;
1321 if (*filter->pc==',') ++filter->pc;
1322 else break;
1323 }
1324 if (*filter->pc==']')
1325 {
1326 d[dataLength].character=(uschar*)0;
1327 d[dataLength].length=-1;
1328 ++filter->pc;
1329 *data=d;
1330 return 1;
1331 }
1332 else
1333 {
1334 filter->errmsg=CUS "missing closing bracket";
1335 goto error;
1336 }
1337 }
1338else /* single string */
1339 {
1340 if ((d=store_get(sizeof(struct String)*2))==(struct String*)0)
1341 {
1342 return -1;
1343 }
1344 m=parse_string(filter,&d[0]);
1345 if (m==-1)
1346 {
1347 return -1;
1348 }
1349 else if (m==0)
1350 {
1351 filter->pc=orig;
1352 return 0;
1353 }
1354 else
1355 {
1356 d[1].character=(uschar*)0;
1357 d[1].length=-1;
1358 *data=d;
1359 return 1;
1360 }
1361 }
1362error:
1363filter->errmsg=CUS "missing string list";
1364return -1;
1365}
1366
1367
1368/*************************************************
1369* Parse an optional address part specifier *
1370*************************************************/
1371
1372/*
1373Grammar:
1374 address-part = ":localpart" / ":domain" / ":all"
1375 address-part =/ ":user" / ":detail"
1376
1377Arguments:
1378 filter points to the Sieve filter including its state
1379 a returns address part specified
1380
1381Returns: 1 success
1382 0 no comparator found
1383 -1 syntax error
1384*/
1385
1386static int parse_addresspart(struct Sieve *filter, enum AddressPart *a)
1387{
1388#ifdef SUBADDRESS
1389if (parse_identifier(filter,CUS ":user")==1)
1390 {
1391 if (!filter->require_subaddress)
1392 {
1393 filter->errmsg=CUS "missing previous require \"subaddress\";";
1394 return -1;
1395 }
1396 *a=ADDRPART_USER;
1397 return 1;
1398 }
1399else if (parse_identifier(filter,CUS ":detail")==1)
1400 {
1401 if (!filter->require_subaddress)
1402 {
1403 filter->errmsg=CUS "missing previous require \"subaddress\";";
1404 return -1;
1405 }
1406 *a=ADDRPART_DETAIL;
1407 return 1;
1408 }
1409else
1410#endif
1411if (parse_identifier(filter,CUS ":localpart")==1)
1412 {
1413 *a=ADDRPART_LOCALPART;
1414 return 1;
1415 }
1416else if (parse_identifier(filter,CUS ":domain")==1)
1417 {
1418 *a=ADDRPART_DOMAIN;
1419 return 1;
1420 }
1421else if (parse_identifier(filter,CUS ":all")==1)
1422 {
1423 *a=ADDRPART_ALL;
1424 return 1;
1425 }
1426else return 0;
1427}
1428
1429
1430/*************************************************
1431* Parse an optional comparator *
1432*************************************************/
1433
1434/*
1435Grammar:
1436 comparator = ":comparator" <comparator-name: string>
1437
1438Arguments:
1439 filter points to the Sieve filter including its state
1440 c returns comparator
1441
1442Returns: 1 success
1443 0 no comparator found
1444 -1 incomplete comparator found
1445*/
1446
1447static int parse_comparator(struct Sieve *filter, enum Comparator *c)
1448{
1449struct String comparator_name;
1450
1451if (parse_identifier(filter,CUS ":comparator")==0) return 0;
1452if (parse_white(filter)==-1) return -1;
1453switch (parse_string(filter,&comparator_name))
1454 {
1455 case -1: return -1;
1456 case 0:
1457 {
1458 filter->errmsg=CUS "missing comparator";
1459 return -1;
1460 }
1461 default:
1462 {
1463 int match;
1464
1465 if (eq_asciicase(&comparator_name,&str_ioctet,0))
1466 {
1467 *c=COMP_OCTET;
1468 match=1;
1469 }
1470 else if (eq_asciicase(&comparator_name,&str_iascii_casemap,0))
1471 {
1472 *c=COMP_ASCII_CASEMAP;
1473 match=1;
1474 }
1475 else if (eq_asciicase(&comparator_name,&str_iascii_numeric,0))
1476 {
1477 *c=COMP_ASCII_NUMERIC;
1478 match=1;
1479 }
1480 else
1481 {
1482 filter->errmsg=CUS "invalid comparator";
1483 match=-1;
1484 }
1485 return match;
1486 }
1487 }
1488}
1489
1490
1491/*************************************************
1492* Parse an optional match type *
1493*************************************************/
1494
1495/*
1496Grammar:
1497 match-type = ":is" / ":contains" / ":matches"
1498
1499Arguments:
1500 filter points to the Sieve filter including its state
1501 m returns match type
1502
1503Returns: 1 success
1504 0 no match type found
1505*/
1506
1507static int parse_matchtype(struct Sieve *filter, enum MatchType *m)
1508{
1509 if (parse_identifier(filter,CUS ":is")==1)
1510 {
1511 *m=MATCH_IS;
1512 return 1;
1513 }
1514 else if (parse_identifier(filter,CUS ":contains")==1)
1515 {
1516 *m=MATCH_CONTAINS;
1517 return 1;
1518 }
1519 else if (parse_identifier(filter,CUS ":matches")==1)
1520 {
1521 *m=MATCH_MATCHES;
1522 return 1;
1523 }
1524 else return 0;
1525}
1526
1527
1528/*************************************************
1529* Parse and interpret an optional test list *
1530*************************************************/
1531
1532/*
1533Grammar:
1534 test-list = "(" test *("," test) ")"
1535
1536Arguments:
1537 filter points to the Sieve filter including its state
1538 n total number of tests
1539 true number of passed tests
1540 exec Execute parsed statements
1541
1542Returns: 1 success
1543 0 no test list found
1544 -1 syntax or execution error
1545*/
1546
1547static int parse_testlist(struct Sieve *filter, int *n, int *true, int exec)
1548{
1549if (parse_white(filter)==-1) return -1;
1550if (*filter->pc=='(')
1551 {
1552 ++filter->pc;
1553 *n=0;
1554 *true=0;
1555 for (;;)
1556 {
1557 int cond;
1558
1559 switch (parse_test(filter,&cond,exec))
1560 {
1561 case -1: return -1;
1562 case 0: filter->errmsg=CUS "missing test"; return -1;
1563 default: ++*n; if (cond) ++*true; break;
1564 }
1565 if (parse_white(filter)==-1) return -1;
1566 if (*filter->pc==',') ++filter->pc;
1567 else break;
1568 }
1569 if (*filter->pc==')')
1570 {
1571 ++filter->pc;
1572 return 1;
1573 }
1574 else
1575 {
1576 filter->errmsg=CUS "missing closing paren";
1577 return -1;
1578 }
1579 }
1580else return 0;
1581}
1582
1583
1584/*************************************************
1585* Parse and interpret an optional test *
1586*************************************************/
1587
1588/*
1589Arguments:
1590 filter points to the Sieve filter including its state
1591 cond returned condition status
1592 exec Execute parsed statements
1593
1594Returns: 1 success
1595 0 no test found
1596 -1 syntax or execution error
1597*/
1598
1599static int parse_test(struct Sieve *filter, int *cond, int exec)
1600{
1601if (parse_white(filter)==-1) return -1;
1602if (parse_identifier(filter,CUS "address"))
1603 {
1604 /*
1605 address-test = "address" { [address-part] [comparator] [match-type] }
1606 <header-list: string-list> <key-list: string-list>
1607
1608 header-list From, To, Cc, Bcc, Sender, Resent-From, Resent-To
1609 */
1610
1611 enum AddressPart addressPart=ADDRPART_ALL;
1612 enum Comparator comparator=COMP_ASCII_CASEMAP;
1613 enum MatchType matchType=MATCH_IS;
1614 struct String *hdr,*h,*key,*k;
1615 int m;
1616 int ap=0,co=0,mt=0;
1617
1618 for (;;)
1619 {
1620 if (parse_white(filter)==-1) return -1;
1621 if ((m=parse_addresspart(filter,&addressPart))!=0)
1622 {
1623 if (m==-1) return -1;
1624 if (ap)
1625 {
1626 filter->errmsg=CUS "address part already specified";
1627 return -1;
1628 }
1629 else ap=1;
1630 }
1631 else if ((m=parse_comparator(filter,&comparator))!=0)
1632 {
1633 if (m==-1) return -1;
1634 if (co)
1635 {
1636 filter->errmsg=CUS "comparator already specified";
1637 return -1;
1638 }
1639 else co=1;
1640 }
1641 else if ((m=parse_matchtype(filter,&matchType))!=0)
1642 {
1643 if (m==-1) return -1;
1644 if (mt)
1645 {
1646 filter->errmsg=CUS "match type already specified";
1647 return -1;
1648 }
1649 else mt=1;
1650 }
1651 else break;
1652 }
1653 if (parse_white(filter)==-1) return -1;
1654 if ((m=parse_stringlist(filter,&hdr))!=1)
1655 {
1656 if (m==0) filter->errmsg=CUS "header string list expected";
1657 return -1;
1658 }
1659 if (parse_white(filter)==-1) return -1;
1660 if ((m=parse_stringlist(filter,&key))!=1)
1661 {
1662 if (m==0) filter->errmsg=CUS "key string list expected";
1663 return -1;
1664 }
1665 *cond=0;
1666 for (h=hdr; h->length!=-1 && !*cond; ++h)
1667 {
1668 uschar *header_value=(uschar*)0,*extracted_addr,*end_addr;
1669
1670 if
1671 (
1672 !eq_asciicase(h,&str_from,0)
1673 && !eq_asciicase(h,&str_to,0)
1674 && !eq_asciicase(h,&str_cc,0)
1675 && !eq_asciicase(h,&str_bcc,0)
1676 && !eq_asciicase(h,&str_sender,0)
1677 && !eq_asciicase(h,&str_resent_from,0)
1678 && !eq_asciicase(h,&str_resent_to,0)
1679 )
1680 {
1681 filter->errmsg=CUS "invalid header field";
1682 return -1;
1683 }
1684 if (exec)
1685 {
1686 /* We are only interested in addresses below, so no MIME decoding */
1687 header_value=expand_string(string_sprintf("$rheader_%s",quote(h)));
1688 if (header_value == NULL)
1689 {
1690 filter->errmsg=CUS "header string expansion failed";
1691 return -1;
1692 }
1693 parse_allow_group = TRUE;
1694 while (*header_value && !*cond)
1695 {
1696 uschar *error;
1697 int start, end, domain;
1698 int saveend;
1699 uschar *part=NULL;
1700
1701 end_addr = parse_find_address_end(header_value, FALSE);
1702 saveend = *end_addr;
1703 *end_addr = 0;
1704 extracted_addr = parse_extract_address(header_value, &error, &start, &end, &domain, FALSE);
1705
1706 if (extracted_addr) switch (addressPart)
1707 {
1708 case ADDRPART_ALL: part=extracted_addr; break;
1709#ifdef SUBADDRESS
1710 case ADDRPART_USER:
1711#endif
1712 case ADDRPART_LOCALPART: part=extracted_addr; part[domain-1]='\0'; break;
1713 case ADDRPART_DOMAIN: part=extracted_addr+domain; break;
1714#ifdef SUBADDRESS
1715 case ADDRPART_DETAIL:
1716 part=NULL;
1717#endif
1718 break;
1719 }
1720
1721 *end_addr = saveend;
1722 if (part)
1723 {
1724 for (k=key; k->length!=-1; ++k)
1725 {
1726 struct String partStr;
1727
1728 partStr.character=part;
1729 partStr.length=Ustrlen(part);
1730 if (extracted_addr)
1731 {
1732 *cond=compare(filter,k,&partStr,comparator,matchType);
1733 if (*cond==-1) return -1;
1734 if (*cond) break;
1735 }
1736 }
1737 }
1738 if (saveend == 0) break;
1739 header_value = end_addr + 1;
1740 }
1741 }
1742 }
1743 return 1;
1744 }
1745else if (parse_identifier(filter,CUS "allof"))
1746 {
1747 /*
1748 allof-test = "allof" <tests: test-list>
1749 */
1750
1751 int n,true;
1752
1753 switch (parse_testlist(filter,&n,&true,exec))
1754 {
1755 case -1: return -1;
1756 case 0: filter->errmsg=CUS "missing test list"; return -1;
1757 default: *cond=(n==true); return 1;
1758 }
1759 }
1760else if (parse_identifier(filter,CUS "anyof"))
1761 {
1762 /*
1763 anyof-test = "anyof" <tests: test-list>
1764 */
1765
1766 int n,true;
1767
1768 switch (parse_testlist(filter,&n,&true,exec))
1769 {
1770 case -1: return -1;
1771 case 0: filter->errmsg=CUS "missing test list"; return -1;
1772 default: *cond=(true>0); return 1;
1773 }
1774 }
1775else if (parse_identifier(filter,CUS "exists"))
1776 {
1777 /*
1778 exists-test = "exists" <header-names: string-list>
1779 */
1780
1781 struct String *hdr,*h;
1782 int m;
1783
1784 if (parse_white(filter)==-1) return -1;
1785 if ((m=parse_stringlist(filter,&hdr))!=1)
1786 {
1787 if (m==0) filter->errmsg=CUS "header string list expected";
1788 return -1;
1789 }
1790 if (exec)
1791 {
1792 *cond=1;
1793 for (h=hdr; h->length!=-1 && *cond; ++h)
1794 {
1795 uschar *header_def;
1796
1797 header_def=expand_string(string_sprintf("${if def:header_%s {true}{false}}",quote(h)));
1798 if (header_def == NULL)
1799 {
1800 filter->errmsg=CUS "header string expansion failed";
1801 return -1;
1802 }
1803 if (Ustrcmp(header_def,"false")==0) *cond=0;
1804 }
1805 }
1806 return 1;
1807 }
1808else if (parse_identifier(filter,CUS "false"))
1809 {
1810 /*
1811 false-test = "false"
1812 */
1813
1814 *cond=0;
1815 return 1;
1816 }
1817else if (parse_identifier(filter,CUS "header"))
1818 {
1819 /*
1820 header-test = "header" { [comparator] [match-type] }
1821 <header-names: string-list> <key-list: string-list>
1822 */
1823
1824 enum Comparator comparator=COMP_ASCII_CASEMAP;
1825 enum MatchType matchType=MATCH_IS;
1826 struct String *hdr,*h,*key,*k;
1827 int m;
1828 int co=0,mt=0;
1829
1830 for (;;)
1831 {
1832 if (parse_white(filter)==-1) return -1;
1833 if ((m=parse_comparator(filter,&comparator))!=0)
1834 {
1835 if (m==-1) return -1;
1836 if (co)
1837 {
1838 filter->errmsg=CUS "comparator already specified";
1839 return -1;
1840 }
1841 else co=1;
1842 }
1843 else if ((m=parse_matchtype(filter,&matchType))!=0)
1844 {
1845 if (m==-1) return -1;
1846 if (mt)
1847 {
1848 filter->errmsg=CUS "match type already specified";
1849 return -1;
1850 }
1851 else mt=1;
1852 }
1853 else break;
1854 }
1855 if (parse_white(filter)==-1) return -1;
1856 if ((m=parse_stringlist(filter,&hdr))!=1)
1857 {
1858 if (m==0) filter->errmsg=CUS "header string list expected";
1859 return -1;
1860 }
1861 if (parse_white(filter)==-1) return -1;
1862 if ((m=parse_stringlist(filter,&key))!=1)
1863 {
1864 if (m==0) filter->errmsg=CUS "key string list expected";
1865 return -1;
1866 }
1867 *cond=0;
1868 for (h=hdr; h->length!=-1 && !*cond; ++h)
1869 {
1870 if (!is_header(h))
1871 {
1872 filter->errmsg=CUS "invalid header field";
1873 return -1;
1874 }
1875 if (exec)
1876 {
1877 struct String header_value;
1878 uschar *header_def;
1879
1880 expand_header(&header_value,h);
1881 header_def=expand_string(string_sprintf("${if def:header_%s {true}{false}}",quote(h)));
1882 if (header_value.character == NULL || header_def == NULL)
1883 {
1884 filter->errmsg=CUS "header string expansion failed";
1885 return -1;
1886 }
1887 for (k=key; k->length!=-1; ++k)
1888 {
1889 if (Ustrcmp(header_def,"true")==0)
1890 {
1891 *cond=compare(filter,k,&header_value,comparator,matchType);
1892 if (*cond==-1) return -1;
1893 if (*cond) break;
1894 }
1895 }
1896 }
1897 }
1898 return 1;
1899 }
1900else if (parse_identifier(filter,CUS "not"))
1901 {
1902 if (parse_white(filter)==-1) return -1;
1903 switch (parse_test(filter,cond,exec))
1904 {
1905 case -1: return -1;
1906 case 0: filter->errmsg=CUS "missing test"; return -1;
1907 default: *cond=!*cond; return 1;
1908 }
1909 }
1910else if (parse_identifier(filter,CUS "size"))
1911 {
1912 /*
1913 relop = ":over" / ":under"
1914 size-test = "size" relop <limit: number>
1915 */
1916
1917 unsigned long limit;
1918 int overNotUnder;
1919
1920 if (parse_white(filter)==-1) return -1;
1921 if (parse_identifier(filter,CUS ":over")) overNotUnder=1;
1922 else if (parse_identifier(filter,CUS ":under")) overNotUnder=0;
1923 else
1924 {
1925 filter->errmsg=CUS "missing :over or :under";
1926 return -1;
1927 }
1928 if (parse_white(filter)==-1) return -1;
1929 if (parse_number(filter,&limit)==-1) return -1;
1930 *cond=(overNotUnder ? (message_size>limit) : (message_size<limit));
1931 return 1;
1932 }
1933else if (parse_identifier(filter,CUS "true"))
1934 {
1935 *cond=1;
1936 return 1;
1937 }
1938else if (parse_identifier(filter,CUS "envelope"))
1939 {
1940 /*
1941 envelope-test = "envelope" { [comparator] [address-part] [match-type] }
1942 <envelope-part: string-list> <key-list: string-list>
1943
1944 envelope-part is case insensitive "from" or "to"
1945 */
1946
1947 enum Comparator comparator=COMP_ASCII_CASEMAP;
1948 enum AddressPart addressPart=ADDRPART_ALL;
1949 enum MatchType matchType=MATCH_IS;
1950 struct String *env,*e,*key,*k;
1951 int m;
1952 int co=0,ap=0,mt=0;
1953
1954 if (!filter->require_envelope)
1955 {
1956 filter->errmsg=CUS "missing previous require \"envelope\";";
1957 return -1;
1958 }
1959 for (;;)
1960 {
1961 if (parse_white(filter)==-1) return -1;
1962 if ((m=parse_comparator(filter,&comparator))!=0)
1963 {
1964 if (m==-1) return -1;
1965 if (co)
1966 {
1967 filter->errmsg=CUS "comparator already specified";
1968 return -1;
1969 }
1970 else co=1;
1971 }
1972 else if ((m=parse_addresspart(filter,&addressPart))!=0)
1973 {
1974 if (m==-1) return -1;
1975 if (ap)
1976 {
1977 filter->errmsg=CUS "address part already specified";
1978 return -1;
1979 }
1980 else ap=1;
1981 }
1982 else if ((m=parse_matchtype(filter,&matchType))!=0)
1983 {
1984 if (m==-1) return -1;
1985 if (mt)
1986 {
1987 filter->errmsg=CUS "match type already specified";
1988 return -1;
1989 }
1990 else mt=1;
1991 }
1992 else break;
1993 }
1994 if (parse_white(filter)==-1) return -1;
1995 if ((m=parse_stringlist(filter,&env))!=1)
1996 {
1997 if (m==0) filter->errmsg=CUS "envelope string list expected";
1998 return -1;
1999 }
2000 if (parse_white(filter)==-1) return -1;
2001 if ((m=parse_stringlist(filter,&key))!=1)
2002 {
2003 if (m==0) filter->errmsg=CUS "key string list expected";
2004 return -1;
2005 }
2006 *cond=0;
2007 for (e=env; e->character; ++e)
2008 {
2009 const uschar *envelopeExpr=CUS 0;
2010 uschar *envelope=US 0;
2011
2012 if (eq_asciicase(e,&str_from,0))
2013 {
2014 switch (addressPart)
2015 {
2016 case ADDRPART_ALL: envelopeExpr=CUS "$sender_address"; break;
2017#ifdef SUBADDRESS
2018 case ADDRPART_USER:
2019#endif
2020 case ADDRPART_LOCALPART: envelopeExpr=CUS "${local_part:$sender_address}"; break;
2021 case ADDRPART_DOMAIN: envelopeExpr=CUS "${domain:$sender_address}"; break;
2022#ifdef SUBADDRESS
2023 case ADDRPART_DETAIL:
2024 envelopeExpr=CUS 0;
2025 break;
2026#endif
2027 }
2028 }
2029 else if (eq_asciicase(e,&str_to,0))
2030 {
2031 switch (addressPart)
2032 {
2033 case ADDRPART_ALL: envelopeExpr=CUS "$local_part_prefix$local_part$local_part_suffix@$domain"; break;
2034#ifdef SUBADDRESS
2035 case ADDRPART_USER: envelopeExpr=CUS "$local_part_prefix$local_part"; break;
2036 case ADDRPART_DETAIL: envelopeExpr=CUS "$local_part_suffix"; break;
2037#endif
2038 case ADDRPART_LOCALPART: envelopeExpr=CUS "$local_part_prefix$local_part$local_part_suffix"; break;
2039 case ADDRPART_DOMAIN: envelopeExpr=CUS "$domain"; break;
2040 }
2041 }
2042 else
2043 {
2044 filter->errmsg=CUS "invalid envelope string";
2045 return -1;
2046 }
2047 if (exec && envelopeExpr)
2048 {
2049 if ((envelope=expand_string(US envelopeExpr)) == NULL)
2050 {
2051 filter->errmsg=CUS "header string expansion failed";
2052 return -1;
2053 }
2054 for (k=key; k->length!=-1; ++k)
2055 {
2056 struct String envelopeStr;
2057
2058 envelopeStr.character=envelope;
2059 envelopeStr.length=Ustrlen(envelope);
2060 *cond=compare(filter,&envelopeStr,k,comparator,matchType);
2061 if (*cond==-1) return -1;
2062 if (*cond) break;
2063 }
2064 }
2065 }
2066 return 1;
2067 }
2068else return 0;
2069}
2070
2071
2072/*************************************************
2073* Parse and interpret an optional block *
2074*************************************************/
2075
2076/*
2077Arguments:
2078 filter points to the Sieve filter including its state
2079 exec Execute parsed statements
2080 generated where to hang newly-generated addresses
2081
2082Returns: 2 success by stop
2083 1 other success
2084 0 no block command found
2085 -1 syntax or execution error
2086*/
2087
2088static int parse_block(struct Sieve *filter, int exec,
2089 address_item **generated)
2090{
2091int r;
2092
2093if (parse_white(filter)==-1) return -1;
2094if (*filter->pc=='{')
2095 {
2096 ++filter->pc;
2097 if ((r=parse_commands(filter,exec,generated))==-1 || r==2) return r;
2098 if (*filter->pc=='}')
2099 {
2100 ++filter->pc;
2101 return 1;
2102 }
2103 else
2104 {
2105 filter->errmsg=CUS "missing closing brace";
2106 return -1;
2107 }
2108 }
2109else return 0;
2110}
2111
2112
2113/*************************************************
2114* Match a semicolon *
2115*************************************************/
2116
2117/*
2118Arguments:
2119 filter points to the Sieve filter including its state
2120
2121Returns: 1 success
2122 -1 syntax error
2123*/
2124
2125static int parse_semicolon(struct Sieve *filter)
2126{
2127 if (parse_white(filter)==-1) return -1;
2128 if (*filter->pc==';')
2129 {
2130 ++filter->pc;
2131 return 1;
2132 }
2133 else
2134 {
2135 filter->errmsg=CUS "missing semicolon";
2136 return -1;
2137 }
2138}
2139
2140
2141/*************************************************
2142* Parse and interpret a Sieve command *
2143*************************************************/
2144
2145/*
2146Arguments:
2147 filter points to the Sieve filter including its state
2148 exec Execute parsed statements
2149 generated where to hang newly-generated addresses
2150
2151Returns: 2 success by stop
2152 1 other success
2153 -1 syntax or execution error
2154*/
2155static int parse_commands(struct Sieve *filter, int exec,
2156 address_item **generated)
2157{
2158while (*filter->pc)
2159 {
2160 if (parse_white(filter)==-1) return -1;
2161 if (parse_identifier(filter,CUS "if"))
2162 {
2163 /*
2164 if-command = "if" test block *( "elsif" test block ) [ else block ]
2165 */
2166
2167 int cond,m,unsuccessful;
2168
2169 /* test block */
2170 if (parse_white(filter)==-1) return -1;
2171 if ((m=parse_test(filter,&cond,exec))==-1) return -1;
2172 if (m==0)
2173 {
2174 filter->errmsg=CUS "missing test";
2175 return -1;
2176 }
2177 m=parse_block(filter,exec ? cond : 0, generated);
2178 if (m==-1 || m==2) return m;
2179 if (m==0)
2180 {
2181 filter->errmsg=CUS "missing block";
2182 return -1;
2183 }
2184 unsuccessful = !cond;
2185 for (;;) /* elsif test block */
2186 {
2187 if (parse_white(filter)==-1) return -1;
2188 if (parse_identifier(filter,CUS "elsif"))
2189 {
2190 if (parse_white(filter)==-1) return -1;
2191 m=parse_test(filter,&cond,exec && unsuccessful);
2192 if (m==-1 || m==2) return m;
2193 if (m==0)
2194 {
2195 filter->errmsg=CUS "missing test";
2196 return -1;
2197 }
2198 m=parse_block(filter,exec && unsuccessful ? cond : 0, generated);
2199 if (m==-1 || m==2) return m;
2200 if (m==0)
2201 {
2202 filter->errmsg=CUS "missing block";
2203 return -1;
2204 }
2205 if (exec && unsuccessful && cond) unsuccessful = 0;
2206 }
2207 else break;
2208 }
2209 /* else block */
2210 if (parse_white(filter)==-1) return -1;
2211 if (parse_identifier(filter,CUS "else"))
2212 {
2213 m=parse_block(filter,exec && unsuccessful, generated);
2214 if (m==-1 || m==2) return m;
2215 if (m==0)
2216 {
2217 filter->errmsg=CUS "missing block";
2218 return -1;
2219 }
2220 }
2221 }
2222 else if (parse_identifier(filter,CUS "stop"))
2223 {
2224 /*
2225 stop-command = "stop" { stop-options } ";"
2226 stop-options =
2227 */
2228
2229 if (parse_semicolon(filter)==-1) return -1;
2230 if (exec)
2231 {
2232 filter->pc+=Ustrlen(filter->pc);
2233 return 2;
2234 }
2235 }
2236 else if (parse_identifier(filter,CUS "keep"))
2237 {
2238 /*
2239 keep-command = "keep" { keep-options } ";"
2240 keep-options =
2241 */
2242
2243 if (parse_semicolon(filter)==-1) return -1;
2244 if (exec)
2245 {
2246 add_addr(generated,US"inbox",1,0,0,0);
2247 filter->keep = 0;
2248 }
2249 }
2250 else if (parse_identifier(filter,CUS "discard"))
2251 {
2252 /*
2253 discard-command = "discard" { discard-options } ";"
2254 discard-options =
2255 */
2256
2257 if (parse_semicolon(filter)==-1) return -1;
2258 if (exec) filter->keep=0;
2259 }
2260 else if (parse_identifier(filter,CUS "redirect"))
2261 {
2262 /*
2263 redirect-command = "redirect" redirect-options "string" ";"
2264 redirect-options =
2265 redirect-options =) ":copy"
2266 */
2267
2268 struct String recipient;
2269 int m;
2270 int copy=0;
2271
2272 for (;;)
2273 {
2274 if (parse_white(filter)==-1) return -1;
2275 if (parse_identifier(filter,CUS ":copy")==1)
2276 {
2277 if (!filter->require_copy)
2278 {
2279 filter->errmsg=CUS "missing previous require \"copy\";";
2280 return -1;
2281 }
2282 copy=1;
2283 }
2284 else break;
2285 }
2286 if (parse_white(filter)==-1) return -1;
2287 if ((m=parse_string(filter,&recipient))!=1)
2288 {
2289 if (m==0) filter->errmsg=CUS "missing redirect recipient string";
2290 return -1;
2291 }
2292 if (strchr(CCS recipient.character,'@')==(char*)0)
2293 {
2294 filter->errmsg=CUS "unqualified recipient address";
2295 return -1;
2296 }
2297 if (exec)
2298 {
2299 add_addr(generated,recipient.character,0,0,0,0);
2300 if (!copy) filter->keep = 0;
2301 }
2302 if (parse_semicolon(filter)==-1) return -1;
2303 }
2304 else if (parse_identifier(filter,CUS "fileinto"))
2305 {
2306 /*
2307 fileinto-command = "fileinto" { fileinto-options } string ";"
2308 fileinto-options =
2309 fileinto-options =) [ ":copy" ]
2310 */
2311
2312 struct String folder;
2313 uschar *s;
2314 int m;
2315 unsigned long maxage, maxmessages, maxstorage;
2316 int copy=0;
2317
2318 maxage = maxmessages = maxstorage = 0;
2319 if (!filter->require_fileinto)
2320 {
2321 filter->errmsg=CUS "missing previous require \"fileinto\";";
2322 return -1;
2323 }
2324 for (;;)
2325 {
2326 if (parse_white(filter)==-1) return -1;
2327 if (parse_identifier(filter,CUS ":copy")==1)
2328 {
2329 if (!filter->require_copy)
2330 {
2331 filter->errmsg=CUS "missing previous require \"copy\";";
2332 return -1;
2333 }
2334 copy=1;
2335 }
2336 else break;
2337 }
2338 if (parse_white(filter)==-1) return -1;
2339 if ((m=parse_string(filter,&folder))!=1)
2340 {
2341 if (m==0) filter->errmsg=CUS "missing fileinto folder string";
2342 return -1;
2343 }
2344 m=0; s=folder.character;
2345 if (folder.length==0) m=1;
2346 if (Ustrcmp(s,"..")==0 || Ustrncmp(s,"../",3)==0) m=1;
2347 else while (*s)
2348 {
2349 if (Ustrcmp(s,"/..")==0 || Ustrncmp(s,"/../",4)==0) { m=1; break; }
2350 ++s;
2351 }
2352 if (m)
2353 {
2354 filter->errmsg=CUS "invalid folder";
2355 return -1;
2356 }
2357 if (exec)
2358 {
2359 add_addr(generated, folder.character, 1, maxage, maxmessages, maxstorage);
2360 if (!copy) filter->keep = 0;
2361 }
2362 if (parse_semicolon(filter)==-1) return -1;
2363 }
2364#ifdef VACATION
2365 else if (parse_identifier(filter,CUS "vacation"))
2366 {
2367 /*
2368 vacation-command = "vacation" { vacation-options } <reason: string> ";"
2369 vacation-options = [":days" number]
2370 [":addresses" string-list]
2371 [":subject" string]
2372 [":mime"]
2373 */
2374
2375 int m;
2376 unsigned long days;
2377 struct String *addresses=(struct String*)0;
2378 struct String subject;
2379 int reason_is_mime;
2380 string_item *aliases;
2381 struct String reason;
2382
2383 if (!filter->require_vacation)
2384 {
2385 filter->errmsg=CUS "missing previous require \"vacation\";";
2386 return -1;
2387 }
2388 if (exec)
2389 {
2390 if (filter->vacation_ran)
2391 {
2392 filter->errmsg=CUS "trying to execute vacation more than once";
2393 return -1;
2394 }
2395 filter->vacation_ran=1;
2396 }
2397 days=VACATION_MIN_DAYS>7 ? VACATION_MIN_DAYS : 7;
2398 subject.character=(uschar*)0;
2399 subject.length=-1;
2400 aliases=NULL;
2401 reason_is_mime=0;
2402 for (;;)
2403 {
2404 if (parse_white(filter)==-1) return -1;
2405 if (parse_identifier(filter,CUS ":days")==1)
2406 {
2407 if (parse_white(filter)==-1) return -1;
2408 if (parse_number(filter,&days)==-1) return -1;
2409 if (days<VACATION_MIN_DAYS) days=VACATION_MIN_DAYS;
2410 else if (days>VACATION_MAX_DAYS) days=VACATION_MAX_DAYS;
2411 }
2412 else if (parse_identifier(filter,CUS ":addresses")==1)
2413 {
2414 struct String *a;
2415
2416 if (parse_white(filter)==-1) return -1;
2417 if ((m=parse_stringlist(filter,&addresses))!=1)
2418 {
2419 if (m==0) filter->errmsg=CUS "addresses string list expected";
2420 return -1;
2421 }
2422 for (a=addresses; a->length!=-1; ++a)
2423 {
2424 string_item *new;
2425
2426 new=store_get(sizeof(string_item));
2427 new->text=store_get(a->length+1);
2428 if (a->length) memcpy(new->text,a->character,a->length);
2429 new->text[a->length]='\0';
2430 new->next=aliases;
2431 aliases=new;
2432 }
2433 }
2434 else if (parse_identifier(filter,CUS ":subject")==1)
2435 {
2436 if (parse_white(filter)==-1) return -1;
2437 if ((m=parse_string(filter,&subject))!=1)
2438 {
2439 if (m==0) filter->errmsg=CUS "subject string expected";
2440 return -1;
2441 }
2442 }
2443 else if (parse_identifier(filter,CUS ":mime")==1)
2444 reason_is_mime=1;
2445 else break;
2446 }
2447 if (parse_white(filter)==-1) return -1;
2448 if ((m=parse_string(filter,&reason))!=1)
2449 {
2450 if (m==0) filter->errmsg=CUS "missing reason string";
2451 return -1;
2452 }
2453 if (parse_semicolon(filter)==-1) return -1;
2454
2455 if (exec)
2456 {
2457 address_item *addr;
2458 int capacity,start;
2459 uschar *buffer;
2460 int buffer_capacity;
2461 struct String key;
2462 md5 base;
2463 uschar digest[16];
2464 uschar hexdigest[33];
2465 int i;
2466 uschar *once;
2467
2468 if (filter_personal(aliases,TRUE))
2469 {
2470
2471 /* ensure oncelog directory exists; failure will be detected later */
2472
2473 (void)directory_make(NULL, filter->vacation_directory, 0700, FALSE);
2474
2475 /* build oncelog filename */
2476
2477 key.character=(uschar*)0;
2478 key.length=0;
2479 capacity=0;
2480 if (subject.length!=-1) key.character=string_cat(key.character,&capacity,&key.length,subject.character,subject.length);
2481 key.character=string_cat(key.character,&capacity,&key.length,reason_is_mime?US"1":US"0",1);
2482 key.character=string_cat(key.character,&capacity,&key.length,reason.character,reason.length);
2483 md5_start(&base);
2484 md5_end(&base, key.character, key.length, digest);
2485 for (i = 0; i < 16; i++) sprintf(CS (hexdigest+2*i), "%02X", digest[i]);
2486 capacity=Ustrlen(filter->vacation_directory);
2487 start=capacity;
2488 once=string_cat(filter->vacation_directory,&capacity,&start,US"/",1);
2489 once=string_cat(once,&capacity,&start,hexdigest,33);
2490
2491 /* process subject */
2492
2493 if (subject.length==-1)
2494 {
2495 expand_header(&subject,&str_subject);
2496 while (subject.length>=4 && Ustrncmp(subject.character,"Re: ",4)==0)
2497 {
2498 subject.character+=4;
2499 subject.length-=4;
2500 }
2501 capacity=6;
2502 start=6;
2503 subject.character=string_cat(US"Auto: ",&capacity,&start,subject.character,subject.length);
2504 subject.length=start;
2505 }
2506
2507 /* add address to list of generated addresses */
2508
2509 addr = deliver_make_addr(string_sprintf(">%.256s", sender_address), FALSE);
2510 setflag(addr, af_pfr);
2511 setflag(addr, af_ignore_error);
2512 addr->next = *generated;
2513 *generated = addr;
2514 addr->reply = store_get(sizeof(reply_item));
2515 memset(addr->reply,0,sizeof(reply_item)); /* XXX */
2516 addr->reply->to = string_copy(sender_address);
2517 /* Allocation is larger than neccessary, but enough even for split MIME words */
2518 buffer_capacity=16+4*subject.length;
2519 buffer=store_get(buffer_capacity);
2520 addr->reply->subject=parse_quote_2047(subject.character, subject.length, US"utf-8", buffer, buffer_capacity);
2521 addr->reply->oncelog=once;
2522 addr->reply->once_repeat=days*86400;
2523
2524 /* build body and MIME headers */
2525
2526 if (reason_is_mime)
2527 {
2528 uschar *mime_body,*reason_end;
2529#ifdef RFC_EOL
2530 static const uschar nlnl[]="\r\n\r\n";
2531#else
2532 static const uschar nlnl[]="\n\n";
2533#endif
2534
2535 for
2536 (
2537 mime_body=reason.character,reason_end=reason.character+reason.length;
2538 mime_body<(reason_end-sizeof(nlnl)-1) && memcmp(mime_body,nlnl,sizeof(nlnl)-1);
2539 ++mime_body
2540 );
2541 capacity = 0;
2542 start = 0;
2543 addr->reply->headers = string_cat(NULL,&capacity,&start,reason.character,mime_body-reason.character);
2544 capacity = 0;
2545 start = 0;
2546 if (mime_body<reason_end) mime_body+=sizeof(nlnl)-1;
2547 addr->reply->text = string_cat(NULL,&capacity,&start,mime_body,reason_end-mime_body);
2548 }
2549 else
2550 {
2551 struct String qp;
2552
2553 capacity = 0;
2554 start = reason.length;
2555 addr->reply->headers = US"MIME-Version: 1.0\n"
2556 "Content-Type: text/plain;\n"
2557 "\tcharset=\"utf-8\"\n"
2558 "Content-Transfer-Encoding: quoted-printable";
2559 addr->reply->text = quoted_printable_encode(&reason,&qp)->character;
2560 }
2561 }
2562 }
2563 }
2564#endif
2565 else break;
2566 }
2567return 1;
2568}
2569
2570
2571/*************************************************
2572* Parse and interpret a sieve filter *
2573*************************************************/
2574
2575/*
2576Arguments:
2577 filter points to the Sieve filter including its state
2578 exec Execute parsed statements
2579 generated where to hang newly-generated addresses
2580
2581Returns: 1 success
2582 -1 syntax or execution error
2583*/
2584
2585static int parse_start(struct Sieve *filter, int exec,
2586 address_item **generated)
2587{
2588filter->pc=filter->filter;
2589filter->line=1;
2590filter->keep=1;
2591filter->require_envelope=0;
2592filter->require_fileinto=0;
2593#ifdef SUBADDRESS
2594filter->require_subaddress=0;
2595#endif
2596#ifdef VACATION
2597filter->require_vacation=0;
2598filter->vacation_ran=0;
2599#endif
2600filter->require_copy=0;
2601filter->require_iascii_numeric=0;
2602
2603if (parse_white(filter)==-1) return -1;
2604
2605if (exec && filter->vacation_directory != NULL) /* 2nd test added by PH */
2606 {
2607 DIR *oncelogdir;
2608 struct dirent *oncelog;
2609 struct stat properties;
2610 time_t now;
2611
2612 /* clean up old vacation log databases */
2613
2614 oncelogdir=opendir(CS filter->vacation_directory);
2615
2616 if (oncelogdir ==(DIR*)0 && errno != ENOENT)
2617 {
2618 filter->errmsg=CUS "unable to open vacation directory";
2619 return -1;
2620 }
2621
2622 if (oncelogdir != NULL)
2623 {
2624 time(&now);
2625
2626 while ((oncelog=readdir(oncelogdir))!=(struct dirent*)0)
2627 {
2628 if (strlen(oncelog->d_name)==32)
2629 {
2630 uschar *s=string_sprintf("%s/%s",filter->vacation_directory,oncelog->d_name);
2631 if (Ustat(s,&properties)==0 && (properties.st_mtime+VACATION_MAX_DAYS*86400)<now)
2632 Uunlink(s);
2633 }
2634 }
2635 closedir(oncelogdir);
2636 }
2637 }
2638
2639while (parse_identifier(filter,CUS "require"))
2640 {
2641 /*
2642 require-command = "require" <capabilities: string-list>
2643 */
2644
2645 struct String *cap,*check;
2646 int m;
2647
2648 if (parse_white(filter)==-1) return -1;
2649 if ((m=parse_stringlist(filter,&cap))!=1)
2650 {
2651 if (m==0) filter->errmsg=CUS "capability string list expected";
2652 return -1;
2653 }
2654 for (check=cap; check->character; ++check)
2655 {
2656 if (eq_asciicase(check,&str_envelope,0)) filter->require_envelope=1;
2657 else if (eq_asciicase(check,&str_fileinto,0)) filter->require_fileinto=1;
2658#ifdef SUBADDRESS
2659 else if (eq_asciicase(check,&str_subaddress,0)) filter->require_subaddress=1;
2660#endif
2661#ifdef VACATION
2662 else if (eq_asciicase(check,&str_vacation,0))
2663 {
2664 if (filter->vacation_directory == NULL)
2665 {
2666 filter->errmsg=CUS "vacation disabled";
2667 return -1;
2668 }
2669 filter->require_vacation=1;
2670 }
2671#endif
2672 else if (eq_asciicase(check,&str_copy,0)) filter->require_copy=1;
2673 else if (eq_asciicase(check,&str_comparator_ioctet,0)) ;
2674 else if (eq_asciicase(check,&str_comparator_iascii_casemap,0)) ;
2675 else if (eq_asciicase(check,&str_comparator_iascii_numeric,0)) filter->require_iascii_numeric=1;
2676 else
2677 {
2678 filter->errmsg=CUS "unknown capability";
2679 return -1;
2680 }
2681 }
2682 if (parse_semicolon(filter)==-1) return -1;
2683 }
2684 if (parse_commands(filter,exec,generated)==-1) return -1;
2685 if (*filter->pc)
2686 {
2687 filter->errmsg=CUS "syntax error";
2688 return -1;
2689 }
2690 return 1;
2691}
2692
2693
2694/*************************************************
2695* Interpret a sieve filter file *
2696*************************************************/
2697
2698/*
2699Arguments:
2700 filter points to the entire file, read into store as a single string
2701 options controls whether various special things are allowed, and requests
2702 special actions (not currently used)
2703 sieve_vacation_directory where to store vacation "once" files
2704 generated where to hang newly-generated addresses
2705 error where to pass back an error text
2706
2707Returns: FF_DELIVERED success, a significant action was taken
2708 FF_NOTDELIVERED success, no significant action
2709 FF_DEFER defer requested
2710 FF_FAIL fail requested
2711 FF_FREEZE freeze requested
2712 FF_ERROR there was a problem
2713*/
2714
2715int
2716sieve_interpret(uschar *filter, int options, uschar *vacation_directory,
2717 address_item **generated, uschar **error)
2718{
2719struct Sieve sieve;
2720int r;
2721uschar *msg;
2722
2723options = options; /* Keep picky compilers happy */
2724error = error;
2725
2726DEBUG(D_route) debug_printf("Sieve: start of processing\n");
2727sieve.filter=filter;
2728
2729if (vacation_directory == NULL)
2730 sieve.vacation_directory = NULL;
2731else
2732 {
2733 sieve.vacation_directory=expand_string(vacation_directory);
2734 if (sieve.vacation_directory == NULL)
2735 {
2736 *error = string_sprintf("failed to expand \"%s\" "
2737 "(sieve_vacation_directory): %s", vacation_directory,
2738 expand_string_message);
2739 return FF_ERROR;
2740 }
2741 }
2742
2743#ifdef COMPILE_SYNTAX_CHECKER
2744if (parse_start(&sieve,0,generated)==1)
2745#else
2746if (parse_start(&sieve,1,generated)==1)
2747#endif
2748 {
2749 if (sieve.keep)
2750 {
2751 add_addr(generated,US"inbox",1,0,0,0);
2752 msg = string_sprintf("Keep");
2753 r = FF_DELIVERED;
2754 }
2755 else
2756 {
2757 msg = string_sprintf("No keep");
2758 r = FF_DELIVERED;
2759 }
2760 }
2761else
2762 {
2763 msg = string_sprintf("Sieve error: %s in line %d",sieve.errmsg,sieve.line);
2764#ifdef COMPILE_SYNTAX_CHECKER
2765 r = FF_ERROR;
2766 *error = msg;
2767#else
2768 add_addr(generated,US"inbox",1,0,0,0);
2769 r = FF_DELIVERED;
2770#endif
2771 }
2772
2773#ifndef COMPILE_SYNTAX_CHECKER
f05da2e8 2774if (filter_test != FTEST_NONE) printf("%s\n", (const char*) msg);
059ec3d9
PH		 2775 else debug_printf("%s\n", msg);
2776#endif
2777
2778DEBUG(D_route) debug_printf("Sieve: end of processing\n");
2779return r;
2780}
Unnamed repository; edit this file 'description' to name the repository.