HCoop / hcoop / debian / exim4.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Import Debian changes 4.89-2+deb9u4
[hcoop/debian/exim4.git] / src / sieve.c
CommitLineData
420a0d19
CE		 1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
2813c06e
CE		 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 */
420a0d19
CE		 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
55struct 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
89enum Comparator { COMP_OCTET, COMP_EN_ASCII_CASEMAP, COMP_ASCII_NUMERIC };
90enum MatchType { MATCH_IS, MATCH_CONTAINS, MATCH_MATCHES };
91#ifdef SUBADDRESS
92enum AddressPart { ADDRPART_USER, ADDRPART_DETAIL, ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
93#else
94enum AddressPart { ADDRPART_LOCALPART, ADDRPART_DOMAIN, ADDRPART_ALL };
95#endif
96enum RelOp { LT, LE, EQ, GE, GT, NE };
97
98struct String
99 {
100 uschar *character;
101 int length;
102 };
103
104struct 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
113ManageSieve (RFC 5804) program can interrogate the current Exim binary for the
114list of extensions and provide correct information to a client.
115
116We'll emit the list in the order given here; keep it alphabetically sorted, so
117that callers don't get surprised.
118
119List *MUST* end with a NULL. Which at least makes ifdef-vs-comma easier. */
120
121const 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
144static int eq_asciicase(const struct String *needle, const struct String *haystack, int match_prefix);
145static int parse_test(struct Sieve *filter, int *cond, int exec);
146static int parse_commands(struct Sieve *filter, int exec, address_item **generated);
147
148static uschar str_from_c[]="From";
149static const struct String str_from={ str_from_c, 4 };
150static uschar str_to_c[]="To";
151static const struct String str_to={ str_to_c, 2 };
152static uschar str_cc_c[]="Cc";
153static const struct String str_cc={ str_cc_c, 2 };
154static uschar str_bcc_c[]="Bcc";
155static const struct String str_bcc={ str_bcc_c, 3 };
156static uschar str_auth_c[]="auth";
157static const struct String str_auth={ str_auth_c, 4 };
158static uschar str_sender_c[]="Sender";
159static const struct String str_sender={ str_sender_c, 6 };
160static uschar str_resent_from_c[]="Resent-From";
161static const struct String str_resent_from={ str_resent_from_c, 11 };
162static uschar str_resent_to_c[]="Resent-To";
163static const struct String str_resent_to={ str_resent_to_c, 9 };
164static uschar str_fileinto_c[]="fileinto";
165static const struct String str_fileinto={ str_fileinto_c, 8 };
166static uschar str_envelope_c[]="envelope";
167static const struct String str_envelope={ str_envelope_c, 8 };
168#ifdef ENCODED_CHARACTER
169static uschar str_encoded_character_c[]="encoded-character";
170static const struct String str_encoded_character={ str_encoded_character_c, 17 };
171#endif
172#ifdef ENVELOPE_AUTH
173static uschar str_envelope_auth_c[]="envelope-auth";
174static const struct String str_envelope_auth={ str_envelope_auth_c, 13 };
175#endif
176#ifdef ENOTIFY
177static uschar str_enotify_c[]="enotify";
178static const struct String str_enotify={ str_enotify_c, 7 };
179static uschar str_online_c[]="online";
180static const struct String str_online={ str_online_c, 6 };
181static uschar str_maybe_c[]="maybe";
182static const struct String str_maybe={ str_maybe_c, 5 };
183static uschar str_auto_submitted_c[]="Auto-Submitted";
184static const struct String str_auto_submitted={ str_auto_submitted_c, 14 };
185#endif
186#ifdef SUBADDRESS
187static uschar str_subaddress_c[]="subaddress";
188static const struct String str_subaddress={ str_subaddress_c, 10 };
189#endif
190#ifdef VACATION
191static uschar str_vacation_c[]="vacation";
192static const struct String str_vacation={ str_vacation_c, 8 };
193static uschar str_subject_c[]="Subject";
194static const struct String str_subject={ str_subject_c, 7 };
195#endif
196static uschar str_copy_c[]="copy";
197static const struct String str_copy={ str_copy_c, 4 };
198static uschar str_iascii_casemap_c[]="i;ascii-casemap";
199static const struct String str_iascii_casemap={ str_iascii_casemap_c, 15 };
200static uschar str_enascii_casemap_c[]="en;ascii-casemap";
201static const struct String str_enascii_casemap={ str_enascii_casemap_c, 16 };
202static uschar str_ioctet_c[]="i;octet";
203static const struct String str_ioctet={ str_ioctet_c, 7 };
204static uschar str_iascii_numeric_c[]="i;ascii-numeric";
205static const struct String str_iascii_numeric={ str_iascii_numeric_c, 15 };
206static uschar str_comparator_iascii_casemap_c[]="comparator-i;ascii-casemap";
207static const struct String str_comparator_iascii_casemap={ str_comparator_iascii_casemap_c, 26 };
208static uschar str_comparator_enascii_casemap_c[]="comparator-en;ascii-casemap";
209static const struct String str_comparator_enascii_casemap={ str_comparator_enascii_casemap_c, 27 };
210static uschar str_comparator_ioctet_c[]="comparator-i;octet";
211static const struct String str_comparator_ioctet={ str_comparator_ioctet_c, 18 };
212static uschar str_comparator_iascii_numeric_c[]="comparator-i;ascii-numeric";
213static const struct String str_comparator_iascii_numeric={ str_comparator_iascii_numeric_c, 26 };
214
215
216/*************************************************
217* Encode to quoted-printable *
218*************************************************/
219
220/*
221Arguments:
222 src UTF-8 string
223 dst US-ASCII string
224
225Returns
226 dst
227*/
228
229static struct String *quoted_printable_encode(const struct String *src, struct String *dst)
230{
231int pass;
232const uschar *start,*end;
233uschar *new = NULL;
234uschar ch;
235size_t line;
236
2813c06e
CE		 237/* Two passes: one to count output allocation size, second
238to do the encoding */
239
420a0d19
CE		 240for (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;
2813c06e 253 if (line>=73) /* line length limit */
420a0d19
CE		 254 {
255 if (pass==0)
256 dst->length+=2;
257 else
258 {
2813c06e 259 *new++='='; /* line split */
420a0d19
CE		 260 *new++='\n';
261 }
262 line=0;
263 }
2813c06e
CE		 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 )
420a0d19
CE		 271 {
272 if (pass==0)
273 ++dst->length;
274 else
2813c06e 275 *new++=*start; /* copy char */
420a0d19
CE		 276 ++line;
277 }
2813c06e 278 else if (ch=='\r' && start+1<end && *(start+1)=='\n') /* CRLF */
420a0d19
CE		 279 {
280 if (pass==0)
420a0d19 281 ++dst->length;
420a0d19 282 else
2813c06e
CE		 283 *new++='\n'; /* NL */
284 line=0;
285 ++start; /* consume extra input char */
420a0d19
CE		 286 }
287 else
288 {
289 if (pass==0)
290 dst->length+=3;
291 else
2813c06e
CE		 292 { /* encoded char */
293 new += sprintf(CS new,"=%02X",ch);
420a0d19
CE		 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/*
310Check mail address for being syntactically correct.
311
312Arguments:
313 filter points to the Sieve filter including its state
314 address String containing one address
315
316Returns
317 1 Mail address is syntactically OK
318 -1 syntax error
319*/
320
321int check_mail_address(struct Sieve *filter, const struct String *address)
322{
323int start, end, domain;
324uschar *error,*ss;
325
326if (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 }
339else
340 {
341 filter->errmsg=CUS "empty address";
342 return -1;
343 }
344}
345
346
347/*************************************************
348* Decode URI encoded string *
349*************************************************/
350
351/*
352Arguments:
353 str URI encoded string
354
355Returns
356 0 Decoding successful
357 -1 Encoding error
358*/
359
360#ifdef ENOTIFY
361static int uri_decode(struct String *str)
362{
363uschar *s,*t,*e;
364
365if (str->length==0) return 0;
366for (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';
382str->length=t-str->character;
383return 0;
384}
385
386
387/*************************************************
388* Parse mailto URI *
389*************************************************/
390
391/*
392Parse 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
401Arguments:
402 filter points to the Sieve filter including its state
403 uri URI, excluding scheme
404 recipient
405 body
406
407Returns
408 1 URI is syntactically OK
409 0 Unknown URI scheme
410 -1 syntax error
411*/
412
413static int parse_mailto_uri(struct Sieve *filter, const uschar *uri, string_item **recipient, struct String *header, struct String *subject, struct String *body)
414{
415const uschar *start;
2813c06e
CE		 416struct String to, hname;
417struct String hvalue = {NULL, 0};
420a0d19
CE		 418int capacity;
419string_item *new;
420
421if (Ustrncmp(uri,"mailto:",7))
422 {
423 filter->errmsg=US "Unknown URI scheme";
424 return 0;
425 }
2813c06e 426
420a0d19
CE		 427uri+=7;
428if (*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;
2813c06e 436 to.character= NULL;
420a0d19 437 to.length=0;
2813c06e 438 to.character=string_catn(to.character, &capacity, &to.length, start, uri-start);
420a0d19
CE		 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 }
460if (*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;
2813c06e 470 hname.character= NULL;
420a0d19 471 hname.length=0;
2813c06e 472 hname.character = string_catn(hname.character, &capacity, &hname.length, start, uri-start);
420a0d19
CE		 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;
2813c06e 493 hvalue.character= NULL;
420a0d19 494 hvalue.length=0;
2813c06e 495 hvalue.character=string_catn(hvalue.character,&capacity,&hvalue.length,start,uri-start);
420a0d19
CE		 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;
2813c06e
CE		 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);
420a0d19
CE		 538 header->character[header->length]='\0';
539 }
540 }
541 if (*uri=='&') ++uri;
542 else break;
543 }
544 }
545if (*uri)
546 {
547 filter->errmsg=US"Syntactically invalid URI";
548 return -1;
549 }
550return 1;
551}
552#endif
553
554
555/*************************************************
556* Octet-wise string comparison *
557*************************************************/
558
559/*
560Arguments:
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
565Returns: 0 needle not found in haystack
566 1 needle found
567*/
568
569static int eq_octet(const struct String *needle,
570 const struct String *haystack, int match_prefix)
571{
572size_t nl,hl;
573const uschar *n,*h;
574
575nl=needle->length;
576n=needle->character;
577hl=haystack->length;
578h=haystack->character;
579while (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 }
591return (match_prefix ? nl==0 : nl==0 && hl==0);
592}
593
594
595/*************************************************
596* ASCII case-insensitive string comparison *
597*************************************************/
598
599/*
600Arguments:
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
605Returns: 0 needle not found in haystack
606 1 needle found
607*/
608
609static int eq_asciicase(const struct String *needle,
610 const struct String *haystack, int match_prefix)
611{
612size_t nl,hl;
613const uschar *n,*h;
614uschar nc,hc;
615
616nl=needle->length;
617n=needle->character;
618hl=haystack->length;
619h=haystack->character;
620while (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 }
635return (match_prefix ? nl==0 : nl==0 && hl==0);
636}
637
638
639/*************************************************
640* Glob pattern search *
641*************************************************/
642
643/*
644Arguments:
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
650Returns: 0 needle not found in haystack
651 1 needle found
652 -1 pattern error
653*/
654
655static int eq_glob(const struct String *needle,
656 const struct String *haystack, int ascii_caseless, int match_octet)
657{
658const uschar *n,*h,*nend,*hend;
659int may_advance=0;
660
661n=needle->character;
662h=haystack->character;
663nend=n+needle->length;
664hend=h+haystack->length;
665while (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 }
749return (h==hend ? 1 : may_advance);
750}
751
752
753/*************************************************
754* ASCII numeric comparison *
755*************************************************/
756
757/*
758Arguments:
759 a first numeric string
760 b second numeric string
761 relop relational operator
762
763Returns: 0 not (a relop b)
764 1 a relop b
765*/
766
767static int eq_asciinumeric(const struct String *a,
768 const struct String *b, enum RelOp relop)
769{
770size_t al,bl;
771const uschar *as,*aend,*bs,*bend;
772int cmp;
773
774as=a->character;
775aend=a->character+a->length;
776bs=b->character;
777bend=b->character+b->length;
778
779while (*as>='0' && *as<='9' && as<aend) ++as;
780al=as-a->character;
781while (*bs>='0' && *bs<='9' && bs<bend) ++bs;
782bl=bs-b->character;
783
784if (al && bl==0) cmp=-1;
785else if (al==0 && bl==0) cmp=0;
786else if (al==0 && bl) cmp=1;
787else
788 {
789 cmp=al-bl;
790 if (cmp==0) cmp=memcmp(a->character,b->character,al);
791 }
792switch (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/*
811Arguments:
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
818Returns: 0 needle not found in haystack
819 1 needle found
820 -1 comparator does not offer matchtype
821*/
822
823static int compare(struct Sieve *filter, const struct String *needle, const struct String *haystack,
824 enum Comparator co, enum MatchType mt)
825{
826int r=0;
827
828if ((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 }
849switch (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 }
933if ((filter_test != FTEST_NONE && debug_selector != 0) ||
934 (debug_selector & D_filter) != 0)
935 debug_printf(" Result %s\n",r?"true":"false");
936return r;
937}
938
939
940/*************************************************
941* Check header field syntax *
942*************************************************/
943
944/*
945RFC 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
953That forbids 8-bit header fields. This implementation accepts them, since
954all of Exim is 8-bit clean, so it adds %d128-%d255.
955
956Arguments:
957 header header field to quote for suitable use in Exim expansions
958
959Returns: 0 string is not a valid header field
960 1 string is a value header field
961*/
962
963static int is_header(const struct String *header)
964{
965size_t l;
966const uschar *h;
967
968l=header->length;
969h=header->character;
970if (l==0) return 0;
971while (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 }
980return 1;
981}
982
983
984/*************************************************
985* Quote special characters string *
986*************************************************/
987
988/*
989Arguments:
990 header header field to quote for suitable use in Exim expansions
991 or as debug output
992
993Returns: quoted string
994*/
995
996static const uschar *quote(const struct String *header)
997{
998uschar *quoted=NULL;
999int size=0,ptr=0;
1000size_t l;
1001const uschar *h;
1002
1003l=header->length;
1004h=header->character;
1005while (l)
1006 {
1007 switch (*h)
1008 {
1009 case '\0':
1010 {
2813c06e 1011 quoted=string_catn(quoted,&size,&ptr,CUS "\\0",2);
420a0d19
CE		 1012 break;
1013 }
1014 case '$':
1015 case '{':
1016 case '}':
1017 {
2813c06e 1018 quoted=string_catn(quoted,&size,&ptr,CUS "\\",1);
420a0d19
CE		 1019 }
1020 default:
1021 {
2813c06e 1022 quoted=string_catn(quoted,&size,&ptr,h,1);
420a0d19
CE		 1023 }
1024 }
1025 ++h;
1026 --l;
1027 }
2813c06e 1028quoted=string_catn(quoted,&size,&ptr,CUS "",1);
420a0d19
CE		 1029return quoted;
1030}
1031
1032
1033/*************************************************
1034* Add address to list of generated addresses *
1035*************************************************/
1036
1037/*
1038According to RFC 5228, duplicate delivery to the same address must
1039not happen, so the list is first searched for the address.
1040
1041Arguments:
1042 generated list of generated addresses
1043 addr new address to add
1044 file address denotes a file
1045
1046Returns: nothing
1047*/
1048
1049static void add_addr(address_item **generated, uschar *addr, int file, int maxage, int maxmessages, int maxstorage)
1050{
1051address_item *new_addr;
1052
1053for (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
1065if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
1066 {
1067 debug_printf("%s `%s'\n",file ? "fileinto" : "redirect", addr);
1068 }
1069new_addr=deliver_make_addr(addr,TRUE);
1070if (file)
1071 {
1072 setflag(new_addr, af_pfr|af_file);
1073 new_addr->mode = 0;
1074 }
2813c06e 1075new_addr->prop.errors_address = NULL;
420a0d19
CE		 1076new_addr->next = *generated;
1077*generated = new_addr;
1078}
1079
1080
1081/*************************************************
1082* Return decoded header field *
1083*************************************************/
1084
1085/*
1086Unfold the header field as described in RFC 2822 and remove all
1087leading and trailing white space, then perform MIME decoding and
1088translate the header field to UTF-8.
1089
1090Arguments:
1091 value returned value of the field
1092 header name of the header field
1093
1094Returns: nothing The expanded string is empty
1095 in case there is no such header
1096*/
1097
1098static void expand_header(struct String *value, const struct String *header)
1099{
1100uschar *s,*r,*t;
1101uschar *errmsg;
1102
1103value->length=0;
1104value->character=(uschar*)0;
1105
1106t=r=s=expand_string(string_sprintf("$rheader_%s",quote(header)));
1107while (*r==' ' || *r=='\t') ++r;
1108while (*r)
1109 {
1110 if (*r=='\n')
1111 ++r;
1112 else
1113 *t++=*r++;
1114 }
1115while (t>s && (*(t-1)==' ' || *(t-1)=='\t')) --t;
1116*t='\0';
1117value->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/*
1126Token definition:
1127 Comment up to terminating CRLF
1128
1129Arguments:
1130 filter points to the Sieve filter including its state
1131
1132Returns: 1 success
1133 -1 syntax error
1134*/
1135
1136static int parse_hashcomment(struct Sieve *filter)
1137{
1138++filter->pc;
1139while (*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 }
1157filter->errmsg=CUS "missing end of comment";
1158return -1;
1159}
1160
1161
1162/*************************************************
1163* Parse remaining C-style comment *
1164*************************************************/
1165
1166/*
1167Token definition:
1168 Everything up to star slash
1169
1170Arguments:
1171 filter points to the Sieve filter including its state
1172
1173Returns: 1 success
1174 -1 syntax error
1175*/
1176
1177static 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/*
1199Token definition:
1200 Spaces, tabs, CRLFs, hash comments or C-style comments
1201
1202Arguments:
1203 filter points to the Sieve filter including its state
1204
1205Returns: 1 success
1206 -1 syntax error
1207*/
1208
1209static int parse_white(struct Sieve *filter)
1210{
1211while (*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 }
1237return 1;
1238}
1239
1240
1241#ifdef ENCODED_CHARACTER
1242/*************************************************
1243* Decode hex-encoded-character string *
1244*************************************************/
1245
1246/*
1247Encoding definition:
1248 blank = SP / TAB / CRLF
1249 hex-pair-seq = *blank hex-pair *(1*blank hex-pair) *blank
1250 hex-pair = 1*2HEXDIG
1251
1252Arguments:
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
1258Returns: >=0 number of decoded octets
1259 -1 syntax error
1260*/
1261
1262static int hex_decode(uschar *src, uschar *end, uschar *dst)
1263{
1264int decoded=0;
1265
1266while (*src==' ' || *src=='\t' || *src=='\n') ++src;
1267do
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 }
1281while (src<end);
1282return decoded;
1283}
1284
1285
1286/*************************************************
1287* Decode unicode-encoded-character string *
1288*************************************************/
1289
1290/*
1291Encoding 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
1302Arguments:
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
1308Returns: >=0 number of decoded octets
1309 -1 syntax error
1310 -2 semantic error (character range violation)
1311*/
1312
1313static int unicode_decode(uschar *src, uschar *end, uschar *dst)
1314{
1315int decoded=0;
1316
1317while (*src==' ' || *src=='\t' || *src=='\n') ++src;
1318do
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 }
1370while (src<end);
1371return decoded;
1372}
1373
1374
1375/*************************************************
1376* Decode encoded-character string *
1377*************************************************/
1378
1379/*
1380Encoding definition:
1381 encoded-arb-octets = "${hex:" hex-pair-seq "}"
1382 encoded-unicode-char = "${unicode:" unicode-hex-seq "}"
1383
1384Arguments:
1385 encoded points to an encoded string, returns decoded string
1386 filter points to the Sieve filter including its state
1387
1388Returns: 1 success
1389 -1 syntax error
1390*/
1391
1392static int string_decode(struct Sieve *filter, struct String *data)
1393{
1394uschar *src,*dst,*end;
1395
1396src=data->character;
1397dst=src;
1398end=data->character+data->length;
1399while (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';
1440return 1;
1441}
1442#endif
1443
1444
1445/*************************************************
1446* Parse an optional string *
1447*************************************************/
1448
1449/*
1450Token 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
1466Arguments:
1467 filter points to the Sieve filter including its state
1468 id specifies identifier to match
1469
1470Returns: 1 success
1471 -1 syntax error
1472 0 identifier not matched
1473*/
1474
1475static int parse_string(struct Sieve *filter, struct String *data)
1476{
1477int dataCapacity=0;
1478
1479data->length=0;
1480data->character=(uschar*)0;
1481if (*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 */
2813c06e 1492 data->character=string_catn(data->character,&dataCapacity,&foo,CUS "",1);
420a0d19
CE		 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 {
2813c06e 1502 data->character=string_catn(data->character,&dataCapacity,&data->length,filter->pc+1,1);
420a0d19
CE		 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 {
2813c06e 1512 data->character=string_catn(data->character,&dataCapacity,&data->length,US"\r",1);
420a0d19
CE		 1513 ++filter->line;
1514 }
1515#endif
2813c06e 1516 data->character=string_catn(data->character,&dataCapacity,&data->length,filter->pc,1);
420a0d19
CE		 1517 filter->pc++;
1518 }
1519 }
1520 filter->errmsg=CUS "missing end of string";
1521 return -1;
1522 }
1523else 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 {
2813c06e 1558 data->character=string_catn(data->character,&dataCapacity,&data->length,CUS "\r\n",2);
420a0d19
CE		 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 */
2813c06e 1574 data->character=string_catn(data->character,&dataCapacity,&foo,CUS "",1);
420a0d19
CE		 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 {
2813c06e 1590 data->character=string_catn(data->character,&dataCapacity,&data->length,CUS ".",1);
420a0d19
CE		 1591 filter->pc+=2;
1592 }
1593 }
1594 else /* regular character */
1595 {
2813c06e 1596 data->character=string_catn(data->character,&dataCapacity,&data->length,filter->pc,1);
420a0d19
CE		 1597 filter->pc++;
1598 }
1599 }
1600 filter->errmsg=CUS "missing end of multi line string";
1601 return -1;
1602 }
1603else return 0;
1604}
1605
1606
1607/*************************************************
1608* Parse a specific identifier *
1609*************************************************/
1610
1611/*
1612Token definition:
1613 identifier = (ALPHA / "_") *(ALPHA DIGIT "_")
1614
1615Arguments:
1616 filter points to the Sieve filter including its state
1617 id specifies identifier to match
1618
1619Returns: 1 success
1620 0 identifier not matched
1621*/
1622
1623static 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/*
1644Token definition:
1645 number = 1*DIGIT [QUANTIFIER]
1646 QUANTIFIER = "K" / "M" / "G"
1647
1648Arguments:
1649 filter points to the Sieve filter including its state
1650 data returns value
1651
1652Returns: 1 success
1653 -1 no string list found
1654*/
1655
1656static int parse_number(struct Sieve *filter, unsigned long *data)
1657{
1658unsigned long d,u;
1659
1660if (*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 }
1685else
1686 {
1687 filter->errmsg=CUS "missing number";
1688 return -1;
1689 }
1690}
1691
1692
1693/*************************************************
1694* Parse a string list *
1695*************************************************/
1696
1697/*
1698Grammar:
1699 string-list = "[" string *("," string) "]" / string
1700
1701Arguments:
1702 filter points to the Sieve filter including its state
1703 data returns string list
1704
1705Returns: 1 success
1706 -1 no string list found
1707*/
1708
2813c06e
CE		 1709static int
1710parse_stringlist(struct Sieve *filter, struct String **data)
420a0d19
CE		 1711{
1712const uschar *orig=filter->pc;
2813c06e
CE		 1713int dataCapacity = 0;
1714int dataLength = 0;
1715struct String *d = NULL;
420a0d19
CE		 1716int m;
1717
1718if (*filter->pc=='[') /* string list */
1719 {
1720 ++filter->pc;
1721 for (;;)
1722 {
1723 if (parse_white(filter)==-1) goto error;
2813c06e 1724 if (dataLength+1 >= dataCapacity) /* increase buffer */
420a0d19
CE		 1725 {
1726 struct String *new;
1727 int newCapacity; /* Don't amalgamate with next line; some compilers grumble */
2813c06e
CE		 1728
1729 dataCapacity = dataCapacity ? dataCapacity * 2 : 4;
1730 new = store_get(sizeof(struct String) * dataCapacity);
1731
420a0d19 1732 if (d) memcpy(new,d,sizeof(struct String)*dataLength);
2813c06e 1733 d = new;
420a0d19 1734 }
2813c06e 1735
420a0d19
CE		 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 }
1766else /* 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 }
1790error:
1791filter->errmsg=CUS "missing string list";
1792return -1;
1793}
1794
1795
1796/*************************************************
1797* Parse an optional address part specifier *
1798*************************************************/
1799
1800/*
1801Grammar:
1802 address-part = ":localpart" / ":domain" / ":all"
1803 address-part =/ ":user" / ":detail"
1804
1805Arguments:
1806 filter points to the Sieve filter including its state
1807 a returns address part specified
1808
1809Returns: 1 success
1810 0 no comparator found
1811 -1 syntax error
1812*/
1813
1814static int parse_addresspart(struct Sieve *filter, enum AddressPart *a)
1815{
1816#ifdef SUBADDRESS
1817if (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 }
1827else 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 }
1837else
1838#endif
1839if (parse_identifier(filter,CUS ":localpart")==1)
1840 {
1841 *a=ADDRPART_LOCALPART;
1842 return 1;
1843 }
1844else if (parse_identifier(filter,CUS ":domain")==1)
1845 {
1846 *a=ADDRPART_DOMAIN;
1847 return 1;
1848 }
1849else if (parse_identifier(filter,CUS ":all")==1)
1850 {
1851 *a=ADDRPART_ALL;
1852 return 1;
1853 }
1854else return 0;
1855}
1856
1857
1858/*************************************************
1859* Parse an optional comparator *
1860*************************************************/
1861
1862/*
1863Grammar:
1864 comparator = ":comparator" <comparator-name: string>
1865
1866Arguments:
1867 filter points to the Sieve filter including its state
1868 c returns comparator
1869
1870Returns: 1 success
1871 0 no comparator found
1872 -1 incomplete comparator found
1873*/
1874
1875static int parse_comparator(struct Sieve *filter, enum Comparator *c)
1876{
1877struct String comparator_name;
1878
1879if (parse_identifier(filter,CUS ":comparator")==0) return 0;
1880if (parse_white(filter)==-1) return -1;
1881switch (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/*
1929Grammar:
1930 match-type = ":is" / ":contains" / ":matches"
1931
1932Arguments:
1933 filter points to the Sieve filter including its state
1934 m returns match type
1935
1936Returns: 1 success
1937 0 no match type found
1938*/
1939
1940static 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/*
1966Grammar:
1967 test-list = "(" test *("," test) ")"
1968
1969Arguments:
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
1975Returns: 1 success
1976 0 no test list found
1977 -1 syntax or execution error
1978*/
1979
1980static int parse_testlist(struct Sieve *filter, int *n, int *num_true, int exec)
1981{
1982if (parse_white(filter)==-1) return -1;
1983if (*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 }
2013else return 0;
2014}
2015
2016
2017/*************************************************
2018* Parse and interpret an optional test *
2019*************************************************/
2020
2021/*
2022Arguments:
2023 filter points to the Sieve filter including its state
2024 cond returned condition status
2025 exec Execute parsed statements
2026
2027Returns: 1 success
2028 0 no test found
2029 -1 syntax or execution error
2030*/
2031
2032static int parse_test(struct Sieve *filter, int *cond, int exec)
2033{
2034if (parse_white(filter)==-1) return -1;
2035if (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 }
2178else 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 }
2193else 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 }
2208else 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 }
2241else if (parse_identifier(filter,CUS "false"))
2242 {
2243 /*
2244 false-test = "false"
2245 */
2246
2247 *cond=0;
2248 return 1;
2249 }
2250else 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 }
2333else 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 }
2343else 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 }
2366else if (parse_identifier(filter,CUS "true"))
2367 {
2368 *cond=1;
2369 return 1;
2370 }
2371else 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
2520else 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 }
2562else 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
2652else return 0;
2653}
2654
2655
2656/*************************************************
2657* Parse and interpret an optional block *
2658*************************************************/
2659
2660/*
2661Arguments:
2662 filter points to the Sieve filter including its state
2663 exec Execute parsed statements
2664 generated where to hang newly-generated addresses
2665
2666Returns: 2 success by stop
2667 1 other success
2668 0 no block command found
2669 -1 syntax or execution error
2670*/
2671
2672static int parse_block(struct Sieve *filter, int exec,
2673 address_item **generated)
2674{
2675int r;
2676
2677if (parse_white(filter)==-1) return -1;
2678if (*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 }
2693else return 0;
2694}
2695
2696
2697/*************************************************
2698* Match a semicolon *
2699*************************************************/
2700
2701/*
2702Arguments:
2703 filter points to the Sieve filter including its state
2704
2705Returns: 1 success
2706 -1 syntax error
2707*/
2708
2709static 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/*
2730Arguments:
2731 filter points to the Sieve filter including its state
2732 exec Execute parsed statements
2733 generated where to hang newly-generated addresses
2734
2735Returns: 2 success by stop
2736 1 other success
2737 -1 syntax or execution error
2738*/
2813c06e
CE		 2739static int
2740parse_commands(struct Sieve *filter, int exec, address_item **generated)
420a0d19
CE		 2741{
2742while (*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;
420a0d19
CE		 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;
420a0d19
CE		 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 }
2813c06e 3107 /* Allocation is larger than necessary, but enough even for split MIME words */
420a0d19
CE		 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 {
2813c06e
CE		 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);
420a0d19
CE		 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;
2813c06e
CE		 3319 once=string_catn(filter->vacation_directory,&capacity,&start,US"/",1);
3320 once=string_catn(once,&capacity,&start,hexdigest,33);
420a0d19
CE		 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;
2813c06e 3335 subject.character=string_catn(US"Auto: ",&capacity,&start,subject.character,subject.length);
420a0d19
CE		 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;
2813c06e 3359 /* Allocation is larger than necessary, but enough even for split MIME words */
420a0d19
CE		 3360 buffer_capacity=32+4*subject.length;
3361 buffer=store_get(buffer_capacity);
2813c06e
CE		 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);
420a0d19
CE		 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;
2813c06e 3382 addr->reply->headers = string_catn(NULL,&capacity,&start,reason.character,mime_body-reason.character);
420a0d19
CE		 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;
2813c06e 3388 addr->reply->text = string_catn(NULL,&capacity,&start,mime_body,reason_end-mime_body);
420a0d19
CE		 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 }
3414return 1;
3415}
3416
3417
3418/*************************************************
3419* Parse and interpret a sieve filter *
3420*************************************************/
3421
3422/*
3423Arguments:
3424 filter points to the Sieve filter including its state
3425 exec Execute parsed statements
3426 generated where to hang newly-generated addresses
3427
3428Returns: 1 success
3429 -1 syntax or execution error
3430*/
3431
3432static int
3433parse_start(struct Sieve *filter, int exec, address_item **generated)
3434{
3435filter->pc=filter->filter;
3436filter->line=1;
3437filter->keep=1;
3438filter->require_envelope=0;
3439filter->require_fileinto=0;
3440#ifdef ENCODED_CHARACTER
3441filter->require_encoded_character=0;
3442#endif
3443#ifdef ENVELOPE_AUTH
3444filter->require_envelope_auth=0;
3445#endif
3446#ifdef ENOTIFY
3447filter->require_enotify=0;
3448filter->notified=(struct Notification*)0;
3449#endif
3450#ifdef SUBADDRESS
3451filter->require_subaddress=0;
3452#endif
3453#ifdef VACATION
3454filter->require_vacation=0;
3455filter->vacation_ran=0;
3456#endif
3457filter->require_copy=0;
3458filter->require_iascii_numeric=0;
3459
3460if (parse_white(filter)==-1) return -1;
3461
3462if (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
3496while (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/*
3574Arguments:
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
3585Returns: 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
3593int
3594sieve_interpret(uschar *filter, int options, uschar *vacation_directory,
3595 uschar *enotify_mailto_owner, uschar *useraddress, uschar *subaddress,
3596 address_item **generated, uschar **error)
3597{
3598struct Sieve sieve;
3599int r;
3600uschar *msg;
3601
3602options = options; /* Keep picky compilers happy */
3603error = error;
3604
3605DEBUG(D_route) debug_printf("Sieve: start of processing\n");
3606sieve.filter=filter;
3607
3608if (vacation_directory == NULL)
3609 sieve.vacation_directory = NULL;
3610else
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
3622if (enotify_mailto_owner == NULL)
3623 sieve.enotify_mailto_owner = NULL;
3624else
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
3636sieve.useraddress = useraddress == NULL ? CUS "$local_part_prefix$local_part$local_part_suffix" : useraddress;
3637sieve.subaddress = subaddress;
3638
3639#ifdef COMPILE_SYNTAX_CHECKER
3640if (parse_start(&sieve,0,generated)==1)
3641#else
3642if (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 }
3657else
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
3670if (filter_test != FTEST_NONE) printf("%s\n", (const char*) msg);
3671 else debug_printf("%s\n", msg);
3672#endif
3673
3674DEBUG(D_route) debug_printf("Sieve: end of processing\n");
3675return r;
3676}
exim4 packaging