src/src/sieve.c

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