src/src/sieve.c

   1 /* $Cambridge: exim/src/src/sieve.c,v 1.27 2007/04/12 09:00:52 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 #ifdef ENCODED_CHARACTER
1199 /*************************************************
1200 *       Decode encoded-character string          *
1201 *************************************************/
1202
1203 /*
1204 Encoding definition:
1205    hex-pair-seq         = hex-pair *(WSP hex-pair)
1206    hex-pair             = 1*2HEXDIG
1207
1208 Arguments:
1209   src         points to a hex-pair-seq
1210   end         points to its end
1211   dst         points to the destination of the decoded octets,
1212               optionally to (uschar*)0 for checking only
1213
1214 Returns:      >=0              number of decoded octets
1215               -1               syntax error
1216 */
1217
1218 static int hex_decode(uschar *src, uschar *end, uschar *dst)
1219 {
1220 int decoded=0;
1221
1222 while (src<end)
1223   {
1224   int l,h;
1225
1226   if (*src==' ' || *src=='\t') ++src;
1227   else if ((src+1)<end && isxdigit(h=tolower(*src)) && isxdigit(l=tolower(*(src+1))))
1228     {
1229     h=(h>='0' && h<='9') ? h-'0' : 10+(h-'a');
1230     l=(l>='0' && l<='9') ? l-'0' : 10+(l-'a');
1231     if (dst) *dst++=(h<<4)|l;
1232     ++decoded;
1233     src+=2;
1234     }
1235   else return -1;
1236   }
1237   return decoded;
1238 }
1239
1240
1241 /*************************************************
1242 *       Decode encoded-character string          *
1243 *************************************************/
1244
1245 /*
1246 Encoding definition:
1247    unicode-hex-seq      = unicode-hex *(WSP unicode-hex)
1248    unicode-hex          = 1*6HEXDIG
1249
1250    It is an error for a script to use a hexadecimal value that isn't in
1251    either the range 0 to D7FF or the range E000 to 10FFFF.
1252
1253 Arguments:
1254   src         points to a unicode-hex-seq
1255   end         points to its end
1256   dst         points to the destination of the decoded octets,
1257               optionally to (uschar*)0 for checking only
1258
1259 Returns:      >=0              number of decoded octets
1260               -1               syntax error
1261               -2               semantic error (character range violation)
1262 */
1263
1264 static int unicode_decode(uschar *src, uschar *end, uschar *dst)
1265 {
1266 int decoded=0;
1267
1268 while (src<end)
1269   {
1270   int c,n5,n4,n3,n2,n1,n0;
1271
1272   if (*src==' ' || *src=='\t') ++src;
1273   else if (
1274            (src+5)<end
1275            && isxdigit(n5=tolower(*src))
1276            && isxdigit(n4=tolower(*(src+1)))
1277            && isxdigit(n3=tolower(*(src+2)))
1278            && isxdigit(n2=tolower(*(src+3)))
1279            && isxdigit(n1=tolower(*(src+4)))
1280            && isxdigit(n0=tolower(*(src+5)))
1281           )
1282     {
1283     n5=(n5>='0' && n5<='9') ? n5-'0' : 10+(n5-'a');
1284     n4=(n4>='0' && n4<='9') ? n4-'0' : 10+(n4-'a');
1285     n3=(n3>='0' && n3<='9') ? n3-'0' : 10+(n3-'a');
1286     n2=(n2>='0' && n2<='9') ? n2-'0' : 10+(n2-'a');
1287     n1=(n1>='0' && n1<='9') ? n1-'0' : 10+(n1-'a');
1288     n0=(n0>='0' && n0<='9') ? n0-'0' : 10+(n0-'a');
1289     c=(n5<<24)|(n4<<16)|(n3<<12)|(n2<<8)|(n1<<4)|n0;
1290     if (!((c>=0 && c<=0xd7ff) || (c>=0xe000 && c<=0x10ffff))) return -2;
1291     if (c<128)
1292       {
1293       if (dst) *dst++=c;
1294       ++decoded;
1295       }
1296     else if (c>=0x80 && c<=0x7ff)
1297       {
1298         if (dst)
1299           {
1300           *dst++=192+(c>>6);
1301           *dst++=128+(c&0x3f);
1302           }
1303         decoded+=2;
1304       }
1305     else if (c>=0x800 && c<=0xffff)
1306       {
1307         if (dst)
1308           {
1309           *dst++=224+(c>>12);
1310           *dst++=128+((c>>6)&0x3f);
1311           *dst++=128+(c&0x3f);
1312           }
1313         decoded+=3;
1314       }
1315     else if (c>=0x10000 && c<=0x1fffff)
1316       {
1317         if (dst)
1318           {
1319           *dst++=240+(c>>18);
1320           *dst++=128+((c>>10)&0x3f);
1321           *dst++=128+((c>>6)&0x3f);
1322           *dst++=128+(c&0x3f);
1323           }
1324         decoded+=4;
1325       }
1326     src+=6;
1327     }
1328   else return -1;
1329   }
1330   return decoded;
1331 }
1332
1333
1334 /*************************************************
1335 *       Decode encoded-character string          *
1336 *************************************************/
1337
1338 /*
1339 Encoding definition:
1340    encoded-arb-octets   = "${hex:" hex-pair-seq "}"
1341    encoded-unicode-char = "${unicode:" unicode-hex-seq "}"
1342
1343 Arguments:
1344   encoded     points to an encoded string, returns decoded string
1345   filter      points to the Sieve filter including its state
1346
1347 Returns:      1                success
1348               -1               syntax error
1349 */
1350
1351 static int string_decode(struct Sieve *filter, struct String *data)
1352 {
1353 uschar *src,*dst,*end;
1354
1355 src=data->character;
1356 dst=src;
1357 end=data->character+data->length;
1358 while (src<end)
1359   {
1360   uschar *brace;
1361
1362   if (
1363       Ustrncmp(src,CUS "${hex:",6)==0
1364       && (brace=Ustrchr(src+6,'}'))!=(uschar*)0
1365       && (hex_decode(src+6,brace,(uschar*)0))>=0
1366      )
1367     {
1368     dst+=hex_decode(src+6,brace,dst);
1369     src=brace+1;
1370     }
1371   else if (
1372            Ustrncmp(src,CUS "${unicode:",10)==0
1373            && (brace=Ustrchr(src+10,'}'))!=(uschar*)0
1374           )
1375     {
1376     switch (unicode_decode(src+10,brace,(uschar*)0))
1377       {
1378       case -2:
1379         {
1380         filter->errmsg=CUS "unicode character out of range";
1381         return -1;
1382         }
1383       case -1:
1384         {
1385         *dst++=*src++;
1386         break;
1387         }
1388       default:
1389         {
1390         dst+=unicode_decode(src+10,brace,dst);
1391         src=brace+1;
1392         }
1393       }
1394     }
1395   else *dst++=*src++;
1396   }
1397   data->length=dst-data->character;
1398   *dst='\0';
1399 return 1;
1400 }
1401 #endif
1402
1403
1404 /*************************************************
1405 *          Parse an optional string              *
1406 *************************************************/
1407
1408 /*
1409 Token definition:
1410    quoted-string = DQUOTE *CHAR DQUOTE
1411            ;; in general, \ CHAR inside a string maps to CHAR
1412            ;; so \" maps to " and \\ maps to \
1413            ;; note that newlines and other characters are all allowed
1414            ;; in strings
1415
1416    multi-line          = "text:" *(SP / HTAB) (hash-comment / CRLF)
1417                          *(multi-line-literal / multi-line-dotstuff)
1418                          "." CRLF
1419    multi-line-literal  = [CHAR-NOT-DOT *CHAR-NOT-CRLF] CRLF
1420    multi-line-dotstuff = "." 1*CHAR-NOT-CRLF CRLF
1421            ;; A line containing only "." ends the multi-line.
1422            ;; Remove a leading '.' if followed by another '.'.
1423   string           = quoted-string / multi-line
1424
1425 Arguments:
1426   filter      points to the Sieve filter including its state
1427   id          specifies identifier to match
1428
1429 Returns:      1                success
1430               -1               syntax error
1431               0                identifier not matched
1432 */
1433
1434 static int parse_string(struct Sieve *filter, struct String *data)
1435 {
1436 int dataCapacity=0;
1437
1438 data->length=0;
1439 data->character=(uschar*)0;
1440 if (*filter->pc=='"') /* quoted string */
1441   {
1442   ++filter->pc;
1443   while (*filter->pc)
1444     {
1445     if (*filter->pc=='"') /* end of string */
1446       {
1447       int foo=data->length;
1448
1449       ++filter->pc;
1450       /* that way, there will be at least one character allocated */
1451       data->character=string_cat(data->character,&dataCapacity,&foo,CUS "",1);
1452 #ifdef ENCODED_CHARACTER
1453       if (filter->require_encoded_character
1454           && string_decode(filter,data)==-1)
1455         return -1;
1456 #endif
1457       return 1;
1458       }
1459     else if (*filter->pc=='\\' && *(filter->pc+1)) /* quoted character */
1460       {
1461       if (*(filter->pc+1)=='0') data->character=string_cat(data->character,&dataCapacity,&data->length,CUS "",1);
1462       else data->character=string_cat(data->character,&dataCapacity,&data->length,filter->pc+1,1);
1463       filter->pc+=2;
1464       }
1465     else /* regular character */
1466       {
1467 #ifdef RFC_EOL
1468       if (*filter->pc=='\r' && *(filter->pc+1)=='\n') ++filter->line;
1469 #else
1470       if (*filter->pc=='\n')
1471         {
1472         data->character=string_cat(data->character,&dataCapacity,&data->length,US"\r",1);
1473         ++filter->line;
1474         }
1475 #endif
1476       data->character=string_cat(data->character,&dataCapacity,&data->length,filter->pc,1);
1477       filter->pc++;
1478       }
1479     }
1480   filter->errmsg=CUS "missing end of string";
1481   return -1;
1482   }
1483 else if (Ustrncmp(filter->pc,CUS "text:",5)==0) /* multiline string */
1484   {
1485   filter->pc+=5;
1486   /* skip optional white space followed by hashed comment or CRLF */
1487   while (*filter->pc==' ' || *filter->pc=='\t') ++filter->pc;
1488   if (*filter->pc=='#')
1489     {
1490     if (parse_hashcomment(filter)==-1) return -1;
1491     }
1492 #ifdef RFC_EOL
1493   else if (*filter->pc=='\r' && *(filter->pc+1)=='\n')
1494 #else
1495   else if (*filter->pc=='\n')
1496 #endif
1497     {
1498 #ifdef RFC_EOL
1499     filter->pc+=2;
1500 #else
1501     ++filter->pc;
1502 #endif
1503     ++filter->line;
1504     }
1505   else
1506     {
1507     filter->errmsg=CUS "syntax error";
1508     return -1;
1509     }
1510   while (*filter->pc)
1511     {
1512 #ifdef RFC_EOL
1513     if (*filter->pc=='\r' && *(filter->pc+1)=='\n') /* end of line */
1514 #else
1515     if (*filter->pc=='\n') /* end of line */
1516 #endif
1517       {
1518       data->character=string_cat(data->character,&dataCapacity,&data->length,CUS "\r\n",2);
1519 #ifdef RFC_EOL
1520       filter->pc+=2;
1521 #else
1522       ++filter->pc;
1523 #endif
1524       ++filter->line;
1525 #ifdef RFC_EOL
1526       if (*filter->pc=='.' && *(filter->pc+1)=='\r' && *(filter->pc+2)=='\n') /* end of string */
1527 #else
1528       if (*filter->pc=='.' && *(filter->pc+1)=='\n') /* end of string */
1529 #endif
1530         {
1531         int foo=data->length;
1532
1533         /* that way, there will be at least one character allocated */
1534         data->character=string_cat(data->character,&dataCapacity,&foo,CUS "",1);
1535 #ifdef RFC_EOL
1536         filter->pc+=3;
1537 #else
1538         filter->pc+=2;
1539 #endif
1540         ++filter->line;
1541 #ifdef ENCODED_CHARACTER
1542         if (filter->require_encoded_character
1543             && string_decode(filter,data)==-1)
1544           return -1;
1545 #endif
1546         return 1;
1547         }
1548       else if (*filter->pc=='.' && *(filter->pc+1)=='.') /* remove dot stuffing */
1549         {
1550         data->character=string_cat(data->character,&dataCapacity,&data->length,CUS ".",1);
1551         filter->pc+=2;
1552         }
1553       }
1554     else /* regular character */
1555       {
1556       data->character=string_cat(data->character,&dataCapacity,&data->length,filter->pc,1);
1557       filter->pc++;
1558       }
1559     }
1560   filter->errmsg=CUS "missing end of multi line string";
1561   return -1;
1562   }
1563 else return 0;
1564 }
1565
1566
1567 /*************************************************
1568 *          Parse a specific identifier           *
1569 *************************************************/
1570
1571 /*
1572 Token definition:
1573   identifier       = (ALPHA / "_") *(ALPHA DIGIT "_")
1574
1575 Arguments:
1576   filter      points to the Sieve filter including its state
1577   id          specifies identifier to match
1578
1579 Returns:      1                success
1580               0                identifier not matched
1581 */
1582
1583 static int parse_identifier(struct Sieve *filter, const uschar *id)
1584 {
1585   size_t idlen=Ustrlen(id);
1586
1587   if (Ustrncmp(filter->pc,id,idlen)==0)
1588   {
1589     uschar next=filter->pc[idlen];
1590
1591     if ((next>='A' && next<='Z') || (next>='a' && next<='z') || next=='_' || (next>='0' && next<='9')) return 0;
1592     filter->pc+=idlen;
1593     return 1;
1594   }
1595   else return 0;
1596 }
1597
1598
1599 /*************************************************
1600 *                 Parse a number                 *
1601 *************************************************/
1602
1603 /*
1604 Token definition:
1605   number           = 1*DIGIT [QUANTIFIER]
1606   QUANTIFIER       = "K" / "M" / "G"
1607
1608 Arguments:
1609   filter      points to the Sieve filter including its state
1610   data        returns value
1611
1612 Returns:      1                success
1613               -1               no string list found
1614 */
1615
1616 static int parse_number(struct Sieve *filter, unsigned long *data)
1617 {
1618 unsigned long d,u;
1619
1620 if (*filter->pc>='0' && *filter->pc<='9')
1621   {
1622   uschar *e;
1623
1624   errno=0;
1625   d=Ustrtoul(filter->pc,&e,10);
1626   if (errno==ERANGE)
1627     {
1628     filter->errmsg=CUstrerror(ERANGE);
1629     return -1;
1630     }
1631   filter->pc=e;
1632   u=1;
1633   if (*filter->pc=='K') { u=1024; ++filter->pc; }
1634   else if (*filter->pc=='M') { u=1024*1024; ++filter->pc; }
1635   else if (*filter->pc=='G') { u=1024*1024*1024; ++filter->pc; }
1636   if (d>(ULONG_MAX/u))
1637     {
1638     filter->errmsg=CUstrerror(ERANGE);
1639     return -1;
1640     }
1641   d*=u;
1642   *data=d;
1643   return 1;
1644   }
1645 else
1646   {
1647   filter->errmsg=CUS "missing number";
1648   return -1;
1649   }
1650 }
1651
1652
1653 /*************************************************
1654 *              Parse a string list               *
1655 *************************************************/
1656
1657 /*
1658 Grammar:
1659   string-list      = "[" string *("," string) "]" / string
1660
1661 Arguments:
1662   filter      points to the Sieve filter including its state
1663   data        returns string list
1664
1665 Returns:      1                success
1666               -1               no string list found
1667 */
1668
1669 static int parse_stringlist(struct Sieve *filter, struct String **data)
1670 {
1671 const uschar *orig=filter->pc;
1672 int dataCapacity=0;
1673 int dataLength=0;
1674 struct String *d=(struct String*)0;
1675 int m;
1676
1677 if (*filter->pc=='[') /* string list */
1678   {
1679   ++filter->pc;
1680   for (;;)
1681     {
1682     if (parse_white(filter)==-1) goto error;
1683     if ((dataLength+1)>=dataCapacity) /* increase buffer */
1684       {
1685       struct String *new;
1686       int newCapacity;          /* Don't amalgamate with next line; some compilers grumble */
1687       newCapacity=dataCapacity?(dataCapacity*=2):(dataCapacity=4);
1688       if ((new=(struct String*)store_get(sizeof(struct String)*newCapacity))==(struct String*)0)
1689         {
1690         filter->errmsg=CUstrerror(errno);
1691         goto error;
1692         }
1693       if (d) memcpy(new,d,sizeof(struct String)*dataLength);
1694       d=new;
1695       dataCapacity=newCapacity;
1696       }
1697     m=parse_string(filter,&d[dataLength]);
1698     if (m==0)
1699       {
1700       if (dataLength==0) break;
1701       else
1702         {
1703         filter->errmsg=CUS "missing string";
1704         goto error;
1705         }
1706       }
1707     else if (m==-1) goto error;
1708     else ++dataLength;
1709     if (parse_white(filter)==-1) goto error;
1710     if (*filter->pc==',') ++filter->pc;
1711     else break;
1712     }
1713   if (*filter->pc==']')
1714     {
1715     d[dataLength].character=(uschar*)0;
1716     d[dataLength].length=-1;
1717     ++filter->pc;
1718     *data=d;
1719     return 1;
1720     }
1721   else
1722     {
1723     filter->errmsg=CUS "missing closing bracket";
1724     goto error;
1725     }
1726   }
1727 else /* single string */
1728   {
1729   if ((d=store_get(sizeof(struct String)*2))==(struct String*)0)
1730     {
1731     return -1;
1732     }
1733   m=parse_string(filter,&d[0]);
1734   if (m==-1)
1735     {
1736     return -1;
1737     }
1738   else if (m==0)
1739     {
1740     filter->pc=orig;
1741     return 0;
1742     }
1743   else
1744     {
1745     d[1].character=(uschar*)0;
1746     d[1].length=-1;
1747     *data=d;
1748     return 1;
1749     }
1750   }
1751 error:
1752 filter->errmsg=CUS "missing string list";
1753 return -1;
1754 }
1755
1756
1757 /*************************************************
1758 *    Parse an optional address part specifier    *
1759 *************************************************/
1760
1761 /*
1762 Grammar:
1763   address-part     =  ":localpart" / ":domain" / ":all"
1764   address-part     =/ ":user" / ":detail"
1765
1766 Arguments:
1767   filter      points to the Sieve filter including its state
1768   a           returns address part specified
1769
1770 Returns:      1                success
1771               0                no comparator found
1772               -1               syntax error
1773 */
1774
1775 static int parse_addresspart(struct Sieve *filter, enum AddressPart *a)
1776 {
1777 #ifdef SUBADDRESS
1778 if (parse_identifier(filter,CUS ":user")==1)
1779   {
1780   if (!filter->require_subaddress)
1781     {
1782     filter->errmsg=CUS "missing previous require \"subaddress\";";
1783     return -1;
1784     }
1785   *a=ADDRPART_USER;
1786   return 1;
1787   }
1788 else if (parse_identifier(filter,CUS ":detail")==1)
1789   {
1790   if (!filter->require_subaddress)
1791     {
1792     filter->errmsg=CUS "missing previous require \"subaddress\";";
1793     return -1;
1794     }
1795   *a=ADDRPART_DETAIL;
1796   return 1;
1797   }
1798 else
1799 #endif
1800 if (parse_identifier(filter,CUS ":localpart")==1)
1801   {
1802   *a=ADDRPART_LOCALPART;
1803   return 1;
1804   }
1805 else if (parse_identifier(filter,CUS ":domain")==1)
1806   {
1807   *a=ADDRPART_DOMAIN;
1808   return 1;
1809   }
1810 else if (parse_identifier(filter,CUS ":all")==1)
1811   {
1812   *a=ADDRPART_ALL;
1813   return 1;
1814   }
1815 else return 0;
1816 }
1817
1818
1819 /*************************************************
1820 *         Parse an optional comparator           *
1821 *************************************************/
1822
1823 /*
1824 Grammar:
1825   comparator = ":comparator" <comparator-name: string>
1826
1827 Arguments:
1828   filter      points to the Sieve filter including its state
1829   c           returns comparator
1830
1831 Returns:      1                success
1832               0                no comparator found
1833               -1               incomplete comparator found
1834 */
1835
1836 static int parse_comparator(struct Sieve *filter, enum Comparator *c)
1837 {
1838 struct String comparator_name;
1839
1840 if (parse_identifier(filter,CUS ":comparator")==0) return 0;
1841 if (parse_white(filter)==-1) return -1;
1842 switch (parse_string(filter,&comparator_name))
1843   {
1844   case -1: return -1;
1845   case 0:
1846     {
1847     filter->errmsg=CUS "missing comparator";
1848     return -1;
1849     }
1850   default:
1851     {
1852     int match;
1853
1854     if (eq_asciicase(&comparator_name,&str_ioctet,0))
1855       {
1856       *c=COMP_OCTET;
1857       match=1;
1858       }
1859     else if (eq_asciicase(&comparator_name,&str_iascii_casemap,0))
1860       {
1861       *c=COMP_EN_ASCII_CASEMAP;
1862       match=1;
1863       }
1864     else if (eq_asciicase(&comparator_name,&str_enascii_casemap,0))
1865       {
1866       *c=COMP_EN_ASCII_CASEMAP;
1867       match=1;
1868       }
1869     else if (eq_asciicase(&comparator_name,&str_iascii_numeric,0))
1870       {
1871       *c=COMP_ASCII_NUMERIC;
1872       match=1;
1873       }
1874     else
1875       {
1876       filter->errmsg=CUS "invalid comparator";
1877       match=-1;
1878       }
1879     return match;
1880     }
1881   }
1882 }
1883
1884
1885 /*************************************************
1886 *          Parse an optional match type          *
1887 *************************************************/
1888
1889 /*
1890 Grammar:
1891   match-type = ":is" / ":contains" / ":matches"
1892
1893 Arguments:
1894   filter      points to the Sieve filter including its state
1895   m           returns match type
1896
1897 Returns:      1                success
1898               0                no match type found
1899 */
1900
1901 static int parse_matchtype(struct Sieve *filter, enum MatchType *m)
1902 {
1903   if (parse_identifier(filter,CUS ":is")==1)
1904   {
1905     *m=MATCH_IS;
1906     return 1;
1907   }
1908   else if (parse_identifier(filter,CUS ":contains")==1)
1909   {
1910     *m=MATCH_CONTAINS;
1911     return 1;
1912   }
1913   else if (parse_identifier(filter,CUS ":matches")==1)
1914   {
1915     *m=MATCH_MATCHES;
1916     return 1;
1917   }
1918   else return 0;
1919 }
1920
1921
1922 /*************************************************
1923 *   Parse and interpret an optional test list    *
1924 *************************************************/
1925
1926 /*
1927 Grammar:
1928   test-list = "(" test *("," test) ")"
1929
1930 Arguments:
1931   filter      points to the Sieve filter including its state
1932   n           total number of tests
1933   true        number of passed tests
1934   exec        Execute parsed statements
1935
1936 Returns:      1                success
1937               0                no test list found
1938               -1               syntax or execution error
1939 */
1940
1941 static int parse_testlist(struct Sieve *filter, int *n, int *true, int exec)
1942 {
1943 if (parse_white(filter)==-1) return -1;
1944 if (*filter->pc=='(')
1945   {
1946   ++filter->pc;
1947   *n=0;
1948    *true=0;
1949   for (;;)
1950     {
1951     int cond;
1952
1953     switch (parse_test(filter,&cond,exec))
1954       {
1955       case -1: return -1;
1956       case 0: filter->errmsg=CUS "missing test"; return -1;
1957       default: ++*n; if (cond) ++*true; break;
1958       }
1959     if (parse_white(filter)==-1) return -1;
1960     if (*filter->pc==',') ++filter->pc;
1961     else break;
1962     }
1963   if (*filter->pc==')')
1964     {
1965     ++filter->pc;
1966     return 1;
1967     }
1968   else
1969     {
1970     filter->errmsg=CUS "missing closing paren";
1971     return -1;
1972     }
1973   }
1974 else return 0;
1975 }
1976
1977
1978 /*************************************************
1979 *     Parse and interpret an optional test       *
1980 *************************************************/
1981
1982 /*
1983 Arguments:
1984   filter      points to the Sieve filter including its state
1985   cond        returned condition status
1986   exec        Execute parsed statements
1987
1988 Returns:      1                success
1989               0                no test found
1990               -1               syntax or execution error
1991 */
1992
1993 static int parse_test(struct Sieve *filter, int *cond, int exec)
1994 {
1995 if (parse_white(filter)==-1) return -1;
1996 if (parse_identifier(filter,CUS "address"))
1997   {
1998   /*
1999   address-test = "address" { [address-part] [comparator] [match-type] }
2000                  <header-list: string-list> <key-list: string-list>
2001
2002   header-list From, To, Cc, Bcc, Sender, Resent-From, Resent-To
2003   */
2004
2005   enum AddressPart addressPart=ADDRPART_ALL;
2006   enum Comparator comparator=COMP_EN_ASCII_CASEMAP;
2007   enum MatchType matchType=MATCH_IS;
2008   struct String *hdr,*h,*key,*k;
2009   int m;
2010   int ap=0,co=0,mt=0;
2011
2012   for (;;)
2013     {
2014     if (parse_white(filter)==-1) return -1;
2015     if ((m=parse_addresspart(filter,&addressPart))!=0)
2016       {
2017       if (m==-1) return -1;
2018       if (ap)
2019         {
2020         filter->errmsg=CUS "address part already specified";
2021         return -1;
2022         }
2023       else ap=1;
2024       }
2025     else if ((m=parse_comparator(filter,&comparator))!=0)
2026       {
2027       if (m==-1) return -1;
2028       if (co)
2029         {
2030         filter->errmsg=CUS "comparator already specified";
2031         return -1;
2032         }
2033       else co=1;
2034       }
2035     else if ((m=parse_matchtype(filter,&matchType))!=0)
2036       {
2037       if (m==-1) return -1;
2038       if (mt)
2039         {
2040         filter->errmsg=CUS "match type already specified";
2041         return -1;
2042         }
2043       else mt=1;
2044       }
2045     else break;
2046     }
2047   if (parse_white(filter)==-1) return -1;
2048   if ((m=parse_stringlist(filter,&hdr))!=1)
2049     {
2050     if (m==0) filter->errmsg=CUS "header string list expected";
2051     return -1;
2052     }
2053   if (parse_white(filter)==-1) return -1;
2054   if ((m=parse_stringlist(filter,&key))!=1)
2055     {
2056     if (m==0) filter->errmsg=CUS "key string list expected";
2057     return -1;
2058     }
2059   *cond=0;
2060   for (h=hdr; h->length!=-1 && !*cond; ++h)
2061     {
2062     uschar *header_value=(uschar*)0,*extracted_addr,*end_addr;
2063
2064     if
2065       (
2066       !eq_asciicase(h,&str_from,0)
2067       && !eq_asciicase(h,&str_to,0)
2068       && !eq_asciicase(h,&str_cc,0)
2069       && !eq_asciicase(h,&str_bcc,0)
2070       && !eq_asciicase(h,&str_sender,0)
2071       && !eq_asciicase(h,&str_resent_from,0)
2072       && !eq_asciicase(h,&str_resent_to,0)
2073       )
2074       {
2075       filter->errmsg=CUS "invalid header field";
2076       return -1;
2077       }
2078     if (exec)
2079       {
2080       /* We are only interested in addresses below, so no MIME decoding */
2081       header_value=expand_string(string_sprintf("$rheader_%s",quote(h)));
2082       if (header_value == NULL)
2083         {
2084         filter->errmsg=CUS "header string expansion failed";
2085         return -1;
2086         }
2087       parse_allow_group = TRUE;
2088       while (*header_value && !*cond)
2089         {
2090         uschar *error;
2091         int start, end, domain;
2092         int saveend;
2093         uschar *part=NULL;
2094
2095         end_addr = parse_find_address_end(header_value, FALSE);
2096         saveend = *end_addr;
2097         *end_addr = 0;
2098         extracted_addr = parse_extract_address(header_value, &error, &start, &end, &domain, FALSE);
2099
2100         if (extracted_addr) switch (addressPart)
2101           {
2102           case ADDRPART_ALL: part=extracted_addr; break;
2103 #ifdef SUBADDRESS
2104           case ADDRPART_USER:
2105 #endif
2106           case ADDRPART_LOCALPART: part=extracted_addr; part[domain-1]='\0'; break;
2107           case ADDRPART_DOMAIN: part=extracted_addr+domain; break;
2108 #ifdef SUBADDRESS
2109           case ADDRPART_DETAIL: part=NULL; break;
2110 #endif
2111           }
2112
2113         *end_addr = saveend;
2114         if (part)
2115           {
2116           for (k=key; k->length!=-1; ++k)
2117             {
2118             struct String partStr;
2119
2120             partStr.character=part;
2121             partStr.length=Ustrlen(part);
2122             if (extracted_addr)
2123               {
2124               *cond=compare(filter,k,&partStr,comparator,matchType);
2125               if (*cond==-1) return -1;
2126               if (*cond) break;
2127               }
2128             }
2129           }
2130         if (saveend == 0) break;
2131         header_value = end_addr + 1;
2132         }
2133       parse_allow_group = FALSE;
2134       parse_found_group = FALSE;
2135       }
2136     }
2137   return 1;
2138   }
2139 else if (parse_identifier(filter,CUS "allof"))
2140   {
2141   /*
2142   allof-test   = "allof" <tests: test-list>
2143   */
2144
2145   int n,true;
2146
2147   switch (parse_testlist(filter,&n,&true,exec))
2148     {
2149     case -1: return -1;
2150     case 0: filter->errmsg=CUS "missing test list"; return -1;
2151     default: *cond=(n==true); return 1;
2152     }
2153   }
2154 else if (parse_identifier(filter,CUS "anyof"))
2155   {
2156   /*
2157   anyof-test   = "anyof" <tests: test-list>
2158   */
2159
2160   int n,true;
2161
2162   switch (parse_testlist(filter,&n,&true,exec))
2163     {
2164     case -1: return -1;
2165     case 0: filter->errmsg=CUS "missing test list"; return -1;
2166     default: *cond=(true>0); return 1;
2167     }
2168   }
2169 else if (parse_identifier(filter,CUS "exists"))
2170   {
2171   /*
2172   exists-test = "exists" <header-names: string-list>
2173   */
2174
2175   struct String *hdr,*h;
2176   int m;
2177
2178   if (parse_white(filter)==-1) return -1;
2179   if ((m=parse_stringlist(filter,&hdr))!=1)
2180     {
2181     if (m==0) filter->errmsg=CUS "header string list expected";
2182     return -1;
2183     }
2184   if (exec)
2185     {
2186     *cond=1;
2187     for (h=hdr; h->length!=-1 && *cond; ++h)
2188       {
2189       uschar *header_def;
2190
2191       header_def=expand_string(string_sprintf("${if def:header_%s {true}{false}}",quote(h)));
2192       if (header_def == NULL)
2193         {
2194         filter->errmsg=CUS "header string expansion failed";
2195         return -1;
2196         }
2197       if (Ustrcmp(header_def,"false")==0) *cond=0;
2198       }
2199     }
2200   return 1;
2201   }
2202 else if (parse_identifier(filter,CUS "false"))
2203   {
2204   /*
2205   false-test = "false"
2206   */
2207
2208   *cond=0;
2209   return 1;
2210   }
2211 else if (parse_identifier(filter,CUS "header"))
2212   {
2213   /*
2214   header-test = "header" { [comparator] [match-type] }
2215                 <header-names: string-list> <key-list: string-list>
2216   */
2217
2218   enum Comparator comparator=COMP_EN_ASCII_CASEMAP;
2219   enum MatchType matchType=MATCH_IS;
2220   struct String *hdr,*h,*key,*k;
2221   int m;
2222   int co=0,mt=0;
2223
2224   for (;;)
2225     {
2226     if (parse_white(filter)==-1) return -1;
2227     if ((m=parse_comparator(filter,&comparator))!=0)
2228       {
2229       if (m==-1) return -1;
2230       if (co)
2231         {
2232         filter->errmsg=CUS "comparator already specified";
2233         return -1;
2234         }
2235       else co=1;
2236       }
2237     else if ((m=parse_matchtype(filter,&matchType))!=0)
2238       {
2239       if (m==-1) return -1;
2240       if (mt)
2241         {
2242         filter->errmsg=CUS "match type already specified";
2243         return -1;
2244         }
2245       else mt=1;
2246       }
2247     else break;
2248     }
2249   if (parse_white(filter)==-1) return -1;
2250   if ((m=parse_stringlist(filter,&hdr))!=1)
2251     {
2252     if (m==0) filter->errmsg=CUS "header string list expected";
2253     return -1;
2254     }
2255   if (parse_white(filter)==-1) return -1;
2256   if ((m=parse_stringlist(filter,&key))!=1)
2257     {
2258     if (m==0) filter->errmsg=CUS "key string list expected";
2259     return -1;
2260     }
2261   *cond=0;
2262   for (h=hdr; h->length!=-1 && !*cond; ++h)
2263     {
2264     if (!is_header(h))
2265       {
2266       filter->errmsg=CUS "invalid header field";
2267       return -1;
2268       }
2269     if (exec)
2270       {
2271       struct String header_value;
2272       uschar *header_def;
2273
2274       expand_header(&header_value,h);
2275       header_def=expand_string(string_sprintf("${if def:header_%s {true}{false}}",quote(h)));
2276       if (header_value.character == NULL || header_def == NULL)
2277         {
2278         filter->errmsg=CUS "header string expansion failed";
2279         return -1;
2280         }
2281       for (k=key; k->length!=-1; ++k)
2282         {
2283         if (Ustrcmp(header_def,"true")==0)
2284           {
2285           *cond=compare(filter,k,&header_value,comparator,matchType);
2286           if (*cond==-1) return -1;
2287           if (*cond) break;
2288           }
2289         }
2290       }
2291     }
2292   return 1;
2293   }
2294 else if (parse_identifier(filter,CUS "not"))
2295   {
2296   if (parse_white(filter)==-1) return -1;
2297   switch (parse_test(filter,cond,exec))
2298     {
2299     case -1: return -1;
2300     case 0: filter->errmsg=CUS "missing test"; return -1;
2301     default: *cond=!*cond; return 1;
2302     }
2303   }
2304 else if (parse_identifier(filter,CUS "size"))
2305   {
2306   /*
2307   relop = ":over" / ":under"
2308   size-test = "size" relop <limit: number>
2309   */
2310
2311   unsigned long limit;
2312   int overNotUnder;
2313
2314   if (parse_white(filter)==-1) return -1;
2315   if (parse_identifier(filter,CUS ":over")) overNotUnder=1;
2316   else if (parse_identifier(filter,CUS ":under")) overNotUnder=0;
2317   else
2318     {
2319     filter->errmsg=CUS "missing :over or :under";
2320     return -1;
2321     }
2322   if (parse_white(filter)==-1) return -1;
2323   if (parse_number(filter,&limit)==-1) return -1;
2324   *cond=(overNotUnder ? (message_size>limit) : (message_size<limit));
2325   return 1;
2326   }
2327 else if (parse_identifier(filter,CUS "true"))
2328   {
2329   *cond=1;
2330   return 1;
2331   }
2332 else if (parse_identifier(filter,CUS "envelope"))
2333   {
2334   /*
2335   envelope-test = "envelope" { [comparator] [address-part] [match-type] }
2336                   <envelope-part: string-list> <key-list: string-list>
2337
2338   envelope-part is case insensitive "from" or "to"
2339 #ifdef ENVELOPE_AUTH
2340   envelope-part =/ "auth"
2341 #endif
2342   */
2343
2344   enum Comparator comparator=COMP_EN_ASCII_CASEMAP;
2345   enum AddressPart addressPart=ADDRPART_ALL;
2346   enum MatchType matchType=MATCH_IS;
2347   struct String *env,*e,*key,*k;
2348   int m;
2349   int co=0,ap=0,mt=0;
2350
2351   if (!filter->require_envelope)
2352     {
2353     filter->errmsg=CUS "missing previous require \"envelope\";";
2354     return -1;
2355     }
2356   for (;;)
2357     {
2358     if (parse_white(filter)==-1) return -1;
2359     if ((m=parse_comparator(filter,&comparator))!=0)
2360       {
2361       if (m==-1) return -1;
2362       if (co)
2363         {
2364         filter->errmsg=CUS "comparator already specified";
2365         return -1;
2366         }
2367       else co=1;
2368       }
2369     else if ((m=parse_addresspart(filter,&addressPart))!=0)
2370       {
2371       if (m==-1) return -1;
2372       if (ap)
2373         {
2374         filter->errmsg=CUS "address part already specified";
2375         return -1;
2376         }
2377       else ap=1;
2378       }
2379     else if ((m=parse_matchtype(filter,&matchType))!=0)
2380       {
2381       if (m==-1) return -1;
2382       if (mt)
2383         {
2384         filter->errmsg=CUS "match type already specified";
2385         return -1;
2386         }
2387       else mt=1;
2388       }
2389     else break;
2390     }
2391   if (parse_white(filter)==-1) return -1;
2392   if ((m=parse_stringlist(filter,&env))!=1)
2393     {
2394     if (m==0) filter->errmsg=CUS "envelope string list expected";
2395     return -1;
2396     }
2397   if (parse_white(filter)==-1) return -1;
2398   if ((m=parse_stringlist(filter,&key))!=1)
2399     {
2400     if (m==0) filter->errmsg=CUS "key string list expected";
2401     return -1;
2402     }
2403   *cond=0;
2404   for (e=env; e->length!=-1 && !*cond; ++e)
2405     {
2406     const uschar *envelopeExpr=CUS 0;
2407     uschar *envelope=US 0;
2408
2409     if (eq_asciicase(e,&str_from,0))
2410       {
2411       switch (addressPart)
2412         {
2413         case ADDRPART_ALL: envelopeExpr=CUS "$sender_address"; break;
2414 #ifdef SUBADDRESS
2415         case ADDRPART_USER:
2416 #endif
2417         case ADDRPART_LOCALPART: envelopeExpr=CUS "${local_part:$sender_address}"; break;
2418         case ADDRPART_DOMAIN: envelopeExpr=CUS "${domain:$sender_address}"; break;
2419 #ifdef SUBADDRESS
2420         case ADDRPART_DETAIL: envelopeExpr=CUS 0; break;
2421 #endif
2422         }
2423       }
2424     else if (eq_asciicase(e,&str_to,0))
2425       {
2426       switch (addressPart)
2427         {
2428         case ADDRPART_ALL: envelopeExpr=CUS "$local_part_prefix$local_part$local_part_suffix@$domain"; break;
2429 #ifdef SUBADDRESS
2430         case ADDRPART_USER: envelopeExpr=filter->useraddress; break;
2431         case ADDRPART_DETAIL: envelopeExpr=filter->subaddress; break;
2432 #endif
2433         case ADDRPART_LOCALPART: envelopeExpr=CUS "$local_part_prefix$local_part$local_part_suffix"; break;
2434         case ADDRPART_DOMAIN: envelopeExpr=CUS "$domain"; break;
2435         }
2436       }
2437 #ifdef ENVELOPE_AUTH
2438     else if (eq_asciicase(e,&str_auth,0))
2439       {
2440       switch (addressPart)
2441         {
2442         case ADDRPART_ALL: envelopeExpr=CUS "$authenticated_sender"; break;
2443 #ifdef SUBADDRESS
2444         case ADDRPART_USER:
2445 #endif
2446         case ADDRPART_LOCALPART: envelopeExpr=CUS "${local_part:$authenticated_sender}"; break;
2447         case ADDRPART_DOMAIN: envelopeExpr=CUS "${domain:$authenticated_sender}"; break;
2448 #ifdef SUBADDRESS
2449         case ADDRPART_DETAIL: envelopeExpr=CUS 0; break;
2450 #endif
2451         }
2452       }
2453 #endif
2454     else
2455       {
2456       filter->errmsg=CUS "invalid envelope string";
2457       return -1;
2458       }
2459     if (exec && envelopeExpr)
2460       {
2461       if ((envelope=expand_string(US envelopeExpr)) == NULL)
2462         {
2463         filter->errmsg=CUS "header string expansion failed";
2464         return -1;
2465         }
2466       for (k=key; k->length!=-1; ++k)
2467         {
2468         struct String envelopeStr;
2469
2470         envelopeStr.character=envelope;
2471         envelopeStr.length=Ustrlen(envelope);
2472         *cond=compare(filter,k,&envelopeStr,comparator,matchType);
2473         if (*cond==-1) return -1;
2474         if (*cond) break;
2475         }
2476       }
2477     }
2478   return 1;
2479   }
2480 #ifdef ENOTIFY
2481 else if (parse_identifier(filter,CUS "valid_notif_method"))
2482   {
2483   /*
2484   valid_notif_method = "valid_notif_method"
2485                        <notification-uris: string-list>
2486   */
2487
2488   struct String *uris,*u;
2489   int m;
2490
2491   if (!filter->require_enotify)
2492     {
2493     filter->errmsg=CUS "missing previous require \"enotify\";";
2494     return -1;
2495     }
2496   if (parse_white(filter)==-1) return -1;
2497   if ((m=parse_stringlist(filter,&uris))!=1)
2498     {
2499     if (m==0) filter->errmsg=CUS "URI string list expected";
2500     return -1;
2501     }
2502   if (exec)
2503     {
2504     *cond=1;
2505     for (u=uris; u->length!=-1 && *cond; ++u)
2506       {
2507         string_item *recipient;
2508         struct String header,body;
2509
2510         recipient=NULL;
2511         header.length=-1;
2512         header.character=(uschar*)0;
2513         body.length=-1;
2514         body.character=(uschar*)0;
2515         if (parse_mailto_uri(filter,u->character,&recipient,&header,&body)!=1)
2516           *cond=0;
2517       }
2518     }
2519   return 1;
2520   }
2521 #endif
2522 else return 0;
2523 }
2524
2525
2526 /*************************************************
2527 *     Parse and interpret an optional block      *
2528 *************************************************/
2529
2530 /*
2531 Arguments:
2532   filter      points to the Sieve filter including its state
2533   exec        Execute parsed statements
2534   generated   where to hang newly-generated addresses
2535
2536 Returns:      2                success by stop
2537               1                other success
2538               0                no block command found
2539               -1               syntax or execution error
2540 */
2541
2542 static int parse_block(struct Sieve *filter, int exec,
2543   address_item **generated)
2544 {
2545 int r;
2546
2547 if (parse_white(filter)==-1) return -1;
2548 if (*filter->pc=='{')
2549   {
2550   ++filter->pc;
2551   if ((r=parse_commands(filter,exec,generated))==-1 || r==2) return r;
2552   if (*filter->pc=='}')
2553     {
2554     ++filter->pc;
2555     return 1;
2556     }
2557   else
2558     {
2559     filter->errmsg=CUS "expecting command or closing brace";
2560     return -1;
2561     }
2562   }
2563 else return 0;
2564 }
2565
2566
2567 /*************************************************
2568 *           Match a semicolon                    *
2569 *************************************************/
2570
2571 /*
2572 Arguments:
2573   filter      points to the Sieve filter including its state
2574
2575 Returns:      1                success
2576               -1               syntax error
2577 */
2578
2579 static int parse_semicolon(struct Sieve *filter)
2580 {
2581   if (parse_white(filter)==-1) return -1;
2582   if (*filter->pc==';')
2583   {
2584     ++filter->pc;
2585     return 1;
2586   }
2587   else
2588   {
2589     filter->errmsg=CUS "missing semicolon";
2590     return -1;
2591   }
2592 }
2593
2594
2595 /*************************************************
2596 *     Parse and interpret a Sieve command        *
2597 *************************************************/
2598
2599 /*
2600 Arguments:
2601   filter      points to the Sieve filter including its state
2602   exec        Execute parsed statements
2603   generated   where to hang newly-generated addresses
2604
2605 Returns:      2                success by stop
2606               1                other success
2607               -1               syntax or execution error
2608 */
2609 static int parse_commands(struct Sieve *filter, int exec,
2610   address_item **generated)
2611 {
2612 while (*filter->pc)
2613   {
2614   if (parse_white(filter)==-1) return -1;
2615   if (parse_identifier(filter,CUS "if"))
2616     {
2617     /*
2618     if-command = "if" test block *( "elsif" test block ) [ else block ]
2619     */
2620
2621     int cond,m,unsuccessful;
2622
2623     /* test block */
2624     if (parse_white(filter)==-1) return -1;
2625     if ((m=parse_test(filter,&cond,exec))==-1) return -1;
2626     if (m==0)
2627       {
2628       filter->errmsg=CUS "missing test";
2629       return -1;
2630       }
2631     if ((filter_test != FTEST_NONE && debug_selector != 0) ||
2632         (debug_selector & D_filter) != 0)
2633       {
2634       if (exec) debug_printf("if %s\n",cond?"true":"false");
2635       }
2636     m=parse_block(filter,exec ? cond : 0, generated);
2637     if (m==-1 || m==2) return m;
2638     if (m==0)
2639       {
2640       filter->errmsg=CUS "missing block";
2641       return -1;
2642       }
2643     unsuccessful = !cond;
2644     for (;;) /* elsif test block */
2645       {
2646       if (parse_white(filter)==-1) return -1;
2647       if (parse_identifier(filter,CUS "elsif"))
2648         {
2649         if (parse_white(filter)==-1) return -1;
2650         m=parse_test(filter,&cond,exec && unsuccessful);
2651         if (m==-1 || m==2) return m;
2652         if (m==0)
2653           {
2654           filter->errmsg=CUS "missing test";
2655           return -1;
2656           }
2657         if ((filter_test != FTEST_NONE && debug_selector != 0) ||
2658             (debug_selector & D_filter) != 0)
2659           {
2660           if (exec) debug_printf("elsif %s\n",cond?"true":"false");
2661           }
2662         m=parse_block(filter,exec && unsuccessful ? cond : 0, generated);
2663         if (m==-1 || m==2) return m;
2664         if (m==0)
2665           {
2666           filter->errmsg=CUS "missing block";
2667           return -1;
2668           }
2669         if (exec && unsuccessful && cond) unsuccessful = 0;
2670         }
2671       else break;
2672       }
2673     /* else block */
2674     if (parse_white(filter)==-1) return -1;
2675     if (parse_identifier(filter,CUS "else"))
2676       {
2677       m=parse_block(filter,exec && unsuccessful, generated);
2678       if (m==-1 || m==2) return m;
2679       if (m==0)
2680         {
2681         filter->errmsg=CUS "missing block";
2682         return -1;
2683         }
2684       }
2685     }
2686   else if (parse_identifier(filter,CUS "stop"))
2687     {
2688     /*
2689     stop-command     =  "stop" { stop-options } ";"
2690     stop-options     =
2691     */
2692
2693     if (parse_semicolon(filter)==-1) return -1;
2694     if (exec)
2695       {
2696       filter->pc+=Ustrlen(filter->pc);
2697       return 2;
2698       }
2699     }
2700   else if (parse_identifier(filter,CUS "keep"))
2701     {
2702     /*
2703     keep-command     =  "keep" { keep-options } ";"
2704     keep-options     =
2705     */
2706
2707     if (parse_semicolon(filter)==-1) return -1;
2708     if (exec)
2709       {
2710       add_addr(generated,US"inbox",1,0,0,0);
2711       filter->keep = 0;
2712       }
2713     }
2714   else if (parse_identifier(filter,CUS "discard"))
2715     {
2716     /*
2717     discard-command  =  "discard" { discard-options } ";"
2718     discard-options  =
2719     */
2720
2721     if (parse_semicolon(filter)==-1) return -1;
2722     if (exec) filter->keep=0;
2723     }
2724   else if (parse_identifier(filter,CUS "redirect"))
2725     {
2726     /*
2727     redirect-command =  "redirect" redirect-options "string" ";"
2728     redirect-options =
2729     redirect-options =) ":copy"
2730     */
2731
2732     struct String recipient;
2733     int m;
2734     int copy=0;
2735
2736     for (;;)
2737       {
2738       if (parse_white(filter)==-1) return -1;
2739       if (parse_identifier(filter,CUS ":copy")==1)
2740         {
2741         if (!filter->require_copy)
2742           {
2743           filter->errmsg=CUS "missing previous require \"copy\";";
2744           return -1;
2745           }
2746           copy=1;
2747         }
2748       else break;
2749       }
2750     if (parse_white(filter)==-1) return -1;
2751     if ((m=parse_string(filter,&recipient))!=1)
2752       {
2753       if (m==0) filter->errmsg=CUS "missing redirect recipient string";
2754       return -1;
2755       }
2756     if (strchr(CCS recipient.character,'@')==(char*)0)
2757       {
2758       filter->errmsg=CUS "unqualified recipient address";
2759       return -1;
2760       }
2761     if (exec)
2762       {
2763       add_addr(generated,recipient.character,0,0,0,0);
2764       if (!copy) filter->keep = 0;
2765       }
2766     if (parse_semicolon(filter)==-1) return -1;
2767     }
2768   else if (parse_identifier(filter,CUS "fileinto"))
2769     {
2770     /*
2771     fileinto-command =  "fileinto" { fileinto-options } string ";"
2772     fileinto-options =
2773     fileinto-options =) [ ":copy" ]
2774     */
2775
2776     struct String folder;
2777     uschar *s;
2778     int m;
2779     unsigned long maxage, maxmessages, maxstorage;
2780     int copy=0;
2781
2782     maxage = maxmessages = maxstorage = 0;
2783     if (!filter->require_fileinto)
2784       {
2785       filter->errmsg=CUS "missing previous require \"fileinto\";";
2786       return -1;
2787       }
2788     for (;;)
2789       {
2790       if (parse_white(filter)==-1) return -1;
2791       if (parse_identifier(filter,CUS ":copy")==1)
2792         {
2793         if (!filter->require_copy)
2794           {
2795           filter->errmsg=CUS "missing previous require \"copy\";";
2796           return -1;
2797           }
2798           copy=1;
2799         }
2800       else break;
2801       }
2802     if (parse_white(filter)==-1) return -1;
2803     if ((m=parse_string(filter,&folder))!=1)
2804       {
2805       if (m==0) filter->errmsg=CUS "missing fileinto folder string";
2806       return -1;
2807       }
2808     m=0; s=folder.character;
2809     if (folder.length==0) m=1;
2810     if (Ustrcmp(s,"..")==0 || Ustrncmp(s,"../",3)==0) m=1;
2811     else while (*s)
2812       {
2813       if (Ustrcmp(s,"/..")==0 || Ustrncmp(s,"/../",4)==0) { m=1; break; }
2814       ++s;
2815       }
2816     if (m)
2817       {
2818       filter->errmsg=CUS "invalid folder";
2819       return -1;
2820       }
2821     if (exec)
2822       {
2823       add_addr(generated, folder.character, 1, maxage, maxmessages, maxstorage);
2824       if (!copy) filter->keep = 0;
2825       }
2826     if (parse_semicolon(filter)==-1) return -1;
2827     }
2828 #ifdef ENOTIFY
2829   else if (parse_identifier(filter,CUS "notify"))
2830     {
2831     /*
2832     notify-command =  "notify" { notify-options } <method: string> ";"
2833     notify-options =  [":from" string]
2834                       [":importance" <"1" / "2" / "3">]
2835                       [":options" 1*(string-list / number)]
2836                       [":message" string]
2837     */
2838
2839     int m;
2840     struct String from;
2841     struct String importance;
2842     struct String *options;
2843     struct String message;
2844     struct String method;
2845     struct Notification *already;
2846     string_item *recipient;
2847     struct String header;
2848     struct String body;
2849     uschar *envelope_from,*envelope_to;
2850
2851     if (!filter->require_enotify)
2852       {
2853       filter->errmsg=CUS "missing previous require \"enotify\";";
2854       return -1;
2855       }
2856     from.character=(uschar*)0;
2857     from.length=-1;
2858     importance.character=(uschar*)0;
2859     importance.length=-1;
2860     options=(struct String*)0;
2861     message.character=(uschar*)0;
2862     message.length=-1;
2863     recipient=NULL;
2864     header.length=-1;
2865     header.character=(uschar*)0;
2866     body.length=-1;
2867     body.character=(uschar*)0;
2868     envelope_from=expand_string("$sender_address");
2869     envelope_to=expand_string("$local_part_prefix$local_part$local_part_suffix@$domain");
2870     for (;;)
2871       {
2872       if (parse_white(filter)==-1) return -1;
2873       if (parse_identifier(filter,CUS ":from")==1)
2874         {
2875         if (parse_white(filter)==-1) return -1;
2876         if ((m=parse_string(filter,&from))!=1)
2877           {
2878           if (m==0) filter->errmsg=CUS "from string expected";
2879           return -1;
2880           }
2881         }
2882       else if (parse_identifier(filter,CUS ":importance")==1)
2883         {
2884         if (parse_white(filter)==-1) return -1;
2885         if ((m=parse_string(filter,&importance))!=1)
2886           {
2887           if (m==0) filter->errmsg=CUS "importance string expected";
2888           return -1;
2889           }
2890         if (importance.length!=1 || importance.character[0]<'1' || importance.character[0]>'3')
2891           {
2892           filter->errmsg=CUS "invalid importance";
2893           return -1;
2894           }
2895         }
2896       else if (parse_identifier(filter,CUS ":options")==1)
2897         {
2898         if (parse_white(filter)==-1) return -1;
2899         }
2900       else if (parse_identifier(filter,CUS ":message")==1)
2901         {
2902         if (parse_white(filter)==-1) return -1;
2903         if ((m=parse_string(filter,&message))!=1)
2904           {
2905           if (m==0) filter->errmsg=CUS "message string expected";
2906           return -1;
2907           }
2908         }
2909       else break;
2910       }
2911     if (parse_white(filter)==-1) return -1;
2912     if ((m=parse_string(filter,&method))!=1)
2913       {
2914       if (m==0) filter->errmsg=CUS "missing method string";
2915       return -1;
2916       }
2917     if (parse_semicolon(filter)==-1) return -1;
2918
2919     for (already=filter->notified; already; already=already->next)
2920       {
2921       if (already->method.length==method.length
2922           && (method.length==-1 || strcmp(already->method.character,method.character)==0)
2923           && already->importance.length==importance.length
2924           && (importance.length==-1 || strcmp(already->importance.character,importance.character)==0)
2925           && already->message.length==message.length
2926           && (message.length==-1 || strcmp(already->message.character,message.character)==0))
2927         break;
2928       }
2929     if (already==(struct Notification*)0)
2930       /* New notification, process it */
2931       {
2932       if (parse_mailto_uri(filter,method.character,&recipient,&header,&body)!=1)
2933         return -1;
2934       struct Notification *sent;
2935       sent=store_get(sizeof(struct Notification));
2936       sent->method=method;
2937       sent->importance=importance;
2938       sent->message=message;
2939       sent->next=filter->notified;
2940       filter->notified=sent;
2941       if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
2942         {
2943         debug_printf("Notification to `%s'.\n",method.character);
2944         }
2945 #ifndef COMPILE_SYNTAX_CHECKER
2946       if (exec && filter_test == FTEST_NONE)
2947         {
2948         string_item *p;
2949         header_line *h;
2950         int pid,fd;
2951
2952         if ((pid = child_open_exim2(&fd,envelope_to,envelope_to))>=1)
2953           {
2954           FILE *f;
2955           uschar *buffer;
2956           int buffer_capacity;
2957
2958           f = fdopen(fd, "wb");
2959           for (h = header_list; h != NULL; h = h->next)
2960             if (h->type == htype_received) fprintf(f,"%s",h->text);
2961           fprintf(f,"From: %s\n",from.length==-1 ? envelope_to : from.character);
2962           for (p=recipient; p; p=p->next) fprintf(f,"To: %s\n",p->text);
2963           if (header.length>0) fprintf(f,"%s",header.character);
2964           if (message.length==-1)
2965             {
2966             message.character=US"Notification";
2967             message.length=Ustrlen(message.character);
2968             }
2969           /* Allocation is larger than neccessary, but enough even for split MIME words */
2970           buffer_capacity=32+4*message.length;
2971           buffer=store_get(buffer_capacity);
2972           fprintf(f,"Subject: %s\n\n",parse_quote_2047(message.character, message.length, US"utf-8", buffer, buffer_capacity, TRUE));
2973           if (body.length>0) fprintf(f,"%s\n",body.character);
2974           fflush(f);
2975           (void)fclose(f);
2976           (void)child_close(pid, 0);
2977           }
2978         }
2979 #endif
2980       }
2981     else
2982       {
2983       if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
2984         {
2985         debug_printf("Repeated notification to `%s' ignored.\n",method.character);
2986         }
2987       }
2988     }
2989 #endif
2990 #ifdef VACATION
2991   else if (parse_identifier(filter,CUS "vacation"))
2992     {
2993     /*
2994     vacation-command =  "vacation" { vacation-options } <reason: string> ";"
2995     vacation-options =  [":days" number]
2996                         [":subject" string]
2997                         [":from" string]
2998                         [":addresses" string-list]
2999                         [":mime"]
3000                         [":handle" string]
3001     */
3002
3003     int m;
3004     unsigned long days;
3005     struct String subject;
3006     struct String from;
3007     struct String *addresses;
3008     int reason_is_mime;
3009     string_item *aliases;
3010     struct String handle;
3011     struct String reason;
3012
3013     if (!filter->require_vacation)
3014       {
3015       filter->errmsg=CUS "missing previous require \"vacation\";";
3016       return -1;
3017       }
3018     if (exec)
3019       {
3020       if (filter->vacation_ran)
3021         {
3022         filter->errmsg=CUS "trying to execute vacation more than once";
3023         return -1;
3024         }
3025       filter->vacation_ran=1;
3026       }
3027     days=VACATION_MIN_DAYS>7 ? VACATION_MIN_DAYS : 7;
3028     subject.character=(uschar*)0;
3029     subject.length=-1;
3030     from.character=(uschar*)0;
3031     from.length=-1;
3032     addresses=(struct String*)0;
3033     aliases=NULL;
3034     reason_is_mime=0;
3035     handle.character=(uschar*)0;
3036     handle.length=-1;
3037     for (;;)
3038       {
3039       if (parse_white(filter)==-1) return -1;
3040       if (parse_identifier(filter,CUS ":days")==1)
3041         {
3042         if (parse_white(filter)==-1) return -1;
3043         if (parse_number(filter,&days)==-1) return -1;
3044         if (days<VACATION_MIN_DAYS) days=VACATION_MIN_DAYS;
3045         else if (days>VACATION_MAX_DAYS) days=VACATION_MAX_DAYS;
3046         }
3047       else if (parse_identifier(filter,CUS ":subject")==1)
3048         {
3049         if (parse_white(filter)==-1) return -1;
3050         if ((m=parse_string(filter,&subject))!=1)
3051           {
3052           if (m==0) filter->errmsg=CUS "subject string expected";
3053           return -1;
3054           }
3055         }
3056       else if (parse_identifier(filter,CUS ":from")==1)
3057         {
3058         if (parse_white(filter)==-1) return -1;
3059         if ((m=parse_string(filter,&from))!=1)
3060           {
3061           if (m==0) filter->errmsg=CUS "from string expected";
3062           return -1;
3063           }
3064         if (check_mail_address(filter,&from)!=1)
3065           return -1;
3066         }
3067       else if (parse_identifier(filter,CUS ":addresses")==1)
3068         {
3069         struct String *a;
3070
3071         if (parse_white(filter)==-1) return -1;
3072         if ((m=parse_stringlist(filter,&addresses))!=1)
3073           {
3074           if (m==0) filter->errmsg=CUS "addresses string list expected";
3075           return -1;
3076           }
3077         for (a=addresses; a->length!=-1; ++a)
3078           {
3079           string_item *new;
3080
3081           new=store_get(sizeof(string_item));
3082           new->text=store_get(a->length+1);
3083           if (a->length) memcpy(new->text,a->character,a->length);
3084           new->text[a->length]='\0';
3085           new->next=aliases;
3086           aliases=new;
3087           }
3088         }
3089       else if (parse_identifier(filter,CUS ":mime")==1)
3090         reason_is_mime=1;
3091       else if (parse_identifier(filter,CUS ":handle")==1)
3092         {
3093         if (parse_white(filter)==-1) return -1;
3094         if ((m=parse_string(filter,&from))!=1)
3095           {
3096           if (m==0) filter->errmsg=CUS "handle string expected";
3097           return -1;
3098           }
3099         }
3100       else break;
3101       }
3102     if (parse_white(filter)==-1) return -1;
3103     if ((m=parse_string(filter,&reason))!=1)
3104       {
3105       if (m==0) filter->errmsg=CUS "missing reason string";
3106       return -1;
3107       }
3108     if (reason_is_mime)
3109       {
3110       uschar *s,*end;
3111
3112       for (s=reason.character,end=reason.character+reason.length; s<end && (*s&0x80)==0; ++s);
3113       if (s<end)
3114         {
3115         filter->errmsg=CUS "MIME reason string contains 8bit text";
3116         return -1;
3117         }
3118       }
3119     if (parse_semicolon(filter)==-1) return -1;
3120
3121     if (exec)
3122       {
3123       address_item *addr;
3124       int capacity,start;
3125       uschar *buffer;
3126       int buffer_capacity;
3127       struct String key;
3128       md5 base;
3129       uschar digest[16];
3130       uschar hexdigest[33];
3131       int i;
3132       uschar *once;
3133
3134       if (filter_personal(aliases,TRUE))
3135         {
3136         if (filter_test == FTEST_NONE)
3137           {
3138           /* ensure oncelog directory exists; failure will be detected later */
3139
3140           (void)directory_make(NULL, filter->vacation_directory, 0700, FALSE);
3141           }
3142         /* build oncelog filename */
3143
3144         key.character=(uschar*)0;
3145         key.length=0;
3146         capacity=0;
3147         if (handle.length==-1)
3148           {
3149           if (subject.length!=-1) key.character=string_cat(key.character,&capacity,&key.length,subject.character,subject.length);
3150           if (from.length!=-1) key.character=string_cat(key.character,&capacity,&key.length,from.character,from.length);
3151           key.character=string_cat(key.character,&capacity,&key.length,reason_is_mime?US"1":US"0",1);
3152           key.character=string_cat(key.character,&capacity,&key.length,reason.character,reason.length);
3153           }
3154         else
3155           key=handle;
3156         md5_start(&base);
3157         md5_end(&base, key.character, key.length, digest);
3158         for (i = 0; i < 16; i++) sprintf(CS (hexdigest+2*i), "%02X", digest[i]);
3159         if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
3160           {
3161           debug_printf("Sieve: mail was personal, vacation file basename: %s\n", hexdigest);
3162           }
3163         if (filter_test == FTEST_NONE)
3164           {
3165           capacity=Ustrlen(filter->vacation_directory);
3166           start=capacity;
3167           once=string_cat(filter->vacation_directory,&capacity,&start,US"/",1);
3168           once=string_cat(once,&capacity,&start,hexdigest,33);
3169           once[start] = '\0';
3170
3171           /* process subject */
3172
3173           if (subject.length==-1)
3174             {
3175             uschar *subject_def;
3176
3177             subject_def=expand_string(US"${if def:header_subject {true}{false}}");
3178             if (Ustrcmp(subject_def,"true")==0)
3179               {
3180               expand_header(&subject,&str_subject);
3181               capacity=6;
3182               start=6;
3183               subject.character=string_cat(US"Auto: ",&capacity,&start,subject.character,subject.length);
3184               subject.length=start;
3185               }
3186             else
3187               {
3188               subject.character=US"Automated reply";
3189               subject.length=Ustrlen(subject.character);
3190               }
3191             }
3192
3193           /* add address to list of generated addresses */
3194
3195           addr = deliver_make_addr(string_sprintf(">%.256s", sender_address), FALSE);
3196           setflag(addr, af_pfr);
3197           setflag(addr, af_ignore_error);
3198           addr->next = *generated;
3199           *generated = addr;
3200           addr->reply = store_get(sizeof(reply_item));
3201           memset(addr->reply,0,sizeof(reply_item)); /* XXX */
3202           addr->reply->to = string_copy(sender_address);
3203           if (from.length==-1)
3204             addr->reply->from = expand_string(US"$local_part@$domain");
3205           else
3206             addr->reply->from = from.character;
3207           /* Allocation is larger than neccessary, but enough even for split MIME words */
3208           buffer_capacity=32+4*subject.length;
3209           buffer=store_get(buffer_capacity);
3210           addr->reply->subject=parse_quote_2047(subject.character, subject.length, US"utf-8", buffer, buffer_capacity, TRUE);
3211           addr->reply->oncelog=once;
3212           addr->reply->once_repeat=days*86400;
3213
3214           /* build body and MIME headers */
3215
3216           if (reason_is_mime)
3217             {
3218             uschar *mime_body,*reason_end;
3219             static const uschar nlnl[]="\r\n\r\n";
3220
3221             for
3222               (
3223               mime_body=reason.character,reason_end=reason.character+reason.length;
3224               mime_body<(reason_end-(sizeof(nlnl)-1)) && memcmp(mime_body,nlnl,(sizeof(nlnl)-1));
3225               ++mime_body
3226               );
3227             capacity = 0;
3228             start = 0;
3229             addr->reply->headers = string_cat(NULL,&capacity,&start,reason.character,mime_body-reason.character);
3230             addr->reply->headers[start] = '\0';
3231             capacity = 0;
3232             start = 0;
3233             if (mime_body+(sizeof(nlnl)-1)<reason_end) mime_body+=(sizeof(nlnl)-1);
3234             else mime_body=reason_end-1;
3235             addr->reply->text = string_cat(NULL,&capacity,&start,mime_body,reason_end-mime_body);
3236             addr->reply->text[start] = '\0';
3237             }
3238           else
3239             {
3240             struct String qp = { NULL, 0 };  /* Keep compiler happy (PH) */
3241
3242             capacity = 0;
3243             start = reason.length;
3244             addr->reply->headers = US"MIME-Version: 1.0\n"
3245                                    "Content-Type: text/plain;\n"
3246                                    "\tcharset=\"utf-8\"\n"
3247                                    "Content-Transfer-Encoding: quoted-printable";
3248             addr->reply->text = quoted_printable_encode(&reason,&qp)->character;
3249             }
3250           }
3251         }
3252         else if ((filter_test != FTEST_NONE && debug_selector != 0) || (debug_selector & D_filter) != 0)
3253           {
3254           debug_printf("Sieve: mail was not personal, vacation would ignore it\n");
3255           }
3256       }
3257     }
3258     else break;
3259 #endif
3260   }
3261 return 1;
3262 }
3263
3264
3265 /*************************************************
3266 *       Parse and interpret a sieve filter       *
3267 *************************************************/
3268
3269 /*
3270 Arguments:
3271   filter      points to the Sieve filter including its state
3272   exec        Execute parsed statements
3273   generated   where to hang newly-generated addresses
3274
3275 Returns:      1                success
3276               -1               syntax or execution error
3277 */
3278
3279 static int parse_start(struct Sieve *filter, int exec,
3280   address_item **generated)
3281 {
3282 filter->pc=filter->filter;
3283 filter->line=1;
3284 filter->keep=1;
3285 filter->require_envelope=0;
3286 filter->require_fileinto=0;
3287 #ifdef ENCODED_CHARACTER
3288 filter->require_encoded_character=0;
3289 #endif
3290 #ifdef ENVELOPE_AUTH
3291 filter->require_envelope_auth=0;
3292 #endif
3293 #ifdef ENOTIFY
3294 filter->require_enotify=0;
3295 filter->notified=(struct Notification*)0;
3296 #endif
3297 #ifdef SUBADDRESS
3298 filter->require_subaddress=0;
3299 #endif
3300 #ifdef VACATION
3301 filter->require_vacation=0;
3302 filter->vacation_ran=0;
3303 #endif
3304 filter->require_copy=0;
3305 filter->require_iascii_numeric=0;
3306
3307 if (parse_white(filter)==-1) return -1;
3308
3309 if (exec && filter->vacation_directory != NULL && filter_test == FTEST_NONE)
3310   {
3311   DIR *oncelogdir;
3312   struct dirent *oncelog;
3313   struct stat properties;
3314   time_t now;
3315
3316   /* clean up old vacation log databases */
3317
3318   oncelogdir=opendir(CS filter->vacation_directory);
3319
3320   if (oncelogdir ==(DIR*)0 && errno != ENOENT)
3321     {
3322     filter->errmsg=CUS "unable to open vacation directory";
3323     return -1;
3324     }
3325
3326   if (oncelogdir != NULL)
3327     {
3328     time(&now);
3329
3330     while ((oncelog=readdir(oncelogdir))!=(struct dirent*)0)
3331       {
3332       if (strlen(oncelog->d_name)==32)
3333         {
3334         uschar *s=string_sprintf("%s/%s",filter->vacation_directory,oncelog->d_name);
3335         if (Ustat(s,&properties)==0 && (properties.st_mtime+VACATION_MAX_DAYS*86400)<now)
3336           Uunlink(s);
3337         }
3338       }
3339     closedir(oncelogdir);
3340     }
3341   }
3342
3343 while (parse_identifier(filter,CUS "require"))
3344   {
3345   /*
3346   require-command = "require" <capabilities: string-list>
3347   */
3348
3349   struct String *cap,*check;
3350   int m;
3351
3352   if (parse_white(filter)==-1) return -1;
3353   if ((m=parse_stringlist(filter,&cap))!=1)
3354     {
3355     if (m==0) filter->errmsg=CUS "capability string list expected";
3356     return -1;
3357     }
3358   for (check=cap; check->character; ++check)
3359     {
3360     if (eq_octet(check,&str_envelope,0)) filter->require_envelope=1;
3361     else if (eq_octet(check,&str_fileinto,0)) filter->require_fileinto=1;
3362 #ifdef ENCODED_CHARACTER
3363     else if (eq_octet(check,&str_encoded_character,0)) filter->require_encoded_character=1;
3364 #endif
3365 #ifdef ENVELOPE_AUTH
3366     else if (eq_octet(check,&str_envelope_auth,0)) filter->require_envelope_auth=1;
3367 #endif
3368 #ifdef ENOTIFY
3369     else if (eq_octet(check,&str_enotify,0)) filter->require_enotify=1;
3370 #endif
3371 #ifdef SUBADDRESS
3372     else if (eq_octet(check,&str_subaddress,0)) filter->require_subaddress=1;
3373 #endif
3374 #ifdef VACATION
3375     else if (eq_octet(check,&str_vacation,0))
3376       {
3377       if (filter_test == FTEST_NONE && filter->vacation_directory == NULL)
3378         {
3379         filter->errmsg=CUS "vacation disabled";
3380         return -1;
3381         }
3382       filter->require_vacation=1;
3383       }
3384 #endif
3385     else if (eq_octet(check,&str_copy,0)) filter->require_copy=1;
3386     else if (eq_octet(check,&str_comparator_ioctet,0)) ;
3387     else if (eq_octet(check,&str_comparator_iascii_casemap,0)) ;
3388     else if (eq_octet(check,&str_comparator_enascii_casemap,0)) ;
3389     else if (eq_octet(check,&str_comparator_iascii_numeric,0)) filter->require_iascii_numeric=1;
3390     else
3391       {
3392       filter->errmsg=CUS "unknown capability";
3393       return -1;
3394       }
3395     }
3396     if (parse_semicolon(filter)==-1) return -1;
3397   }
3398   if (parse_commands(filter,exec,generated)==-1) return -1;
3399   if (*filter->pc)
3400     {
3401     filter->errmsg=CUS "syntax error";
3402     return -1;
3403     }
3404   return 1;
3405 }
3406
3407
3408 /*************************************************
3409 *            Interpret a sieve filter file       *
3410 *************************************************/
3411
3412 /*
3413 Arguments:
3414   filter      points to the entire file, read into store as a single string
3415   options     controls whether various special things are allowed, and requests
3416               special actions (not currently used)
3417   sieve_vacation_directory  where to store vacation "once" files
3418   useraddress string expression for :user part of address
3419   subaddress  string expression for :subaddress part of address
3420   generated   where to hang newly-generated addresses
3421   error       where to pass back an error text
3422
3423 Returns:      FF_DELIVERED     success, a significant action was taken
3424               FF_NOTDELIVERED  success, no significant action
3425               FF_DEFER         defer requested
3426               FF_FAIL          fail requested
3427               FF_FREEZE        freeze requested
3428               FF_ERROR         there was a problem
3429 */
3430
3431 int
3432 sieve_interpret(uschar *filter, int options, uschar *vacation_directory,
3433   uschar *useraddress, uschar *subaddress, address_item **generated, uschar **error)
3434 {
3435 struct Sieve sieve;
3436 int r;
3437 uschar *msg;
3438
3439 options = options; /* Keep picky compilers happy */
3440 error = error;
3441
3442 DEBUG(D_route) debug_printf("Sieve: start of processing\n");
3443 sieve.filter=filter;
3444
3445 if (vacation_directory == NULL)
3446   sieve.vacation_directory = NULL;
3447 else
3448   {
3449   sieve.vacation_directory=expand_string(vacation_directory);
3450   if (sieve.vacation_directory == NULL)
3451     {
3452     *error = string_sprintf("failed to expand \"%s\" "
3453       "(sieve_vacation_directory): %s", vacation_directory,
3454       expand_string_message);
3455     return FF_ERROR;
3456     }
3457   }
3458
3459 sieve.useraddress = useraddress == NULL ? CUS "$local_part_prefix$local_part$local_part_suffix" : useraddress;
3460 sieve.subaddress = subaddress;
3461
3462 #ifdef COMPILE_SYNTAX_CHECKER
3463 if (parse_start(&sieve,0,generated)==1)
3464 #else
3465 if (parse_start(&sieve,1,generated)==1)
3466 #endif
3467   {
3468   if (sieve.keep)
3469     {
3470     add_addr(generated,US"inbox",1,0,0,0);
3471     msg = string_sprintf("Implicit keep");
3472     r = FF_DELIVERED;
3473     }
3474   else
3475     {
3476     msg = string_sprintf("No implicit keep");
3477     r = FF_DELIVERED;
3478     }
3479   }
3480 else
3481   {
3482   msg = string_sprintf("Sieve error: %s in line %d",sieve.errmsg,sieve.line);
3483 #ifdef COMPILE_SYNTAX_CHECKER
3484   r = FF_ERROR;
3485   *error = msg;
3486 #else
3487   add_addr(generated,US"inbox",1,0,0,0);
3488   r = FF_DELIVERED;
3489 #endif
3490   }
3491
3492 #ifndef COMPILE_SYNTAX_CHECKER
3493 if (filter_test != FTEST_NONE) printf("%s\n", (const char*) msg);
3494   else debug_printf("%s\n", msg);
3495 #endif
3496
3497 DEBUG(D_route) debug_printf("Sieve: end of processing\n");
3498 return r;
3499 }