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