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