src/src/sieve.c

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