src/src/sieve.c

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