src/src/sieve.c

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