src/src/sieve.c

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