src/src/sieve.c

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