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