8e11af557f1d923d2769df1e58c231093c33097b
[exim.git] / src / src / sieve.c
1 /* $Cambridge: exim/src/src/sieve.c,v 1.4 2005/02/15 09:31:13 ph10 Exp $ */
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
48 struct 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
69 enum Comparator { COMP_OCTET, COMP_ASCII_CASEMAP, COMP_ASCII_NUMERIC };
70 enum MatchType { MATCH_IS, MATCH_CONTAINS, MATCH_MATCHES };
71 #ifdef SUBADDRESS
72 enum AddressPart { ADDRPART_USER, ADDRPART_DETAIL, ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
73 #else
74 enum AddressPart { ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
75 #endif
76 enum RelOp { LT, LE, EQ, GE, GT, NE };
77
78 struct String
79 {
80 uschar *character;
81 int length;
82 };
83
84 static int parse_test(struct Sieve *filter, int *cond, int exec);
85 static int parse_commands(struct Sieve *filter, int exec, address_item **generated);
86
87 static uschar str_from_c[]="From";
88 static const struct String str_from={ str_from_c, 4 };
89 static uschar str_to_c[]="To";
90 static const struct String str_to={ str_to_c, 2 };
91 static uschar str_cc_c[]="Cc";
92 static const struct String str_cc={ str_cc_c, 2 };
93 static uschar str_bcc_c[]="Bcc";
94 static const struct String str_bcc={ str_bcc_c, 3 };
95 static uschar str_sender_c[]="Sender";
96 static const struct String str_sender={ str_sender_c, 6 };
97 static uschar str_resent_from_c[]="Resent-From";
98 static const struct String str_resent_from={ str_resent_from_c, 11 };
99 static uschar str_resent_to_c[]="Resent-To";
100 static const struct String str_resent_to={ str_resent_to_c, 9 };
101 static uschar str_fileinto_c[]="fileinto";
102 static const struct String str_fileinto={ str_fileinto_c, 8 };
103 static uschar str_envelope_c[]="envelope";
104 static const struct String str_envelope={ str_envelope_c, 8 };
105 #ifdef SUBADDRESS
106 static uschar str_subaddress_c[]="subaddress";
107 static const struct String str_subaddress={ str_subaddress_c, 10 };
108 #endif
109 #ifdef VACATION
110 static uschar str_vacation_c[]="vacation";
111 static const struct String str_vacation={ str_vacation_c, 8 };
112 static uschar str_subject_c[]="Subject";
113 static const struct String str_subject={ str_subject_c, 7 };
114 #endif
115 static uschar str_copy_c[]="copy";
116 static const struct String str_copy={ str_copy_c, 4 };
117 static uschar str_iascii_casemap_c[]="i;ascii-casemap";
118 static const struct String str_iascii_casemap={ str_iascii_casemap_c, 15 };
119 static uschar str_ioctet_c[]="i;octet";
120 static const struct String str_ioctet={ str_ioctet_c, 7 };
121 static uschar str_iascii_numeric_c[]="i;ascii-numeric";
122 static const struct String str_iascii_numeric={ str_iascii_numeric_c, 15 };
123 static uschar str_comparator_iascii_casemap_c[]="comparator-i;ascii-casemap";
124 static const struct String str_comparator_iascii_casemap={ str_comparator_iascii_casemap_c, 26 };
125 static uschar str_comparator_ioctet_c[]="comparator-i;octet";
126 static const struct String str_comparator_ioctet={ str_comparator_ioctet_c, 18 };
127 static uschar str_comparator_iascii_numeric_c[]="comparator-i;ascii-numeric";
128 static const struct String str_comparator_iascii_numeric={ str_comparator_iascii_numeric_c, 26 };
129
130
131 /*************************************************
132 * Encode to quoted-printable *
133 *************************************************/
134
135 /*
136 Arguments:
137 src UTF-8 string
138 */
139
140 static struct String *quoted_printable_encode(const struct String *src, struct String *dst)
141 {
142 int pass;
143 const uschar *start,*end;
144 uschar *new = NULL;
145 uschar ch;
146 size_t line;
147
148 for (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 /*
241 Arguments:
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
246 Returns: 0 needle not found in haystack
247 1 needle found
248 */
249
250 static int eq_octet(const struct String *needle,
251 const struct String *haystack, int match_prefix)
252 {
253 size_t nl,hl;
254 const uschar *n,*h;
255
256 nl=needle->length;
257 n=needle->character;
258 hl=haystack->length;
259 h=haystack->character;
260 while (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 }
272 return (match_prefix ? nl==0 : nl==0 && hl==0);
273 }
274
275
276 /*************************************************
277 * ASCII case-insensitive string comparison *
278 *************************************************/
279
280 /*
281 Arguments:
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
286 Returns: 0 needle not found in haystack
287 1 needle found
288 */
289
290 static int eq_asciicase(const struct String *needle,
291 const struct String *haystack, int match_prefix)
292 {
293 size_t nl,hl;
294 const uschar *n,*h;
295 uschar nc,hc;
296
297 nl=needle->length;
298 n=needle->character;
299 hl=haystack->length;
300 h=haystack->character;
301 while (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 }
317 return (match_prefix ? nl==0 : nl==0 && hl==0);
318 }
319
320
321 /*************************************************
322 * Octet-wise glob pattern search *
323 *************************************************/
324
325 /*
326 Arguments:
327 needle pattern to search ...
328 haystack ... inside the haystack
329
330 Returns: 0 needle not found in haystack
331 1 needle found
332 */
333
334 static int eq_octetglob(const struct String *needle,
335 const struct String *haystack)
336 {
337 struct String n,h;
338
339 n=*needle;
340 h=*haystack;
341 while (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 }
421 return (h.length==0);
422 }
423
424
425 /*************************************************
426 * ASCII case-insensitive glob pattern search *
427 *************************************************/
428
429 /*
430 Arguments:
431 needle UTF-8 pattern to search ...
432 haystack ... inside the haystack
433
434 Returns: 0 needle not found in haystack
435 1 needle found
436 */
437
438 static int eq_asciicaseglob(const struct String *needle,
439 const struct String *haystack)
440 {
441 struct String n,h;
442
443 n=*needle;
444 h=*haystack;
445 while (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 }
556 return (h.length==0);
557 }
558
559
560 /*************************************************
561 * ASCII numeric comparison *
562 *************************************************/
563
564 /*
565 Arguments:
566 a first numeric string
567 b second numeric string
568 relop relational operator
569
570 Returns: 0 not (a relop b)
571 1 a relop b
572 */
573
574 static int eq_asciinumeric(const struct String *a,
575 const struct String *b, enum RelOp relop)
576 {
577 size_t al,bl;
578 const uschar *as,*aend,*bs,*bend;
579 int cmp;
580
581 as=a->character;
582 aend=a->character+a->length;
583 bs=b->character;
584 bend=b->character+b->length;
585
586 while (*as>='0' && *as<='9' && as<aend) ++as;
587 al=as-a->character;
588 while (*bs>='0' && *bs<='9' && bs<bend) ++bs;
589 bl=bs-b->character;
590
591 if (al && bl==0) cmp=-1;
592 else if (al==0 && bl==0) cmp=0;
593 else if (al==0 && bl) cmp=1;
594 else
595 {
596 cmp=al-bl;
597 if (cmp==0) cmp=memcmp(a->character,b->character,al);
598 }
599 switch (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 /*
618 Arguments:
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
624 Returns: 0 needle not found in haystack
625 1 needle found
626 -1 comparator does not offer matchtype
627 */
628
629 static int compare(struct Sieve *filter, const struct String *needle, const struct String *haystack,
630 enum Comparator co, enum MatchType mt)
631 {
632 int r=0;
633
634 if ((filter_test != FTEST_NONE && debug_selector != 0) ||
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 }
655 switch (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 }
731 if ((filter_test != FTEST_NONE && debug_selector != 0) ||
732 (debug_selector & D_filter) != 0)
733 debug_printf(" Result %s\n",r?"true":"false");
734 return r;
735 }
736
737
738 /*************************************************
739 * Check header field syntax *
740 *************************************************/
741
742 /*
743 RFC 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
751 That forbids 8-bit header fields. This implementation accepts them, since
752 all of Exim is 8-bit clean, so it adds %d128-%d255.
753
754 Arguments:
755 header header field to quote for suitable use in Exim expansions
756
757 Returns: 0 string is not a valid header field
758 1 string is a value header field
759 */
760
761 static int is_header(const struct String *header)
762 {
763 size_t l;
764 const uschar *h;
765
766 l=header->length;
767 h=header->character;
768 if (l==0) return 0;
769 while (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 }
778 return 1;
779 }
780
781
782 /*************************************************
783 * Quote special characters string *
784 *************************************************/
785
786 /*
787 Arguments:
788 header header field to quote for suitable use in Exim expansions
789 or as debug output
790
791 Returns: quoted string
792 */
793
794 static const uschar *quote(const struct String *header)
795 {
796 uschar *quoted=NULL;
797 int size=0,ptr=0;
798 size_t l;
799 const uschar *h;
800
801 l=header->length;
802 h=header->character;
803 while (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 }
826 quoted=string_cat(quoted,&size,&ptr,CUS "",1);
827 return quoted;
828 }
829
830
831 /*************************************************
832 * Add address to list of generated addresses *
833 *************************************************/
834
835 /*
836 According to RFC 3028, duplicate delivery to the same address must
837 not happen, so the list is first searched for the address.
838
839 Arguments:
840 generated list of generated addresses
841 addr new address to add
842 file address denotes a file
843
844 Returns: nothing
845 */
846
847 static void add_addr(address_item **generated, uschar *addr, int file, int maxage, int maxmessages, int maxstorage)
848 {
849 address_item *new_addr;
850
851 for (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 {
855 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
856 {
857 debug_printf("Repeated %s `%s' ignored.\n",file ? "fileinto" : "redirect", addr);
858 }
859 return;
860 }
861 }
862
863 if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
864 {
865 debug_printf("%s `%s'\n",file ? "fileinto" : "redirect", addr);
866 }
867 new_addr=deliver_make_addr(addr,TRUE);
868 if (file)
869 {
870 setflag(new_addr, af_pfr|af_file);
871 new_addr->mode = 0;
872 }
873 new_addr->p.errors_address = NULL;
874 new_addr->next = *generated;
875 *generated = new_addr;
876 }
877
878
879 /*************************************************
880 * Return decoded header field *
881 *************************************************/
882
883 /*
884 Arguments:
885 value returned value of the field
886 header name of the header field
887
888 Returns: nothing The expanded string is empty
889 in case there is no such header
890 */
891
892 static void expand_header(struct String *value, const struct String *header)
893 {
894 uschar *s,*r,*t;
895 uschar *errmsg;
896
897 value->length=0;
898 value->character=(uschar*)0;
899
900 t=r=s=expand_string(string_sprintf("$rheader_%s",quote(header)));
901 while (*r==' ') ++r;
902 while (*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';
914 value->character=rfc2047_decode(s,TRUE,US"utf-8",'\0',&value->length,&errmsg);
915 }
916
917
918 /*************************************************
919 * Parse remaining hash comment *
920 *************************************************/
921
922 /*
923 Token definition:
924 Comment up to terminating CRLF
925
926 Arguments:
927 filter points to the Sieve filter including its state
928
929 Returns: 1 success
930 -1 syntax error
931 */
932
933 static int parse_hashcomment(struct Sieve *filter)
934 {
935 ++filter->pc;
936 while (*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 }
954 filter->errmsg=CUS "missing end of comment";
955 return -1;
956 }
957
958
959 /*************************************************
960 * Parse remaining C-style comment *
961 *************************************************/
962
963 /*
964 Token definition:
965 Everything up to star slash
966
967 Arguments:
968 filter points to the Sieve filter including its state
969
970 Returns: 1 success
971 -1 syntax error
972 */
973
974 static 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 /*
996 Token definition:
997 Spaces, tabs, CRLFs, hash comments or C-style comments
998
999 Arguments:
1000 filter points to the Sieve filter including its state
1001
1002 Returns: 1 success
1003 -1 syntax error
1004 */
1005
1006 static int parse_white(struct Sieve *filter)
1007 {
1008 while (*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 }
1034 return 1;
1035 }
1036
1037
1038 /*************************************************
1039 * Parse a optional string *
1040 *************************************************/
1041
1042 /*
1043 Token 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
1059 Arguments:
1060 filter points to the Sieve filter including its state
1061 id specifies identifier to match
1062
1063 Returns: 1 success
1064 -1 syntax error
1065 0 identifier not matched
1066 */
1067
1068 static int parse_string(struct Sieve *filter, struct String *data)
1069 {
1070 int dataCapacity=0;
1071
1072 data->length=0;
1073 data->character=(uschar*)0;
1074 if (*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 }
1102 else 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 }
1174 else return 0;
1175 }
1176
1177
1178 /*************************************************
1179 * Parse a specific identifier *
1180 *************************************************/
1181
1182 /*
1183 Token definition:
1184 identifier = (ALPHA / "_") *(ALPHA DIGIT "_")
1185
1186 Arguments:
1187 filter points to the Sieve filter including its state
1188 id specifies identifier to match
1189
1190 Returns: 1 success
1191 0 identifier not matched
1192 */
1193
1194 static 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 /*
1215 Token definition:
1216 number = 1*DIGIT [QUANTIFIER]
1217 QUANTIFIER = "K" / "M" / "G"
1218
1219 Arguments:
1220 filter points to the Sieve filter including its state
1221 data returns value
1222
1223 Returns: 1 success
1224 -1 no string list found
1225 */
1226
1227 static int parse_number(struct Sieve *filter, unsigned long *data)
1228 {
1229 unsigned long d,u;
1230
1231 if (*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 }
1256 else
1257 {
1258 filter->errmsg=CUS "missing number";
1259 return -1;
1260 }
1261 }
1262
1263
1264 /*************************************************
1265 * Parse a string list *
1266 *************************************************/
1267
1268 /*
1269 Grammar:
1270 string-list = "[" string *("," string) "]" / string
1271
1272 Arguments:
1273 filter points to the Sieve filter including its state
1274 data returns string list
1275
1276 Returns: 1 success
1277 -1 no string list found
1278 */
1279
1280 static int parse_stringlist(struct Sieve *filter, struct String **data)
1281 {
1282 const uschar *orig=filter->pc;
1283 int dataCapacity=0;
1284 int dataLength=0;
1285 struct String *d=(struct String*)0;
1286 int m;
1287
1288 if (*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 }
1338 else /* 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 }
1362 error:
1363 filter->errmsg=CUS "missing string list";
1364 return -1;
1365 }
1366
1367
1368 /*************************************************
1369 * Parse an optional address part specifier *
1370 *************************************************/
1371
1372 /*
1373 Grammar:
1374 address-part = ":localpart" / ":domain" / ":all"
1375 address-part =/ ":user" / ":detail"
1376
1377 Arguments:
1378 filter points to the Sieve filter including its state
1379 a returns address part specified
1380
1381 Returns: 1 success
1382 0 no comparator found
1383 -1 syntax error
1384 */
1385
1386 static int parse_addresspart(struct Sieve *filter, enum AddressPart *a)
1387 {
1388 #ifdef SUBADDRESS
1389 if (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 }
1399 else 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 }
1409 else
1410 #endif
1411 if (parse_identifier(filter,CUS ":localpart")==1)
1412 {
1413 *a=ADDRPART_LOCALPART;
1414 return 1;
1415 }
1416 else if (parse_identifier(filter,CUS ":domain")==1)
1417 {
1418 *a=ADDRPART_DOMAIN;
1419 return 1;
1420 }
1421 else if (parse_identifier(filter,CUS ":all")==1)
1422 {
1423 *a=ADDRPART_ALL;
1424 return 1;
1425 }
1426 else return 0;
1427 }
1428
1429
1430 /*************************************************
1431 * Parse an optional comparator *
1432 *************************************************/
1433
1434 /*
1435 Grammar:
1436 comparator = ":comparator" <comparator-name: string>
1437
1438 Arguments:
1439 filter points to the Sieve filter including its state
1440 c returns comparator
1441
1442 Returns: 1 success
1443 0 no comparator found
1444 -1 incomplete comparator found
1445 */
1446
1447 static int parse_comparator(struct Sieve *filter, enum Comparator *c)
1448 {
1449 struct String comparator_name;
1450
1451 if (parse_identifier(filter,CUS ":comparator")==0) return 0;
1452 if (parse_white(filter)==-1) return -1;
1453 switch (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 /*
1496 Grammar:
1497 match-type = ":is" / ":contains" / ":matches"
1498
1499 Arguments:
1500 filter points to the Sieve filter including its state
1501 m returns match type
1502
1503 Returns: 1 success
1504 0 no match type found
1505 */
1506
1507 static 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 /*
1533 Grammar:
1534 test-list = "(" test *("," test) ")"
1535
1536 Arguments:
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
1542 Returns: 1 success
1543 0 no test list found
1544 -1 syntax or execution error
1545 */
1546
1547 static int parse_testlist(struct Sieve *filter, int *n, int *true, int exec)
1548 {
1549 if (parse_white(filter)==-1) return -1;
1550 if (*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 }
1580 else return 0;
1581 }
1582
1583
1584 /*************************************************
1585 * Parse and interpret an optional test *
1586 *************************************************/
1587
1588 /*
1589 Arguments:
1590 filter points to the Sieve filter including its state
1591 cond returned condition status
1592 exec Execute parsed statements
1593
1594 Returns: 1 success
1595 0 no test found
1596 -1 syntax or execution error
1597 */
1598
1599 static int parse_test(struct Sieve *filter, int *cond, int exec)
1600 {
1601 if (parse_white(filter)==-1) return -1;
1602 if (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 }
1745 else 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 }
1760 else 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 }
1775 else 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 }
1808 else if (parse_identifier(filter,CUS "false"))
1809 {
1810 /*
1811 false-test = "false"
1812 */
1813
1814 *cond=0;
1815 return 1;
1816 }
1817 else 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 }
1900 else 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 }
1910 else 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 }
1933 else if (parse_identifier(filter,CUS "true"))
1934 {
1935 *cond=1;
1936 return 1;
1937 }
1938 else 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 }
2068 else return 0;
2069 }
2070
2071
2072 /*************************************************
2073 * Parse and interpret an optional block *
2074 *************************************************/
2075
2076 /*
2077 Arguments:
2078 filter points to the Sieve filter including its state
2079 exec Execute parsed statements
2080 generated where to hang newly-generated addresses
2081
2082 Returns: 2 success by stop
2083 1 other success
2084 0 no block command found
2085 -1 syntax or execution error
2086 */
2087
2088 static int parse_block(struct Sieve *filter, int exec,
2089 address_item **generated)
2090 {
2091 int r;
2092
2093 if (parse_white(filter)==-1) return -1;
2094 if (*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 "expecting command or closing brace";
2106 return -1;
2107 }
2108 }
2109 else return 0;
2110 }
2111
2112
2113 /*************************************************
2114 * Match a semicolon *
2115 *************************************************/
2116
2117 /*
2118 Arguments:
2119 filter points to the Sieve filter including its state
2120
2121 Returns: 1 success
2122 -1 syntax error
2123 */
2124
2125 static 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 /*
2146 Arguments:
2147 filter points to the Sieve filter including its state
2148 exec Execute parsed statements
2149 generated where to hang newly-generated addresses
2150
2151 Returns: 2 success by stop
2152 1 other success
2153 -1 syntax or execution error
2154 */
2155 static int parse_commands(struct Sieve *filter, int exec,
2156 address_item **generated)
2157 {
2158 while (*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 addr->reply->from = expand_string(US"$local_part@$domain");
2518 /* Allocation is larger than neccessary, but enough even for split MIME words */
2519 buffer_capacity=16+4*subject.length;
2520 buffer=store_get(buffer_capacity);
2521 addr->reply->subject=parse_quote_2047(subject.character, subject.length, US"utf-8", buffer, buffer_capacity);
2522 addr->reply->oncelog=once;
2523 addr->reply->once_repeat=days*86400;
2524
2525 /* build body and MIME headers */
2526
2527 if (reason_is_mime)
2528 {
2529 uschar *mime_body,*reason_end;
2530 #ifdef RFC_EOL
2531 static const uschar nlnl[]="\r\n\r\n";
2532 #else
2533 static const uschar nlnl[]="\n\n";
2534 #endif
2535
2536 for
2537 (
2538 mime_body=reason.character,reason_end=reason.character+reason.length;
2539 mime_body<(reason_end-sizeof(nlnl)-1) && memcmp(mime_body,nlnl,sizeof(nlnl)-1);
2540 ++mime_body
2541 );
2542 capacity = 0;
2543 start = 0;
2544 addr->reply->headers = string_cat(NULL,&capacity,&start,reason.character,mime_body-reason.character);
2545 capacity = 0;
2546 start = 0;
2547 if (mime_body<reason_end) mime_body+=sizeof(nlnl)-1;
2548 addr->reply->text = string_cat(NULL,&capacity,&start,mime_body,reason_end-mime_body);
2549 }
2550 else
2551 {
2552 struct String qp;
2553
2554 capacity = 0;
2555 start = reason.length;
2556 addr->reply->headers = US"MIME-Version: 1.0\n"
2557 "Content-Type: text/plain;\n"
2558 "\tcharset=\"utf-8\"\n"
2559 "Content-Transfer-Encoding: quoted-printable";
2560 addr->reply->text = quoted_printable_encode(&reason,&qp)->character;
2561 }
2562 }
2563 }
2564 }
2565 #endif
2566 else break;
2567 }
2568 return 1;
2569 }
2570
2571
2572 /*************************************************
2573 * Parse and interpret a sieve filter *
2574 *************************************************/
2575
2576 /*
2577 Arguments:
2578 filter points to the Sieve filter including its state
2579 exec Execute parsed statements
2580 generated where to hang newly-generated addresses
2581
2582 Returns: 1 success
2583 -1 syntax or execution error
2584 */
2585
2586 static int parse_start(struct Sieve *filter, int exec,
2587 address_item **generated)
2588 {
2589 filter->pc=filter->filter;
2590 filter->line=1;
2591 filter->keep=1;
2592 filter->require_envelope=0;
2593 filter->require_fileinto=0;
2594 #ifdef SUBADDRESS
2595 filter->require_subaddress=0;
2596 #endif
2597 #ifdef VACATION
2598 filter->require_vacation=0;
2599 filter->vacation_ran=0;
2600 #endif
2601 filter->require_copy=0;
2602 filter->require_iascii_numeric=0;
2603
2604 if (parse_white(filter)==-1) return -1;
2605
2606 if (exec && filter->vacation_directory != NULL) /* 2nd test added by PH */
2607 {
2608 DIR *oncelogdir;
2609 struct dirent *oncelog;
2610 struct stat properties;
2611 time_t now;
2612
2613 /* clean up old vacation log databases */
2614
2615 oncelogdir=opendir(CS filter->vacation_directory);
2616
2617 if (oncelogdir ==(DIR*)0 && errno != ENOENT)
2618 {
2619 filter->errmsg=CUS "unable to open vacation directory";
2620 return -1;
2621 }
2622
2623 if (oncelogdir != NULL)
2624 {
2625 time(&now);
2626
2627 while ((oncelog=readdir(oncelogdir))!=(struct dirent*)0)
2628 {
2629 if (strlen(oncelog->d_name)==32)
2630 {
2631 uschar *s=string_sprintf("%s/%s",filter->vacation_directory,oncelog->d_name);
2632 if (Ustat(s,&properties)==0 && (properties.st_mtime+VACATION_MAX_DAYS*86400)<now)
2633 Uunlink(s);
2634 }
2635 }
2636 closedir(oncelogdir);
2637 }
2638 }
2639
2640 while (parse_identifier(filter,CUS "require"))
2641 {
2642 /*
2643 require-command = "require" <capabilities: string-list>
2644 */
2645
2646 struct String *cap,*check;
2647 int m;
2648
2649 if (parse_white(filter)==-1) return -1;
2650 if ((m=parse_stringlist(filter,&cap))!=1)
2651 {
2652 if (m==0) filter->errmsg=CUS "capability string list expected";
2653 return -1;
2654 }
2655 for (check=cap; check->character; ++check)
2656 {
2657 if (eq_asciicase(check,&str_envelope,0)) filter->require_envelope=1;
2658 else if (eq_asciicase(check,&str_fileinto,0)) filter->require_fileinto=1;
2659 #ifdef SUBADDRESS
2660 else if (eq_asciicase(check,&str_subaddress,0)) filter->require_subaddress=1;
2661 #endif
2662 #ifdef VACATION
2663 else if (eq_asciicase(check,&str_vacation,0))
2664 {
2665 if (filter->vacation_directory == NULL)
2666 {
2667 filter->errmsg=CUS "vacation disabled";
2668 return -1;
2669 }
2670 filter->require_vacation=1;
2671 }
2672 #endif
2673 else if (eq_asciicase(check,&str_copy,0)) filter->require_copy=1;
2674 else if (eq_asciicase(check,&str_comparator_ioctet,0)) ;
2675 else if (eq_asciicase(check,&str_comparator_iascii_casemap,0)) ;
2676 else if (eq_asciicase(check,&str_comparator_iascii_numeric,0)) filter->require_iascii_numeric=1;
2677 else
2678 {
2679 filter->errmsg=CUS "unknown capability";
2680 return -1;
2681 }
2682 }
2683 if (parse_semicolon(filter)==-1) return -1;
2684 }
2685 if (parse_commands(filter,exec,generated)==-1) return -1;
2686 if (*filter->pc)
2687 {
2688 filter->errmsg=CUS "syntax error";
2689 return -1;
2690 }
2691 return 1;
2692 }
2693
2694
2695 /*************************************************
2696 * Interpret a sieve filter file *
2697 *************************************************/
2698
2699 /*
2700 Arguments:
2701 filter points to the entire file, read into store as a single string
2702 options controls whether various special things are allowed, and requests
2703 special actions (not currently used)
2704 sieve_vacation_directory where to store vacation "once" files
2705 generated where to hang newly-generated addresses
2706 error where to pass back an error text
2707
2708 Returns: FF_DELIVERED success, a significant action was taken
2709 FF_NOTDELIVERED success, no significant action
2710 FF_DEFER defer requested
2711 FF_FAIL fail requested
2712 FF_FREEZE freeze requested
2713 FF_ERROR there was a problem
2714 */
2715
2716 int
2717 sieve_interpret(uschar *filter, int options, uschar *vacation_directory,
2718 address_item **generated, uschar **error)
2719 {
2720 struct Sieve sieve;
2721 int r;
2722 uschar *msg;
2723
2724 options = options; /* Keep picky compilers happy */
2725 error = error;
2726
2727 DEBUG(D_route) debug_printf("Sieve: start of processing\n");
2728 sieve.filter=filter;
2729
2730 if (vacation_directory == NULL)
2731 sieve.vacation_directory = NULL;
2732 else
2733 {
2734 sieve.vacation_directory=expand_string(vacation_directory);
2735 if (sieve.vacation_directory == NULL)
2736 {
2737 *error = string_sprintf("failed to expand \"%s\" "
2738 "(sieve_vacation_directory): %s", vacation_directory,
2739 expand_string_message);
2740 return FF_ERROR;
2741 }
2742 }
2743
2744 #ifdef COMPILE_SYNTAX_CHECKER
2745 if (parse_start(&sieve,0,generated)==1)
2746 #else
2747 if (parse_start(&sieve,1,generated)==1)
2748 #endif
2749 {
2750 if (sieve.keep)
2751 {
2752 add_addr(generated,US"inbox",1,0,0,0);
2753 msg = string_sprintf("Keep");
2754 r = FF_DELIVERED;
2755 }
2756 else
2757 {
2758 msg = string_sprintf("No keep");
2759 r = FF_DELIVERED;
2760 }
2761 }
2762 else
2763 {
2764 msg = string_sprintf("Sieve error: %s in line %d",sieve.errmsg,sieve.line);
2765 #ifdef COMPILE_SYNTAX_CHECKER
2766 r = FF_ERROR;
2767 *error = msg;
2768 #else
2769 add_addr(generated,US"inbox",1,0,0,0);
2770 r = FF_DELIVERED;
2771 #endif
2772 }
2773
2774 #ifndef COMPILE_SYNTAX_CHECKER
2775 if (filter_test != FTEST_NONE) printf("%s\n", (const char*) msg);
2776 else debug_printf("%s\n", msg);
2777 #endif
2778
2779 DEBUG(D_route) debug_printf("Sieve: end of processing\n");
2780 return r;
2781 }