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