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