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