src/src/sieve.c

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