src/src/acl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2013 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Code for handling Access Control Lists (ACLs) */
   9
  10 #include "exim.h"
  11
  12
  13 /* Default callout timeout */
  14
  15 #define CALLOUT_TIMEOUT_DEFAULT 30
  16
  17 /* ACL verb codes - keep in step with the table of verbs that follows */
  18
  19 enum { ACL_ACCEPT, ACL_DEFER, ACL_DENY, ACL_DISCARD, ACL_DROP, ACL_REQUIRE,
  20        ACL_WARN };
  21
  22 /* ACL verbs */
  23
  24 static uschar *verbs[] = {
  25     US"accept",
  26     US"defer",
  27     US"deny",
  28     US"discard",
  29     US"drop",
  30     US"require",
  31     US"warn" };
  32
  33 /* For each verb, the conditions for which "message" or "log_message" are used
  34 are held as a bitmap. This is to avoid expanding the strings unnecessarily. For
  35 "accept", the FAIL case is used only after "endpass", but that is selected in
  36 the code. */
  37
  38 static int msgcond[] = {
  39   (1<<OK) | (1<<FAIL) | (1<<FAIL_DROP),  /* accept */
  40   (1<<OK),                               /* defer */
  41   (1<<OK),                               /* deny */
  42   (1<<OK) | (1<<FAIL) | (1<<FAIL_DROP),  /* discard */
  43   (1<<OK),                               /* drop */
  44   (1<<FAIL) | (1<<FAIL_DROP),            /* require */
  45   (1<<OK)                                /* warn */
  46   };
  47
  48 /* ACL condition and modifier codes - keep in step with the table that
  49 follows, and the cond_expand_at_top and uschar cond_modifiers tables lower
  50 down. */
  51
  52 enum { ACLC_ACL,
  53        ACLC_ADD_HEADER,
  54        ACLC_AUTHENTICATED,
  55 #ifdef EXPERIMENTAL_BRIGHTMAIL
  56        ACLC_BMI_OPTIN,
  57 #endif
  58        ACLC_CONDITION,
  59        ACLC_CONTINUE,
  60        ACLC_CONTROL,
  61 #ifdef EXPERIMENTAL_DCC
  62        ACLC_DCC,
  63 #endif
  64 #ifdef WITH_CONTENT_SCAN
  65        ACLC_DECODE,
  66 #endif
  67        ACLC_DELAY,
  68 #ifdef WITH_OLD_DEMIME
  69        ACLC_DEMIME,
  70 #endif
  71 #ifndef DISABLE_DKIM
  72        ACLC_DKIM_SIGNER,
  73        ACLC_DKIM_STATUS,
  74 #endif
  75 #ifdef EXPERIMENTAL_DMARC
  76        ACLC_DMARC_STATUS,
  77 #endif
  78        ACLC_DNSLISTS,
  79        ACLC_DOMAINS,
  80        ACLC_ENCRYPTED,
  81        ACLC_ENDPASS,
  82        ACLC_HOSTS,
  83        ACLC_LOCAL_PARTS,
  84        ACLC_LOG_MESSAGE,
  85        ACLC_LOG_REJECT_TARGET,
  86        ACLC_LOGWRITE,
  87 #ifdef WITH_CONTENT_SCAN
  88        ACLC_MALWARE,
  89 #endif
  90        ACLC_MESSAGE,
  91 #ifdef WITH_CONTENT_SCAN
  92        ACLC_MIME_REGEX,
  93 #endif
  94        ACLC_RATELIMIT,
  95        ACLC_RECIPIENTS,
  96 #ifdef WITH_CONTENT_SCAN
  97        ACLC_REGEX,
  98 #endif
  99        ACLC_REMOVE_HEADER,
 100        ACLC_SENDER_DOMAINS,
 101        ACLC_SENDERS,
 102        ACLC_SET,
 103 #ifdef WITH_CONTENT_SCAN
 104        ACLC_SPAM,
 105 #endif
 106 #ifdef EXPERIMENTAL_SPF
 107        ACLC_SPF,
 108        ACLC_SPF_GUESS,
 109 #endif
 110        ACLC_UDPSEND,
 111        ACLC_VERIFY };
 112
 113 /* ACL conditions/modifiers: "delay", "control", "continue", "endpass",
 114 "message", "log_message", "log_reject_target", "logwrite", and "set" are
 115 modifiers that look like conditions but always return TRUE. They are used for
 116 their side effects. */
 117
 118 static uschar *conditions[] = {
 119   US"acl",
 120   US"add_header",
 121   US"authenticated",
 122 #ifdef EXPERIMENTAL_BRIGHTMAIL
 123   US"bmi_optin",
 124 #endif
 125   US"condition",
 126   US"continue",
 127   US"control",
 128 #ifdef EXPERIMENTAL_DCC
 129   US"dcc",
 130 #endif
 131 #ifdef WITH_CONTENT_SCAN
 132   US"decode",
 133 #endif
 134   US"delay",
 135 #ifdef WITH_OLD_DEMIME
 136   US"demime",
 137 #endif
 138 #ifndef DISABLE_DKIM
 139   US"dkim_signers",
 140   US"dkim_status",
 141 #endif
 142 #ifdef EXPERIMENTAL_DMARC
 143   US"dmarc_status",
 144 #endif
 145   US"dnslists",
 146   US"domains",
 147   US"encrypted",
 148   US"endpass",
 149   US"hosts",
 150   US"local_parts",
 151   US"log_message",
 152   US"log_reject_target",
 153   US"logwrite",
 154 #ifdef WITH_CONTENT_SCAN
 155   US"malware",
 156 #endif
 157   US"message",
 158 #ifdef WITH_CONTENT_SCAN
 159   US"mime_regex",
 160 #endif
 161   US"ratelimit",
 162   US"recipients",
 163 #ifdef WITH_CONTENT_SCAN
 164   US"regex",
 165 #endif
 166   US"remove_header",
 167   US"sender_domains", US"senders", US"set",
 168 #ifdef WITH_CONTENT_SCAN
 169   US"spam",
 170 #endif
 171 #ifdef EXPERIMENTAL_SPF
 172   US"spf",
 173   US"spf_guess",
 174 #endif
 175   US"udpsend",
 176   US"verify" };
 177
 178
 179 /* Return values from decode_control(); keep in step with the table of names
 180 that follows! */
 181
 182 enum {
 183   CONTROL_AUTH_UNADVERTISED,
 184   #ifdef EXPERIMENTAL_BRIGHTMAIL
 185   CONTROL_BMI_RUN,
 186   #endif
 187   CONTROL_DEBUG,
 188   #ifndef DISABLE_DKIM
 189   CONTROL_DKIM_VERIFY,
 190   #endif
 191   #ifdef EXPERIMENTAL_DMARC
 192   CONTROL_DMARC_VERIFY,
 193   CONTROL_DMARC_FORENSIC,
 194   #endif
 195   CONTROL_DSCP,
 196   CONTROL_ERROR,
 197   CONTROL_CASEFUL_LOCAL_PART,
 198   CONTROL_CASELOWER_LOCAL_PART,
 199   CONTROL_CUTTHROUGH_DELIVERY,
 200   CONTROL_ENFORCE_SYNC,
 201   CONTROL_NO_ENFORCE_SYNC,
 202   CONTROL_FREEZE,
 203   CONTROL_QUEUE_ONLY,
 204   CONTROL_SUBMISSION,
 205   CONTROL_SUPPRESS_LOCAL_FIXUPS,
 206   #ifdef WITH_CONTENT_SCAN
 207   CONTROL_NO_MBOX_UNSPOOL,
 208   #endif
 209   CONTROL_FAKEDEFER,
 210   CONTROL_FAKEREJECT,
 211   CONTROL_NO_MULTILINE,
 212   CONTROL_NO_PIPELINING,
 213   CONTROL_NO_DELAY_FLUSH,
 214   CONTROL_NO_CALLOUT_FLUSH
 215 };
 216
 217 /* ACL control names; keep in step with the table above! This list is used for
 218 turning ids into names. The actual list of recognized names is in the variable
 219 control_def controls_list[] below. The fact that there are two lists is a mess
 220 and should be tidied up. */
 221
 222 static uschar *controls[] = {
 223   US"allow_auth_unadvertised",
 224   #ifdef EXPERIMENTAL_BRIGHTMAIL
 225   US"bmi_run",
 226   #endif
 227   US"debug",
 228   #ifndef DISABLE_DKIM
 229   US"dkim_disable_verify",
 230   #endif
 231   #ifdef EXPERIMENTAL_DMARC
 232   US"dmarc_disable_verify",
 233   US"dmarc_enable_forensic",
 234   #endif
 235   US"dscp",
 236   US"error",
 237   US"caseful_local_part",
 238   US"caselower_local_part",
 239   US"cutthrough_delivery",
 240   US"enforce_sync",
 241   US"no_enforce_sync",
 242   US"freeze",
 243   US"queue_only",
 244   US"submission",
 245   US"suppress_local_fixups",
 246   #ifdef WITH_CONTENT_SCAN
 247   US"no_mbox_unspool",
 248   #endif
 249   US"fakedefer",
 250   US"fakereject",
 251   US"no_multiline_responses",
 252   US"no_pipelining",
 253   US"no_delay_flush",
 254   US"no_callout_flush"
 255 };
 256
 257 /* Flags to indicate for which conditions/modifiers a string expansion is done
 258 at the outer level. In the other cases, expansion already occurs in the
 259 checking functions. */
 260
 261 static uschar cond_expand_at_top[] = {
 262   FALSE,   /* acl */
 263   TRUE,    /* add_header */
 264   FALSE,   /* authenticated */
 265 #ifdef EXPERIMENTAL_BRIGHTMAIL
 266   TRUE,    /* bmi_optin */
 267 #endif
 268   TRUE,    /* condition */
 269   TRUE,    /* continue */
 270   TRUE,    /* control */
 271 #ifdef EXPERIMENTAL_DCC
 272   TRUE,    /* dcc */
 273 #endif
 274 #ifdef WITH_CONTENT_SCAN
 275   TRUE,    /* decode */
 276 #endif
 277   TRUE,    /* delay */
 278 #ifdef WITH_OLD_DEMIME
 279   TRUE,    /* demime */
 280 #endif
 281 #ifndef DISABLE_DKIM
 282   TRUE,    /* dkim_signers */
 283   TRUE,    /* dkim_status */
 284 #endif
 285 #ifdef EXPERIMENTAL_DMARC
 286   TRUE,    /* dmarc_status */
 287 #endif
 288   TRUE,    /* dnslists */
 289   FALSE,   /* domains */
 290   FALSE,   /* encrypted */
 291   TRUE,    /* endpass */
 292   FALSE,   /* hosts */
 293   FALSE,   /* local_parts */
 294   TRUE,    /* log_message */
 295   TRUE,    /* log_reject_target */
 296   TRUE,    /* logwrite */
 297 #ifdef WITH_CONTENT_SCAN
 298   TRUE,    /* malware */
 299 #endif
 300   TRUE,    /* message */
 301 #ifdef WITH_CONTENT_SCAN
 302   TRUE,    /* mime_regex */
 303 #endif
 304   TRUE,    /* ratelimit */
 305   FALSE,   /* recipients */
 306 #ifdef WITH_CONTENT_SCAN
 307   TRUE,    /* regex */
 308 #endif
 309   TRUE,    /* remove_header */
 310   FALSE,   /* sender_domains */
 311   FALSE,   /* senders */
 312   TRUE,    /* set */
 313 #ifdef WITH_CONTENT_SCAN
 314   TRUE,    /* spam */
 315 #endif
 316 #ifdef EXPERIMENTAL_SPF
 317   TRUE,    /* spf */
 318   TRUE,    /* spf_guess */
 319 #endif
 320   TRUE,    /* udpsend */
 321   TRUE     /* verify */
 322 };
 323
 324 /* Flags to identify the modifiers */
 325
 326 static uschar cond_modifiers[] = {
 327   FALSE,   /* acl */
 328   TRUE,    /* add_header */
 329   FALSE,   /* authenticated */
 330 #ifdef EXPERIMENTAL_BRIGHTMAIL
 331   TRUE,    /* bmi_optin */
 332 #endif
 333   FALSE,   /* condition */
 334   TRUE,    /* continue */
 335   TRUE,    /* control */
 336 #ifdef EXPERIMENTAL_DCC
 337   FALSE,   /* dcc */
 338 #endif
 339 #ifdef WITH_CONTENT_SCAN
 340   FALSE,   /* decode */
 341 #endif
 342   TRUE,    /* delay */
 343 #ifdef WITH_OLD_DEMIME
 344   FALSE,   /* demime */
 345 #endif
 346 #ifndef DISABLE_DKIM
 347   FALSE,   /* dkim_signers */
 348   FALSE,   /* dkim_status */
 349 #endif
 350 #ifdef EXPERIMENTAL_DMARC
 351   FALSE,   /* dmarc_status */
 352 #endif
 353   FALSE,   /* dnslists */
 354   FALSE,   /* domains */
 355   FALSE,   /* encrypted */
 356   TRUE,    /* endpass */
 357   FALSE,   /* hosts */
 358   FALSE,   /* local_parts */
 359   TRUE,    /* log_message */
 360   TRUE,    /* log_reject_target */
 361   TRUE,    /* logwrite */
 362 #ifdef WITH_CONTENT_SCAN
 363   FALSE,   /* malware */
 364 #endif
 365   TRUE,    /* message */
 366 #ifdef WITH_CONTENT_SCAN
 367   FALSE,   /* mime_regex */
 368 #endif
 369   FALSE,   /* ratelimit */
 370   FALSE,   /* recipients */
 371 #ifdef WITH_CONTENT_SCAN
 372   FALSE,   /* regex */
 373 #endif
 374   TRUE,    /* remove_header */
 375   FALSE,   /* sender_domains */
 376   FALSE,   /* senders */
 377   TRUE,    /* set */
 378 #ifdef WITH_CONTENT_SCAN
 379   FALSE,   /* spam */
 380 #endif
 381 #ifdef EXPERIMENTAL_SPF
 382   FALSE,   /* spf */
 383   FALSE,   /* spf_guess */
 384 #endif
 385   TRUE,    /* udpsend */
 386   FALSE    /* verify */
 387 };
 388
 389 /* Bit map vector of which conditions and modifiers are not allowed at certain
 390 times. For each condition and modifier, there's a bitmap of dis-allowed times.
 391 For some, it is easier to specify the negation of a small number of allowed
 392 times. */
 393
 394 static unsigned int cond_forbids[] = {
 395   0,                                               /* acl */
 396
 397   (unsigned int)
 398   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* add_header */
 399     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 400   #ifdef EXPERIMENTAL_PRDR
 401     (1<<ACL_WHERE_PRDR)|
 402   #endif
 403     (1<<ACL_WHERE_MIME)|(1<<ACL_WHERE_NOTSMTP)|
 404     (1<<ACL_WHERE_DKIM)|
 405     (1<<ACL_WHERE_NOTSMTP_START)),
 406
 407   (1<<ACL_WHERE_NOTSMTP)|                          /* authenticated */
 408     (1<<ACL_WHERE_NOTSMTP_START)|
 409     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO),
 410
 411   #ifdef EXPERIMENTAL_BRIGHTMAIL
 412   (1<<ACL_WHERE_AUTH)|                             /* bmi_optin */
 413     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
 414     (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_MIME)|
 415   #ifdef EXPERIMENTAL_PRDR
 416     (1<<ACL_WHERE_PRDR)|
 417   #endif
 418     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
 419     (1<<ACL_WHERE_MAILAUTH)|
 420     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
 421     (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_PREDATA)|
 422     (1<<ACL_WHERE_NOTSMTP_START),
 423   #endif
 424
 425   0,                                               /* condition */
 426
 427   0,                                               /* continue */
 428
 429   /* Certain types of control are always allowed, so we let it through
 430   always and check in the control processing itself. */
 431
 432   0,                                               /* control */
 433
 434   #ifdef EXPERIMENTAL_DCC
 435   (unsigned int)
 436   ~((1<<ACL_WHERE_DATA)|                           /* dcc */
 437   #ifdef EXPERIMENTAL_PRDR
 438     (1<<ACL_WHERE_PRDR)|
 439   #endif /* EXPERIMENTAL_PRDR */
 440     (1<<ACL_WHERE_NOTSMTP)),
 441   #endif
 442
 443   #ifdef WITH_CONTENT_SCAN
 444   (unsigned int)
 445   ~(1<<ACL_WHERE_MIME),                            /* decode */
 446   #endif
 447
 448   (1<<ACL_WHERE_NOTQUIT),                          /* delay */
 449
 450   #ifdef WITH_OLD_DEMIME
 451   (unsigned int)
 452   ~((1<<ACL_WHERE_DATA)|                           /* demime */
 453   #ifdef EXPERIMENTAL_PRDR
 454     (1<<ACL_WHERE_PRDR)|
 455   #endif /* EXPERIMENTAL_PRDR */
 456     (1<<ACL_WHERE_NOTSMTP)),
 457   #endif
 458
 459   #ifndef DISABLE_DKIM
 460   (unsigned int)
 461   ~(1<<ACL_WHERE_DKIM),                            /* dkim_signers */
 462
 463   (unsigned int)
 464   ~(1<<ACL_WHERE_DKIM),                            /* dkim_status */
 465   #endif
 466
 467   #ifdef EXPERIMENTAL_DMARC
 468   (unsigned int)
 469   ~(1<<ACL_WHERE_DATA),                            /* dmarc_status */
 470   #endif
 471
 472   (1<<ACL_WHERE_NOTSMTP)|                          /* dnslists */
 473     (1<<ACL_WHERE_NOTSMTP_START),
 474
 475   (unsigned int)
 476   ~((1<<ACL_WHERE_RCPT)                            /* domains */
 477   #ifdef EXPERIMENTAL_PRDR
 478     |(1<<ACL_WHERE_PRDR)
 479   #endif
 480     ),
 481
 482   (1<<ACL_WHERE_NOTSMTP)|                          /* encrypted */
 483     (1<<ACL_WHERE_CONNECT)|
 484     (1<<ACL_WHERE_NOTSMTP_START)|
 485     (1<<ACL_WHERE_HELO),
 486
 487   0,                                               /* endpass */
 488
 489   (1<<ACL_WHERE_NOTSMTP)|                          /* hosts */
 490     (1<<ACL_WHERE_NOTSMTP_START),
 491
 492   (unsigned int)
 493   ~((1<<ACL_WHERE_RCPT)                             /* local_parts */
 494   #ifdef EXPERIMENTAL_PRDR
 495     |(1<<ACL_WHERE_PRDR)
 496   #endif
 497     ),
 498
 499   0,                                               /* log_message */
 500
 501   0,                                               /* log_reject_target */
 502
 503   0,                                               /* logwrite */
 504
 505   #ifdef WITH_CONTENT_SCAN
 506   (unsigned int)
 507   ~((1<<ACL_WHERE_DATA)|                           /* malware */
 508   #ifdef EXPERIMENTAL_PRDR
 509     (1<<ACL_WHERE_PRDR)|
 510   #endif /* EXPERIMENTAL_PRDR */
 511     (1<<ACL_WHERE_NOTSMTP)),
 512   #endif
 513
 514   0,                                               /* message */
 515
 516   #ifdef WITH_CONTENT_SCAN
 517   (unsigned int)
 518   ~(1<<ACL_WHERE_MIME),                            /* mime_regex */
 519   #endif
 520
 521   0,                                               /* ratelimit */
 522
 523   (unsigned int)
 524   ~(1<<ACL_WHERE_RCPT),                            /* recipients */
 525
 526   #ifdef WITH_CONTENT_SCAN
 527   (unsigned int)
 528   ~((1<<ACL_WHERE_DATA)|                           /* regex */
 529   #ifdef EXPERIMENTAL_PRDR
 530     (1<<ACL_WHERE_PRDR)|
 531   #endif /* EXPERIMENTAL_PRDR */
 532     (1<<ACL_WHERE_NOTSMTP)|
 533     (1<<ACL_WHERE_MIME)),
 534   #endif
 535
 536   (unsigned int)
 537   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* remove_header */
 538     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 539   #ifdef EXPERIMENTAL_PRDR
 540     (1<<ACL_WHERE_PRDR)|
 541   #endif
 542     (1<<ACL_WHERE_MIME)|(1<<ACL_WHERE_NOTSMTP)|
 543     (1<<ACL_WHERE_NOTSMTP_START)),
 544
 545   (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|      /* sender_domains */
 546     (1<<ACL_WHERE_HELO)|
 547     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
 548     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
 549     (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
 550
 551   (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|      /* senders */
 552     (1<<ACL_WHERE_HELO)|
 553     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
 554     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
 555     (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
 556
 557   0,                                               /* set */
 558
 559   #ifdef WITH_CONTENT_SCAN
 560   (unsigned int)
 561   ~((1<<ACL_WHERE_DATA)|                           /* spam */
 562   #ifdef EXPERIMENTAL_PRDR
 563     (1<<ACL_WHERE_PRDR)|
 564   #endif /* EXPERIMENTAL_PRDR */
 565     (1<<ACL_WHERE_NOTSMTP)),
 566   #endif
 567
 568   #ifdef EXPERIMENTAL_SPF
 569   (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|      /* spf */
 570     (1<<ACL_WHERE_HELO)|
 571     (1<<ACL_WHERE_MAILAUTH)|
 572     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
 573     (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY)|
 574     (1<<ACL_WHERE_NOTSMTP)|
 575     (1<<ACL_WHERE_NOTSMTP_START),
 576
 577   (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|      /* spf_guess */
 578     (1<<ACL_WHERE_HELO)|
 579     (1<<ACL_WHERE_MAILAUTH)|
 580     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
 581     (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY)|
 582     (1<<ACL_WHERE_NOTSMTP)|
 583     (1<<ACL_WHERE_NOTSMTP_START),
 584   #endif
 585
 586   0,                                               /* udpsend */
 587
 588   /* Certain types of verify are always allowed, so we let it through
 589   always and check in the verify function itself */
 590
 591   0                                                /* verify */
 592 };
 593
 594
 595 /* Bit map vector of which controls are not allowed at certain times. For
 596 each control, there's a bitmap of dis-allowed times. For some, it is easier to
 597 specify the negation of a small number of allowed times. */
 598
 599 static unsigned int control_forbids[] = {
 600   (unsigned int)
 601   ~((1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)),   /* allow_auth_unadvertised */
 602
 603   #ifdef EXPERIMENTAL_BRIGHTMAIL
 604   0,                                               /* bmi_run */
 605   #endif
 606
 607   0,                                               /* debug */
 608
 609   #ifndef DISABLE_DKIM
 610   (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|      /* dkim_disable_verify */
 611   #ifdef EXPERIMENTAL_PRDR
 612     (1<<ACL_WHERE_PRDR)|
 613   #endif /* EXPERIMENTAL_PRDR */
 614     (1<<ACL_WHERE_NOTSMTP_START),
 615   #endif
 616
 617   #ifdef EXPERIMENTAL_DMARC
 618   (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|      /* dmarc_disable_verify */
 619     (1<<ACL_WHERE_NOTSMTP_START),
 620   (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|      /* dmarc_enable_forensic */
 621     (1<<ACL_WHERE_NOTSMTP_START),
 622   #endif
 623
 624   (1<<ACL_WHERE_NOTSMTP)|
 625     (1<<ACL_WHERE_NOTSMTP_START)|
 626     (1<<ACL_WHERE_NOTQUIT),                        /* dscp */
 627
 628   0,                                               /* error */
 629
 630   (unsigned int)
 631   ~(1<<ACL_WHERE_RCPT),                            /* caseful_local_part */
 632
 633   (unsigned int)
 634   ~(1<<ACL_WHERE_RCPT),                            /* caselower_local_part */
 635
 636   (unsigned int)
 637   0,                                               /* cutthrough_delivery */
 638
 639   (1<<ACL_WHERE_NOTSMTP)|                          /* enforce_sync */
 640     (1<<ACL_WHERE_NOTSMTP_START),
 641
 642   (1<<ACL_WHERE_NOTSMTP)|                          /* no_enforce_sync */
 643     (1<<ACL_WHERE_NOTSMTP_START),
 644
 645   (unsigned int)
 646   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* freeze */
 647     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 648     // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
 649     (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_MIME)),
 650
 651   (unsigned int)
 652   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* queue_only */
 653     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 654     // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
 655     (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_MIME)),
 656
 657   (unsigned int)
 658   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* submission */
 659     (1<<ACL_WHERE_PREDATA)),
 660
 661   (unsigned int)
 662   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* suppress_local_fixups */
 663     (1<<ACL_WHERE_PREDATA)|
 664     (1<<ACL_WHERE_NOTSMTP_START)),
 665
 666   #ifdef WITH_CONTENT_SCAN
 667   (unsigned int)
 668   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* no_mbox_unspool */
 669     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 670     // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
 671     (1<<ACL_WHERE_MIME)),
 672   #endif
 673
 674   (unsigned int)
 675   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* fakedefer */
 676     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 677   #ifdef EXPERIMENTAL_PRDR
 678     (1<<ACL_WHERE_PRDR)|
 679   #endif /* EXPERIMENTAL_PRDR */
 680     (1<<ACL_WHERE_MIME)),
 681
 682   (unsigned int)
 683   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* fakereject */
 684     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 685   #ifdef EXPERIMENTAL_PRDR
 686     (1<<ACL_WHERE_PRDR)|
 687   #endif /* EXPERIMENTAL_PRDR */
 688     (1<<ACL_WHERE_MIME)),
 689
 690   (1<<ACL_WHERE_NOTSMTP)|                          /* no_multiline */
 691     (1<<ACL_WHERE_NOTSMTP_START),
 692
 693   (1<<ACL_WHERE_NOTSMTP)|                          /* no_pipelining */
 694     (1<<ACL_WHERE_NOTSMTP_START),
 695
 696   (1<<ACL_WHERE_NOTSMTP)|                          /* no_delay_flush */
 697     (1<<ACL_WHERE_NOTSMTP_START),
 698
 699   (1<<ACL_WHERE_NOTSMTP)|                          /* no_callout_flush */
 700     (1<<ACL_WHERE_NOTSMTP_START)
 701 };
 702
 703 /* Structure listing various control arguments, with their characteristics. */
 704
 705 typedef struct control_def {
 706   uschar *name;
 707   int    value;                  /* CONTROL_xxx value */
 708   BOOL   has_option;             /* Has /option(s) following */
 709 } control_def;
 710
 711 static control_def controls_list[] = {
 712   { US"allow_auth_unadvertised", CONTROL_AUTH_UNADVERTISED, FALSE },
 713 #ifdef EXPERIMENTAL_BRIGHTMAIL
 714   { US"bmi_run",                 CONTROL_BMI_RUN, FALSE },
 715 #endif
 716   { US"debug",                   CONTROL_DEBUG, TRUE },
 717 #ifndef DISABLE_DKIM
 718   { US"dkim_disable_verify",     CONTROL_DKIM_VERIFY, FALSE },
 719 #endif
 720 #ifdef EXPERIMENTAL_DMARC
 721   { US"dmarc_disable_verify",    CONTROL_DMARC_VERIFY, FALSE },
 722   { US"dmarc_enable_forensic",   CONTROL_DMARC_FORENSIC, FALSE },
 723 #endif
 724   { US"dscp",                    CONTROL_DSCP, TRUE },
 725   { US"caseful_local_part",      CONTROL_CASEFUL_LOCAL_PART, FALSE },
 726   { US"caselower_local_part",    CONTROL_CASELOWER_LOCAL_PART, FALSE },
 727   { US"enforce_sync",            CONTROL_ENFORCE_SYNC, FALSE },
 728   { US"freeze",                  CONTROL_FREEZE, TRUE },
 729   { US"no_callout_flush",        CONTROL_NO_CALLOUT_FLUSH, FALSE },
 730   { US"no_delay_flush",          CONTROL_NO_DELAY_FLUSH, FALSE },
 731   { US"no_enforce_sync",         CONTROL_NO_ENFORCE_SYNC, FALSE },
 732   { US"no_multiline_responses",  CONTROL_NO_MULTILINE, FALSE },
 733   { US"no_pipelining",           CONTROL_NO_PIPELINING, FALSE },
 734   { US"queue_only",              CONTROL_QUEUE_ONLY, FALSE },
 735 #ifdef WITH_CONTENT_SCAN
 736   { US"no_mbox_unspool",         CONTROL_NO_MBOX_UNSPOOL, FALSE },
 737 #endif
 738   { US"fakedefer",               CONTROL_FAKEDEFER, TRUE },
 739   { US"fakereject",              CONTROL_FAKEREJECT, TRUE },
 740   { US"submission",              CONTROL_SUBMISSION, TRUE },
 741   { US"suppress_local_fixups",   CONTROL_SUPPRESS_LOCAL_FIXUPS, FALSE },
 742   { US"cutthrough_delivery",     CONTROL_CUTTHROUGH_DELIVERY, FALSE }
 743   };
 744
 745 /* Support data structures for Client SMTP Authorization. acl_verify_csa()
 746 caches its result in a tree to avoid repeated DNS queries. The result is an
 747 integer code which is used as an index into the following tables of
 748 explanatory strings and verification return codes. */
 749
 750 static tree_node *csa_cache = NULL;
 751
 752 enum { CSA_UNKNOWN, CSA_OK, CSA_DEFER_SRV, CSA_DEFER_ADDR,
 753  CSA_FAIL_EXPLICIT, CSA_FAIL_DOMAIN, CSA_FAIL_NOADDR, CSA_FAIL_MISMATCH };
 754
 755 /* The acl_verify_csa() return code is translated into an acl_verify() return
 756 code using the following table. It is OK unless the client is definitely not
 757 authorized. This is because CSA is supposed to be optional for sending sites,
 758 so recipients should not be too strict about checking it - especially because
 759 DNS problems are quite likely to occur. It's possible to use $csa_status in
 760 further ACL conditions to distinguish ok, unknown, and defer if required, but
 761 the aim is to make the usual configuration simple. */
 762
 763 static int csa_return_code[] = {
 764   OK, OK, OK, OK,
 765   FAIL, FAIL, FAIL, FAIL
 766 };
 767
 768 static uschar *csa_status_string[] = {
 769   US"unknown", US"ok", US"defer", US"defer",
 770   US"fail", US"fail", US"fail", US"fail"
 771 };
 772
 773 static uschar *csa_reason_string[] = {
 774   US"unknown",
 775   US"ok",
 776   US"deferred (SRV lookup failed)",
 777   US"deferred (target address lookup failed)",
 778   US"failed (explicit authorization required)",
 779   US"failed (host name not authorized)",
 780   US"failed (no authorized addresses)",
 781   US"failed (client address mismatch)"
 782 };
 783
 784 /* Options for the ratelimit condition. Note that there are two variants of
 785 the per_rcpt option, depending on the ACL that is used to measure the rate.
 786 However any ACL must be able to look up per_rcpt rates in /noupdate mode,
 787 so the two variants must have the same internal representation as well as
 788 the same configuration string. */
 789
 790 enum {
 791   RATE_PER_WHAT, RATE_PER_CLASH, RATE_PER_ADDR, RATE_PER_BYTE, RATE_PER_CMD,
 792   RATE_PER_CONN, RATE_PER_MAIL, RATE_PER_RCPT, RATE_PER_ALLRCPTS
 793 };
 794
 795 #define RATE_SET(var,new) \
 796   (((var) == RATE_PER_WHAT) ? ((var) = RATE_##new) : ((var) = RATE_PER_CLASH))
 797
 798 static uschar *ratelimit_option_string[] = {
 799   US"?", US"!", US"per_addr", US"per_byte", US"per_cmd",
 800   US"per_conn", US"per_mail", US"per_rcpt", US"per_rcpt"
 801 };
 802
 803 /* Enable recursion between acl_check_internal() and acl_check_condition() */
 804
 805 static int acl_check_wargs(int, address_item *, uschar *, int, uschar **,
 806     uschar **);
 807
 808
 809 /*************************************************
 810 *         Pick out name from list                *
 811 *************************************************/
 812
 813 /* Use a binary chop method
 814
 815 Arguments:
 816   name        name to find
 817   list        list of names
 818   end         size of list
 819
 820 Returns:      offset in list, or -1 if not found
 821 */
 822
 823 static int
 824 acl_checkname(uschar *name, uschar **list, int end)
 825 {
 826 int start = 0;
 827
 828 while (start < end)
 829   {
 830   int mid = (start + end)/2;
 831   int c = Ustrcmp(name, list[mid]);
 832   if (c == 0) return mid;
 833   if (c < 0) end = mid; else start = mid + 1;
 834   }
 835
 836 return -1;
 837 }
 838
 839
 840 /*************************************************
 841 *            Read and parse one ACL              *
 842 *************************************************/
 843
 844 /* This function is called both from readconf in order to parse the ACLs in the
 845 configuration file, and also when an ACL is encountered dynamically (e.g. as
 846 the result of an expansion). It is given a function to call in order to
 847 retrieve the lines of the ACL. This function handles skipping comments and
 848 blank lines (where relevant).
 849
 850 Arguments:
 851   func        function to get next line of ACL
 852   error       where to put an error message
 853
 854 Returns:      pointer to ACL, or NULL
 855               NULL can be legal (empty ACL); in this case error will be NULL
 856 */
 857
 858 acl_block *
 859 acl_read(uschar *(*func)(void), uschar **error)
 860 {
 861 acl_block *yield = NULL;
 862 acl_block **lastp = &yield;
 863 acl_block *this = NULL;
 864 acl_condition_block *cond;
 865 acl_condition_block **condp = NULL;
 866 uschar *s;
 867
 868 *error = NULL;
 869
 870 while ((s = (*func)()) != NULL)
 871   {
 872   int v, c;
 873   BOOL negated = FALSE;
 874   uschar *saveline = s;
 875   uschar name[64];
 876
 877   /* Conditions (but not verbs) are allowed to be negated by an initial
 878   exclamation mark. */
 879
 880   while (isspace(*s)) s++;
 881   if (*s == '!')
 882     {
 883     negated = TRUE;
 884     s++;
 885     }
 886
 887   /* Read the name of a verb or a condition, or the start of a new ACL, which
 888   can be started by a name, or by a macro definition. */
 889
 890   s = readconf_readname(name, sizeof(name), s);
 891   if (*s == ':' || (isupper(name[0]) && *s == '=')) return yield;
 892
 893   /* If a verb is unrecognized, it may be another condition or modifier that
 894   continues the previous verb. */
 895
 896   v = acl_checkname(name, verbs, sizeof(verbs)/sizeof(char *));
 897   if (v < 0)
 898     {
 899     if (this == NULL)
 900       {
 901       *error = string_sprintf("unknown ACL verb \"%s\" in \"%s\"", name,
 902         saveline);
 903       return NULL;
 904       }
 905     }
 906
 907   /* New verb */
 908
 909   else
 910     {
 911     if (negated)
 912       {
 913       *error = string_sprintf("malformed ACL line \"%s\"", saveline);
 914       return NULL;
 915       }
 916     this = store_get(sizeof(acl_block));
 917     *lastp = this;
 918     lastp = &(this->next);
 919     this->next = NULL;
 920     this->verb = v;
 921     this->condition = NULL;
 922     condp = &(this->condition);
 923     if (*s == 0) continue;               /* No condition on this line */
 924     if (*s == '!')
 925       {
 926       negated = TRUE;
 927       s++;
 928       }
 929     s = readconf_readname(name, sizeof(name), s);  /* Condition name */
 930     }
 931
 932   /* Handle a condition or modifier. */
 933
 934   c = acl_checkname(name, conditions, sizeof(conditions)/sizeof(char *));
 935   if (c < 0)
 936     {
 937     *error = string_sprintf("unknown ACL condition/modifier in \"%s\"",
 938       saveline);
 939     return NULL;
 940     }
 941
 942   /* The modifiers may not be negated */
 943
 944   if (negated && cond_modifiers[c])
 945     {
 946     *error = string_sprintf("ACL error: negation is not allowed with "
 947       "\"%s\"", conditions[c]);
 948     return NULL;
 949     }
 950
 951   /* ENDPASS may occur only with ACCEPT or DISCARD. */
 952
 953   if (c == ACLC_ENDPASS &&
 954       this->verb != ACL_ACCEPT &&
 955       this->verb != ACL_DISCARD)
 956     {
 957     *error = string_sprintf("ACL error: \"%s\" is not allowed with \"%s\"",
 958       conditions[c], verbs[this->verb]);
 959     return NULL;
 960     }
 961
 962   cond = store_get(sizeof(acl_condition_block));
 963   cond->next = NULL;
 964   cond->type = c;
 965   cond->u.negated = negated;
 966
 967   *condp = cond;
 968   condp = &(cond->next);
 969
 970   /* The "set" modifier is different in that its argument is "name=value"
 971   rather than just a value, and we can check the validity of the name, which
 972   gives us a variable name to insert into the data block. The original ACL
 973   variable names were acl_c0 ... acl_c9 and acl_m0 ... acl_m9. This was
 974   extended to 20 of each type, but after that people successfully argued for
 975   arbitrary names. In the new scheme, the names must start with acl_c or acl_m.
 976   After that, we allow alphanumerics and underscores, but the first character
 977   after c or m must be a digit or an underscore. This retains backwards
 978   compatibility. */
 979
 980   if (c == ACLC_SET)
 981     {
 982     uschar *endptr;
 983
 984     if (Ustrncmp(s, "acl_c", 5) != 0 &&
 985         Ustrncmp(s, "acl_m", 5) != 0)
 986       {
 987       *error = string_sprintf("invalid variable name after \"set\" in ACL "
 988         "modifier \"set %s\" (must start \"acl_c\" or \"acl_m\")", s);
 989       return NULL;
 990       }
 991
 992     endptr = s + 5;
 993     if (!isdigit(*endptr) && *endptr != '_')
 994       {
 995       *error = string_sprintf("invalid variable name after \"set\" in ACL "
 996         "modifier \"set %s\" (digit or underscore must follow acl_c or acl_m)",
 997         s);
 998       return NULL;
 999       }
1000
1001     while (*endptr != 0 && *endptr != '=' && !isspace(*endptr))
1002       {
1003       if (!isalnum(*endptr) && *endptr != '_')
1004         {
1005         *error = string_sprintf("invalid character \"%c\" in variable name "
1006           "in ACL modifier \"set %s\"", *endptr, s);
1007         return NULL;
1008         }
1009       endptr++;
1010       }
1011
1012     cond->u.varname = string_copyn(s + 4, endptr - s - 4);
1013     s = endptr;
1014     while (isspace(*s)) s++;
1015     }
1016
1017   /* For "set", we are now positioned for the data. For the others, only
1018   "endpass" has no data */
1019
1020   if (c != ACLC_ENDPASS)
1021     {
1022     if (*s++ != '=')
1023       {
1024       *error = string_sprintf("\"=\" missing after ACL \"%s\" %s", name,
1025         cond_modifiers[c]? US"modifier" : US"condition");
1026       return NULL;
1027       }
1028     while (isspace(*s)) s++;
1029     cond->arg = string_copy(s);
1030     }
1031   }
1032
1033 return yield;
1034 }
1035
1036
1037
1038 /*************************************************
1039 *         Set up added header line(s)            *
1040 *************************************************/
1041
1042 /* This function is called by the add_header modifier, and also from acl_warn()
1043 to implement the now-deprecated way of adding header lines using "message" on a
1044 "warn" verb. The argument is treated as a sequence of header lines which are
1045 added to a chain, provided there isn't an identical one already there.
1046
1047 Argument:   string of header lines
1048 Returns:    nothing
1049 */
1050
1051 static void
1052 setup_header(uschar *hstring)
1053 {
1054 uschar *p, *q;
1055 int hlen = Ustrlen(hstring);
1056
1057 /* Ignore any leading newlines */
1058 while (*hstring == '\n') hstring++, hlen--;
1059
1060 /* An empty string does nothing; ensure exactly one final newline. */
1061 if (hlen <= 0) return;
1062 if (hstring[--hlen] != '\n') hstring = string_sprintf("%s\n", hstring);
1063 else while(hstring[--hlen] == '\n') hstring[hlen+1] = '\0';
1064
1065 /* Loop for multiple header lines, taking care about continuations */
1066
1067 for (p = q = hstring; *p != 0; )
1068   {
1069   uschar *s;
1070   int newtype = htype_add_bot;
1071   header_line **hptr = &acl_added_headers;
1072
1073   /* Find next header line within the string */
1074
1075   for (;;)
1076     {
1077     q = Ustrchr(q, '\n');
1078     if (*(++q) != ' ' && *q != '\t') break;
1079     }
1080
1081   /* If the line starts with a colon, interpret the instruction for where to
1082   add it. This temporarily sets up a new type. */
1083
1084   if (*p == ':')
1085     {
1086     if (strncmpic(p, US":after_received:", 16) == 0)
1087       {
1088       newtype = htype_add_rec;
1089       p += 16;
1090       }
1091     else if (strncmpic(p, US":at_start_rfc:", 14) == 0)
1092       {
1093       newtype = htype_add_rfc;
1094       p += 14;
1095       }
1096     else if (strncmpic(p, US":at_start:", 10) == 0)
1097       {
1098       newtype = htype_add_top;
1099       p += 10;
1100       }
1101     else if (strncmpic(p, US":at_end:", 8) == 0)
1102       {
1103       newtype = htype_add_bot;
1104       p += 8;
1105       }
1106     while (*p == ' ' || *p == '\t') p++;
1107     }
1108
1109   /* See if this line starts with a header name, and if not, add X-ACL-Warn:
1110   to the front of it. */
1111
1112   for (s = p; s < q - 1; s++)
1113     {
1114     if (*s == ':' || !isgraph(*s)) break;
1115     }
1116
1117   s = string_sprintf("%s%.*s", (*s == ':')? "" : "X-ACL-Warn: ", (int) (q - p), p);
1118   hlen = Ustrlen(s);
1119
1120   /* See if this line has already been added */
1121
1122   while (*hptr != NULL)
1123     {
1124     if (Ustrncmp((*hptr)->text, s, hlen) == 0) break;
1125     hptr = &((*hptr)->next);
1126     }
1127
1128   /* Add if not previously present */
1129
1130   if (*hptr == NULL)
1131     {
1132     header_line *h = store_get(sizeof(header_line));
1133     h->text = s;
1134     h->next = NULL;
1135     h->type = newtype;
1136     h->slen = hlen;
1137     *hptr = h;
1138     hptr = &(h->next);
1139     }
1140
1141   /* Advance for next header line within the string */
1142
1143   p = q;
1144   }
1145 }
1146
1147
1148
1149 /*************************************************
1150 *        List the added header lines             *
1151 *************************************************/
1152 uschar *
1153 fn_hdrs_added(void)
1154 {
1155 uschar * ret = NULL;
1156 header_line * h = acl_added_headers;
1157 uschar * s;
1158 uschar * cp;
1159 int size = 0;
1160 int ptr = 0;
1161
1162 if (!h) return NULL;
1163
1164 do
1165   {
1166   s = h->text;
1167   while ((cp = Ustrchr(s, '\n')) != NULL)
1168     {
1169     if (cp[1] == '\0') break;
1170
1171     /* contains embedded newline; needs doubling */
1172     ret = string_cat(ret, &size, &ptr, s, cp-s+1);
1173     ret = string_cat(ret, &size, &ptr, US"\n", 1);
1174     s = cp+1;
1175     }
1176   /* last bit of header */
1177
1178   ret = string_cat(ret, &size, &ptr, s, cp-s+1);        /* newline-sep list */
1179   }
1180 while((h = h->next));
1181
1182 ret[ptr-1] = '\0';      /* overwrite last newline */
1183 return ret;
1184 }
1185
1186
1187 /*************************************************
1188 *        Set up removed header line(s)           *
1189 *************************************************/
1190
1191 /* This function is called by the remove_header modifier.  The argument is
1192 treated as a sequence of header names which are added to a colon separated
1193 list, provided there isn't an identical one already there.
1194
1195 Argument:   string of header names
1196 Returns:    nothing
1197 */
1198
1199 static void
1200 setup_remove_header(uschar *hnames)
1201 {
1202 if (*hnames != 0)
1203   {
1204   if (acl_removed_headers == NULL)
1205     acl_removed_headers = hnames;
1206   else
1207     acl_removed_headers = string_sprintf("%s : %s", acl_removed_headers, hnames);
1208   }
1209 }
1210
1211
1212
1213 /*************************************************
1214 *               Handle warnings                  *
1215 *************************************************/
1216
1217 /* This function is called when a WARN verb's conditions are true. It adds to
1218 the message's headers, and/or writes information to the log. In each case, this
1219 only happens once (per message for headers, per connection for log).
1220
1221 ** NOTE: The header adding action using the "message" setting is historic, and
1222 its use is now deprecated. The new add_header modifier should be used instead.
1223
1224 Arguments:
1225   where          ACL_WHERE_xxxx indicating which ACL this is
1226   user_message   message for adding to headers
1227   log_message    message for logging, if different
1228
1229 Returns:         nothing
1230 */
1231
1232 static void
1233 acl_warn(int where, uschar *user_message, uschar *log_message)
1234 {
1235 if (log_message != NULL && log_message != user_message)
1236   {
1237   uschar *text;
1238   string_item *logged;
1239
1240   text = string_sprintf("%s Warning: %s",  host_and_ident(TRUE),
1241     string_printing(log_message));
1242
1243   /* If a sender verification has failed, and the log message is "sender verify
1244   failed", add the failure message. */
1245
1246   if (sender_verified_failed != NULL &&
1247       sender_verified_failed->message != NULL &&
1248       strcmpic(log_message, US"sender verify failed") == 0)
1249     text = string_sprintf("%s: %s", text, sender_verified_failed->message);
1250
1251   /* Search previously logged warnings. They are kept in malloc
1252   store so they can be freed at the start of a new message. */
1253
1254   for (logged = acl_warn_logged; logged != NULL; logged = logged->next)
1255     if (Ustrcmp(logged->text, text) == 0) break;
1256
1257   if (logged == NULL)
1258     {
1259     int length = Ustrlen(text) + 1;
1260     log_write(0, LOG_MAIN, "%s", text);
1261     logged = store_malloc(sizeof(string_item) + length);
1262     logged->text = (uschar *)logged + sizeof(string_item);
1263     memcpy(logged->text, text, length);
1264     logged->next = acl_warn_logged;
1265     acl_warn_logged = logged;
1266     }
1267   }
1268
1269 /* If there's no user message, we are done. */
1270
1271 if (user_message == NULL) return;
1272
1273 /* If this isn't a message ACL, we can't do anything with a user message.
1274 Log an error. */
1275
1276 if (where > ACL_WHERE_NOTSMTP)
1277   {
1278   log_write(0, LOG_MAIN|LOG_PANIC, "ACL \"warn\" with \"message\" setting "
1279     "found in a non-message (%s) ACL: cannot specify header lines here: "
1280     "message ignored", acl_wherenames[where]);
1281   return;
1282   }
1283
1284 /* The code for setting up header lines is now abstracted into a separate
1285 function so that it can be used for the add_header modifier as well. */
1286
1287 setup_header(user_message);
1288 }
1289
1290
1291
1292 /*************************************************
1293 *         Verify and check reverse DNS           *
1294 *************************************************/
1295
1296 /* Called from acl_verify() below. We look up the host name(s) of the client IP
1297 address if this has not yet been done. The host_name_lookup() function checks
1298 that one of these names resolves to an address list that contains the client IP
1299 address, so we don't actually have to do the check here.
1300
1301 Arguments:
1302   user_msgptr  pointer for user message
1303   log_msgptr   pointer for log message
1304
1305 Returns:       OK        verification condition succeeded
1306                FAIL      verification failed
1307                DEFER     there was a problem verifying
1308 */
1309
1310 static int
1311 acl_verify_reverse(uschar **user_msgptr, uschar **log_msgptr)
1312 {
1313 int rc;
1314
1315 user_msgptr = user_msgptr;  /* stop compiler warning */
1316
1317 /* Previous success */
1318
1319 if (sender_host_name != NULL) return OK;
1320
1321 /* Previous failure */
1322
1323 if (host_lookup_failed)
1324   {
1325   *log_msgptr = string_sprintf("host lookup failed%s", host_lookup_msg);
1326   return FAIL;
1327   }
1328
1329 /* Need to do a lookup */
1330
1331 HDEBUG(D_acl)
1332   debug_printf("looking up host name to force name/address consistency check\n");
1333
1334 if ((rc = host_name_lookup()) != OK)
1335   {
1336   *log_msgptr = (rc == DEFER)?
1337     US"host lookup deferred for reverse lookup check"
1338     :
1339     string_sprintf("host lookup failed for reverse lookup check%s",
1340       host_lookup_msg);
1341   return rc;    /* DEFER or FAIL */
1342   }
1343
1344 host_build_sender_fullhost();
1345 return OK;
1346 }
1347
1348
1349
1350 /*************************************************
1351 *   Check client IP address matches CSA target   *
1352 *************************************************/
1353
1354 /* Called from acl_verify_csa() below. This routine scans a section of a DNS
1355 response for address records belonging to the CSA target hostname. The section
1356 is specified by the reset argument, either RESET_ADDITIONAL or RESET_ANSWERS.
1357 If one of the addresses matches the client's IP address, then the client is
1358 authorized by CSA. If there are target IP addresses but none of them match
1359 then the client is using an unauthorized IP address. If there are no target IP
1360 addresses then the client cannot be using an authorized IP address. (This is
1361 an odd configuration - why didn't the SRV record have a weight of 1 instead?)
1362
1363 Arguments:
1364   dnsa       the DNS answer block
1365   dnss       a DNS scan block for us to use
1366   reset      option specifing what portion to scan, as described above
1367   target     the target hostname to use for matching RR names
1368
1369 Returns:     CSA_OK             successfully authorized
1370              CSA_FAIL_MISMATCH  addresses found but none matched
1371              CSA_FAIL_NOADDR    no target addresses found
1372 */
1373
1374 static int
1375 acl_verify_csa_address(dns_answer *dnsa, dns_scan *dnss, int reset,
1376                        uschar *target)
1377 {
1378 dns_record *rr;
1379 dns_address *da;
1380
1381 BOOL target_found = FALSE;
1382
1383 for (rr = dns_next_rr(dnsa, dnss, reset);
1384      rr != NULL;
1385      rr = dns_next_rr(dnsa, dnss, RESET_NEXT))
1386   {
1387   /* Check this is an address RR for the target hostname. */
1388
1389   if (rr->type != T_A
1390     #if HAVE_IPV6
1391       && rr->type != T_AAAA
1392       #ifdef SUPPORT_A6
1393         && rr->type != T_A6
1394       #endif
1395     #endif
1396   ) continue;
1397
1398   if (strcmpic(target, rr->name) != 0) continue;
1399
1400   target_found = TRUE;
1401
1402   /* Turn the target address RR into a list of textual IP addresses and scan
1403   the list. There may be more than one if it is an A6 RR. */
1404
1405   for (da = dns_address_from_rr(dnsa, rr); da != NULL; da = da->next)
1406     {
1407     /* If the client IP address matches the target IP address, it's good! */
1408
1409     DEBUG(D_acl) debug_printf("CSA target address is %s\n", da->address);
1410
1411     if (strcmpic(sender_host_address, da->address) == 0) return CSA_OK;
1412     }
1413   }
1414
1415 /* If we found some target addresses but none of them matched, the client is
1416 using an unauthorized IP address, otherwise the target has no authorized IP
1417 addresses. */
1418
1419 if (target_found) return CSA_FAIL_MISMATCH;
1420 else return CSA_FAIL_NOADDR;
1421 }
1422
1423
1424
1425 /*************************************************
1426 *       Verify Client SMTP Authorization         *
1427 *************************************************/
1428
1429 /* Called from acl_verify() below. This routine calls dns_lookup_special()
1430 to find the CSA SRV record corresponding to the domain argument, or
1431 $sender_helo_name if no argument is provided. It then checks that the
1432 client is authorized, and that its IP address corresponds to the SRV
1433 target's address by calling acl_verify_csa_address() above. The address
1434 should have been returned in the DNS response's ADDITIONAL section, but if
1435 not we perform another DNS lookup to get it.
1436
1437 Arguments:
1438   domain    pointer to optional parameter following verify = csa
1439
1440 Returns:    CSA_UNKNOWN    no valid CSA record found
1441             CSA_OK         successfully authorized
1442             CSA_FAIL_*     client is definitely not authorized
1443             CSA_DEFER_*    there was a DNS problem
1444 */
1445
1446 static int
1447 acl_verify_csa(uschar *domain)
1448 {
1449 tree_node *t;
1450 uschar *found, *p;
1451 int priority, weight, port;
1452 dns_answer dnsa;
1453 dns_scan dnss;
1454 dns_record *rr;
1455 int rc, type;
1456 uschar target[256];
1457
1458 /* Work out the domain we are using for the CSA lookup. The default is the
1459 client's HELO domain. If the client has not said HELO, use its IP address
1460 instead. If it's a local client (exim -bs), CSA isn't applicable. */
1461
1462 while (isspace(*domain) && *domain != '\0') ++domain;
1463 if (*domain == '\0') domain = sender_helo_name;
1464 if (domain == NULL) domain = sender_host_address;
1465 if (sender_host_address == NULL) return CSA_UNKNOWN;
1466
1467 /* If we have an address literal, strip off the framing ready for turning it
1468 into a domain. The framing consists of matched square brackets possibly
1469 containing a keyword and a colon before the actual IP address. */
1470
1471 if (domain[0] == '[')
1472   {
1473   uschar *start = Ustrchr(domain, ':');
1474   if (start == NULL) start = domain;
1475   domain = string_copyn(start + 1, Ustrlen(start) - 2);
1476   }
1477
1478 /* Turn domains that look like bare IP addresses into domains in the reverse
1479 DNS. This code also deals with address literals and $sender_host_address. It's
1480 not quite kosher to treat bare domains such as EHLO 192.0.2.57 the same as
1481 address literals, but it's probably the most friendly thing to do. This is an
1482 extension to CSA, so we allow it to be turned off for proper conformance. */
1483
1484 if (string_is_ip_address(domain, NULL) != 0)
1485   {
1486   if (!dns_csa_use_reverse) return CSA_UNKNOWN;
1487   dns_build_reverse(domain, target);
1488   domain = target;
1489   }
1490
1491 /* Find out if we've already done the CSA check for this domain. If we have,
1492 return the same result again. Otherwise build a new cached result structure
1493 for this domain. The name is filled in now, and the value is filled in when
1494 we return from this function. */
1495
1496 t = tree_search(csa_cache, domain);
1497 if (t != NULL) return t->data.val;
1498
1499 t = store_get_perm(sizeof(tree_node) + Ustrlen(domain));
1500 Ustrcpy(t->name, domain);
1501 (void)tree_insertnode(&csa_cache, t);
1502
1503 /* Now we are ready to do the actual DNS lookup(s). */
1504
1505 found = domain;
1506 switch (dns_special_lookup(&dnsa, domain, T_CSA, &found))
1507   {
1508   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1509
1510   default:
1511   return t->data.val = CSA_DEFER_SRV;
1512
1513   /* If we found nothing, the client's authorization is unknown. */
1514
1515   case DNS_NOMATCH:
1516   case DNS_NODATA:
1517   return t->data.val = CSA_UNKNOWN;
1518
1519   /* We got something! Go on to look at the reply in more detail. */
1520
1521   case DNS_SUCCEED:
1522   break;
1523   }
1524
1525 /* Scan the reply for well-formed CSA SRV records. */
1526
1527 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1528      rr != NULL;
1529      rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1530   {
1531   if (rr->type != T_SRV) continue;
1532
1533   /* Extract the numerical SRV fields (p is incremented) */
1534
1535   p = rr->data;
1536   GETSHORT(priority, p);
1537   GETSHORT(weight, p);
1538   GETSHORT(port, p);
1539
1540   DEBUG(D_acl)
1541     debug_printf("CSA priority=%d weight=%d port=%d\n", priority, weight, port);
1542
1543   /* Check the CSA version number */
1544
1545   if (priority != 1) continue;
1546
1547   /* If the domain does not have a CSA SRV record of its own (i.e. the domain
1548   found by dns_special_lookup() is a parent of the one we asked for), we check
1549   the subdomain assertions in the port field. At the moment there's only one
1550   assertion: legitimate SMTP clients are all explicitly authorized with CSA
1551   SRV records of their own. */
1552
1553   if (found != domain)
1554     {
1555     if (port & 1)
1556       return t->data.val = CSA_FAIL_EXPLICIT;
1557     else
1558       return t->data.val = CSA_UNKNOWN;
1559     }
1560
1561   /* This CSA SRV record refers directly to our domain, so we check the value
1562   in the weight field to work out the domain's authorization. 0 and 1 are
1563   unauthorized; 3 means the client is authorized but we can't check the IP
1564   address in order to authenticate it, so we treat it as unknown; values
1565   greater than 3 are undefined. */
1566
1567   if (weight < 2) return t->data.val = CSA_FAIL_DOMAIN;
1568
1569   if (weight > 2) continue;
1570
1571   /* Weight == 2, which means the domain is authorized. We must check that the
1572   client's IP address is listed as one of the SRV target addresses. Save the
1573   target hostname then break to scan the additional data for its addresses. */
1574
1575   (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, p,
1576     (DN_EXPAND_ARG4_TYPE)target, sizeof(target));
1577
1578   DEBUG(D_acl) debug_printf("CSA target is %s\n", target);
1579
1580   break;
1581   }
1582
1583 /* If we didn't break the loop then no appropriate records were found. */
1584
1585 if (rr == NULL) return t->data.val = CSA_UNKNOWN;
1586
1587 /* Do not check addresses if the target is ".", in accordance with RFC 2782.
1588 A target of "." indicates there are no valid addresses, so the client cannot
1589 be authorized. (This is an odd configuration because weight=2 target=. is
1590 equivalent to weight=1, but we check for it in order to keep load off the
1591 root name servers.) Note that dn_expand() turns "." into "". */
1592
1593 if (Ustrcmp(target, "") == 0) return t->data.val = CSA_FAIL_NOADDR;
1594
1595 /* Scan the additional section of the CSA SRV reply for addresses belonging
1596 to the target. If the name server didn't return any additional data (e.g.
1597 because it does not fully support SRV records), we need to do another lookup
1598 to obtain the target addresses; otherwise we have a definitive result. */
1599
1600 rc = acl_verify_csa_address(&dnsa, &dnss, RESET_ADDITIONAL, target);
1601 if (rc != CSA_FAIL_NOADDR) return t->data.val = rc;
1602
1603 /* The DNS lookup type corresponds to the IP version used by the client. */
1604
1605 #if HAVE_IPV6
1606 if (Ustrchr(sender_host_address, ':') != NULL)
1607   type = T_AAAA;
1608 else
1609 #endif /* HAVE_IPV6 */
1610   type = T_A;
1611
1612
1613 #if HAVE_IPV6 && defined(SUPPORT_A6)
1614 DNS_LOOKUP_AGAIN:
1615 #endif
1616
1617 switch (dns_lookup(&dnsa, target, type, NULL))
1618   {
1619   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1620
1621   default:
1622   return t->data.val = CSA_DEFER_ADDR;
1623
1624   /* If the query succeeded, scan the addresses and return the result. */
1625
1626   case DNS_SUCCEED:
1627   rc = acl_verify_csa_address(&dnsa, &dnss, RESET_ANSWERS, target);
1628   if (rc != CSA_FAIL_NOADDR) return t->data.val = rc;
1629   /* else fall through */
1630
1631   /* If the target has no IP addresses, the client cannot have an authorized
1632   IP address. However, if the target site uses A6 records (not AAAA records)
1633   we have to do yet another lookup in order to check them. */
1634
1635   case DNS_NOMATCH:
1636   case DNS_NODATA:
1637
1638   #if HAVE_IPV6 && defined(SUPPORT_A6)
1639   if (type == T_AAAA) { type = T_A6; goto DNS_LOOKUP_AGAIN; }
1640   #endif
1641
1642   return t->data.val = CSA_FAIL_NOADDR;
1643   }
1644 }
1645
1646
1647
1648 /*************************************************
1649 *     Handle verification (address & other)      *
1650 *************************************************/
1651
1652 enum { VERIFY_REV_HOST_LKUP, VERIFY_CERT, VERIFY_HELO, VERIFY_CSA, VERIFY_HDR_SYNTAX,
1653   VERIFY_NOT_BLIND, VERIFY_HDR_SNDR, VERIFY_SNDR, VERIFY_RCPT
1654   };
1655 typedef struct {
1656   uschar * name;
1657   int      value;
1658   unsigned where_allowed;       /* bitmap */
1659   BOOL     no_options;          /* Never has /option(s) following */
1660   unsigned alt_opt_sep;         /* >0 Non-/ option separator (custom parser) */
1661   } verify_type_t;
1662 static verify_type_t verify_type_list[] = {
1663     { US"reverse_host_lookup",  VERIFY_REV_HOST_LKUP,   ~0,     TRUE, 0 },
1664     { US"certificate",          VERIFY_CERT,            ~0,     TRUE, 0 },
1665     { US"helo",                 VERIFY_HELO,            ~0,     TRUE, 0 },
1666     { US"csa",                  VERIFY_CSA,             ~0,     FALSE, 0 },
1667     { US"header_syntax",        VERIFY_HDR_SYNTAX,      (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP), TRUE, 0 },
1668     { US"not_blind",            VERIFY_NOT_BLIND,       (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP), TRUE, 0 },
1669     { US"header_sender",        VERIFY_HDR_SNDR,        (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP), FALSE, 0 },
1670     { US"sender",               VERIFY_SNDR,            (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)
1671                         |(1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP),
1672                                                                                 FALSE, 6 },
1673     { US"recipient",            VERIFY_RCPT,            (1<<ACL_WHERE_RCPT),    FALSE, 0 }
1674   };
1675
1676
1677 enum { CALLOUT_DEFER_OK, CALLOUT_NOCACHE, CALLOUT_RANDOM, CALLOUT_USE_SENDER,
1678   CALLOUT_USE_POSTMASTER, CALLOUT_POSTMASTER, CALLOUT_FULLPOSTMASTER,
1679   CALLOUT_MAILFROM, CALLOUT_POSTMASTER_MAILFROM, CALLOUT_MAXWAIT, CALLOUT_CONNECT,
1680   CALLOUT_TIME
1681   };
1682 typedef struct {
1683   uschar * name;
1684   int      value;
1685   int      flag;
1686   BOOL     has_option;  /* Has =option(s) following */
1687   BOOL     timeval;     /* Has a time value */
1688   } callout_opt_t;
1689 static callout_opt_t callout_opt_list[] = {
1690     { US"defer_ok",       CALLOUT_DEFER_OK,      0,                             FALSE, FALSE },
1691     { US"no_cache",       CALLOUT_NOCACHE,       vopt_callout_no_cache,         FALSE, FALSE },
1692     { US"random",         CALLOUT_RANDOM,        vopt_callout_random,           FALSE, FALSE },
1693     { US"use_sender",     CALLOUT_USE_SENDER,    vopt_callout_recipsender,      FALSE, FALSE },
1694     { US"use_postmaster", CALLOUT_USE_POSTMASTER,vopt_callout_recippmaster,     FALSE, FALSE },
1695     { US"postmaster_mailfrom",CALLOUT_POSTMASTER_MAILFROM,0,                    TRUE,  FALSE },
1696     { US"postmaster",     CALLOUT_POSTMASTER,    0,                             FALSE, FALSE },
1697     { US"fullpostmaster", CALLOUT_FULLPOSTMASTER,vopt_callout_fullpm,           FALSE, FALSE },
1698     { US"mailfrom",       CALLOUT_MAILFROM,      0,                             TRUE,  FALSE },
1699     { US"maxwait",        CALLOUT_MAXWAIT,       0,                             TRUE,  TRUE },
1700     { US"connect",        CALLOUT_CONNECT,       0,                             TRUE,  TRUE },
1701     { NULL,               CALLOUT_TIME,          0,                             FALSE, TRUE }
1702   };
1703
1704
1705
1706 /* This function implements the "verify" condition. It is called when
1707 encountered in any ACL, because some tests are almost always permitted. Some
1708 just don't make sense, and always fail (for example, an attempt to test a host
1709 lookup for a non-TCP/IP message). Others are restricted to certain ACLs.
1710
1711 Arguments:
1712   where        where called from
1713   addr         the recipient address that the ACL is handling, or NULL
1714   arg          the argument of "verify"
1715   user_msgptr  pointer for user message
1716   log_msgptr   pointer for log message
1717   basic_errno  where to put verify errno
1718
1719 Returns:       OK        verification condition succeeded
1720                FAIL      verification failed
1721                DEFER     there was a problem verifying
1722                ERROR     syntax error
1723 */
1724
1725 static int
1726 acl_verify(int where, address_item *addr, uschar *arg,
1727   uschar **user_msgptr, uschar **log_msgptr, int *basic_errno)
1728 {
1729 int sep = '/';
1730 int callout = -1;
1731 int callout_overall = -1;
1732 int callout_connect = -1;
1733 int verify_options = 0;
1734 int rc;
1735 BOOL verify_header_sender = FALSE;
1736 BOOL defer_ok = FALSE;
1737 BOOL callout_defer_ok = FALSE;
1738 BOOL no_details = FALSE;
1739 BOOL success_on_redirect = FALSE;
1740 address_item *sender_vaddr = NULL;
1741 uschar *verify_sender_address = NULL;
1742 uschar *pm_mailfrom = NULL;
1743 uschar *se_mailfrom = NULL;
1744
1745 /* Some of the verify items have slash-separated options; some do not. Diagnose
1746 an error if options are given for items that don't expect them.
1747 */
1748
1749 uschar *slash = Ustrchr(arg, '/');
1750 uschar *list = arg;
1751 uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
1752 verify_type_t * vp;
1753
1754 if (ss == NULL) goto BAD_VERIFY;
1755
1756 /* Handle name/address consistency verification in a separate function. */
1757
1758 for (vp= verify_type_list;
1759      (char *)vp < (char *)verify_type_list + sizeof(verify_type_list);
1760      vp++
1761     )
1762   if (vp->alt_opt_sep ? strncmpic(ss, vp->name, vp->alt_opt_sep) == 0
1763                       : strcmpic (ss, vp->name) == 0)
1764    break;
1765 if ((char *)vp >= (char *)verify_type_list + sizeof(verify_type_list))
1766   goto BAD_VERIFY;
1767
1768 if (vp->no_options && slash != NULL)
1769   {
1770   *log_msgptr = string_sprintf("unexpected '/' found in \"%s\" "
1771     "(this verify item has no options)", arg);
1772   return ERROR;
1773   }
1774 if (!(vp->where_allowed & (1<<where)))
1775   {
1776   *log_msgptr = string_sprintf("cannot verify %s in ACL for %s", vp->name, acl_wherenames[where]);
1777   return ERROR;
1778   }
1779 switch(vp->value)
1780   {
1781   case VERIFY_REV_HOST_LKUP:
1782     if (sender_host_address == NULL) return OK;
1783     return acl_verify_reverse(user_msgptr, log_msgptr);
1784
1785   case VERIFY_CERT:
1786     /* TLS certificate verification is done at STARTTLS time; here we just
1787     test whether it was successful or not. (This is for optional verification; for
1788     mandatory verification, the connection doesn't last this long.) */
1789
1790       if (tls_in.certificate_verified) return OK;
1791       *user_msgptr = US"no verified certificate";
1792       return FAIL;
1793
1794   case VERIFY_HELO:
1795     /* We can test the result of optional HELO verification that might have
1796     occurred earlier. If not, we can attempt the verification now. */
1797
1798       if (!helo_verified && !helo_verify_failed) smtp_verify_helo();
1799       return helo_verified? OK : FAIL;
1800
1801   case VERIFY_CSA:
1802     /* Do Client SMTP Authorization checks in a separate function, and turn the
1803     result code into user-friendly strings. */
1804
1805       rc = acl_verify_csa(list);
1806       *log_msgptr = *user_msgptr = string_sprintf("client SMTP authorization %s",
1807                                               csa_reason_string[rc]);
1808       csa_status = csa_status_string[rc];
1809       DEBUG(D_acl) debug_printf("CSA result %s\n", csa_status);
1810       return csa_return_code[rc];
1811
1812   case VERIFY_HDR_SYNTAX:
1813     /* Check that all relevant header lines have the correct syntax. If there is
1814     a syntax error, we return details of the error to the sender if configured to
1815     send out full details. (But a "message" setting on the ACL can override, as
1816     always). */
1817
1818     rc = verify_check_headers(log_msgptr);
1819     if (rc != OK && smtp_return_error_details && *log_msgptr != NULL)
1820       *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1821     return rc;
1822
1823   case VERIFY_NOT_BLIND:
1824     /* Check that no recipient of this message is "blind", that is, every envelope
1825     recipient must be mentioned in either To: or Cc:. */
1826
1827     rc = verify_check_notblind();
1828     if (rc != OK)
1829       {
1830       *log_msgptr = string_sprintf("bcc recipient detected");
1831       if (smtp_return_error_details)
1832         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1833       }
1834     return rc;
1835
1836   /* The remaining verification tests check recipient and sender addresses,
1837   either from the envelope or from the header. There are a number of
1838   slash-separated options that are common to all of them. */
1839
1840   case VERIFY_HDR_SNDR:
1841     verify_header_sender = TRUE;
1842     break;
1843
1844   case VERIFY_SNDR:
1845     /* In the case of a sender, this can optionally be followed by an address to use
1846     in place of the actual sender (rare special-case requirement). */
1847     {
1848     uschar *s = ss + 6;
1849     if (*s == 0)
1850       verify_sender_address = sender_address;
1851     else
1852       {
1853       while (isspace(*s)) s++;
1854       if (*s++ != '=') goto BAD_VERIFY;
1855       while (isspace(*s)) s++;
1856       verify_sender_address = string_copy(s);
1857       }
1858     }
1859     break;
1860
1861   case VERIFY_RCPT:
1862     break;
1863   }
1864
1865
1866
1867 /* Remaining items are optional; they apply to sender and recipient
1868 verification, including "header sender" verification. */
1869
1870 while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
1871       != NULL)
1872   {
1873   if (strcmpic(ss, US"defer_ok") == 0) defer_ok = TRUE;
1874   else if (strcmpic(ss, US"no_details") == 0) no_details = TRUE;
1875   else if (strcmpic(ss, US"success_on_redirect") == 0) success_on_redirect = TRUE;
1876
1877   /* These two old options are left for backwards compatibility */
1878
1879   else if (strcmpic(ss, US"callout_defer_ok") == 0)
1880     {
1881     callout_defer_ok = TRUE;
1882     if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1883     }
1884
1885   else if (strcmpic(ss, US"check_postmaster") == 0)
1886      {
1887      pm_mailfrom = US"";
1888      if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1889      }
1890
1891   /* The callout option has a number of sub-options, comma separated */
1892
1893   else if (strncmpic(ss, US"callout", 7) == 0)
1894     {
1895     callout = CALLOUT_TIMEOUT_DEFAULT;
1896     ss += 7;
1897     if (*ss != 0)
1898       {
1899       while (isspace(*ss)) ss++;
1900       if (*ss++ == '=')
1901         {
1902         int optsep = ',';
1903         uschar *opt;
1904         uschar buffer[256];
1905         while (isspace(*ss)) ss++;
1906
1907         while ((opt = string_nextinlist(&ss, &optsep, buffer, sizeof(buffer)))
1908               != NULL)
1909           {
1910           callout_opt_t * op;
1911           double period = 1.0F;
1912
1913           for (op= callout_opt_list; op->name; op++)
1914             if (strncmpic(opt, op->name, Ustrlen(op->name)) == 0)
1915               break;
1916
1917           verify_options |= op->flag;
1918           if (op->has_option)
1919             {
1920             opt += Ustrlen(op->name);
1921             while (isspace(*opt)) opt++;
1922             if (*opt++ != '=')
1923               {
1924               *log_msgptr = string_sprintf("'=' expected after "
1925                 "\"%s\" in ACL verify condition \"%s\"", op->name, arg);
1926               return ERROR;
1927               }
1928             while (isspace(*opt)) opt++;
1929             }
1930           if (op->timeval)
1931             {
1932             period = readconf_readtime(opt, 0, FALSE);
1933             if (period < 0)
1934               {
1935               *log_msgptr = string_sprintf("bad time value in ACL condition "
1936                 "\"verify %s\"", arg);
1937               return ERROR;
1938               }
1939             }
1940
1941           switch(op->value)
1942             {
1943             case CALLOUT_DEFER_OK:              callout_defer_ok = TRUE; break;
1944             case CALLOUT_POSTMASTER:            pm_mailfrom = US"";     break;
1945             case CALLOUT_FULLPOSTMASTER:        pm_mailfrom = US"";     break;
1946             case CALLOUT_MAILFROM:
1947               if (!verify_header_sender)
1948                 {
1949                 *log_msgptr = string_sprintf("\"mailfrom\" is allowed as a "
1950                   "callout option only for verify=header_sender (detected in ACL "
1951                   "condition \"%s\")", arg);
1952                 return ERROR;
1953                 }
1954               se_mailfrom = string_copy(opt);
1955               break;
1956             case CALLOUT_POSTMASTER_MAILFROM:   pm_mailfrom = string_copy(opt); break;
1957             case CALLOUT_MAXWAIT:               callout_overall = period;       break;
1958             case CALLOUT_CONNECT:               callout_connect = period;       break;
1959             case CALLOUT_TIME:                  callout = period;               break;
1960             }
1961           }
1962         }
1963       else
1964         {
1965         *log_msgptr = string_sprintf("'=' expected after \"callout\" in "
1966           "ACL condition \"%s\"", arg);
1967         return ERROR;
1968         }
1969       }
1970     }
1971
1972   /* Option not recognized */
1973
1974   else
1975     {
1976     *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
1977       "condition \"verify %s\"", ss, arg);
1978     return ERROR;
1979     }
1980   }
1981
1982 if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)) ==
1983       (vopt_callout_recipsender|vopt_callout_recippmaster))
1984   {
1985   *log_msgptr = US"only one of use_sender and use_postmaster can be set "
1986     "for a recipient callout";
1987   return ERROR;
1988   }
1989
1990 /* Handle sender-in-header verification. Default the user message to the log
1991 message if giving out verification details. */
1992
1993 if (verify_header_sender)
1994   {
1995   int verrno;
1996   rc = verify_check_header_address(user_msgptr, log_msgptr, callout,
1997     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, verify_options,
1998     &verrno);
1999   if (rc != OK)
2000     {
2001     *basic_errno = verrno;
2002     if (smtp_return_error_details)
2003       {
2004       if (*user_msgptr == NULL && *log_msgptr != NULL)
2005         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
2006       if (rc == DEFER) acl_temp_details = TRUE;
2007       }
2008     }
2009   }
2010
2011 /* Handle a sender address. The default is to verify *the* sender address, but
2012 optionally a different address can be given, for special requirements. If the
2013 address is empty, we are dealing with a bounce message that has no sender, so
2014 we cannot do any checking. If the real sender address gets rewritten during
2015 verification (e.g. DNS widening), set the flag to stop it being rewritten again
2016 during message reception.
2017
2018 A list of verified "sender" addresses is kept to try to avoid doing to much
2019 work repetitively when there are multiple recipients in a message and they all
2020 require sender verification. However, when callouts are involved, it gets too
2021 complicated because different recipients may require different callout options.
2022 Therefore, we always do a full sender verify when any kind of callout is
2023 specified. Caching elsewhere, for instance in the DNS resolver and in the
2024 callout handling, should ensure that this is not terribly inefficient. */
2025
2026 else if (verify_sender_address != NULL)
2027   {
2028   if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster))
2029        != 0)
2030     {
2031     *log_msgptr = US"use_sender or use_postmaster cannot be used for a "
2032       "sender verify callout";
2033     return ERROR;
2034     }
2035
2036   sender_vaddr = verify_checked_sender(verify_sender_address);
2037   if (sender_vaddr != NULL &&               /* Previously checked */
2038       callout <= 0)                         /* No callout needed this time */
2039     {
2040     /* If the "routed" flag is set, it means that routing worked before, so
2041     this check can give OK (the saved return code value, if set, belongs to a
2042     callout that was done previously). If the "routed" flag is not set, routing
2043     must have failed, so we use the saved return code. */
2044
2045     if (testflag(sender_vaddr, af_verify_routed)) rc = OK; else
2046       {
2047       rc = sender_vaddr->special_action;
2048       *basic_errno = sender_vaddr->basic_errno;
2049       }
2050     HDEBUG(D_acl) debug_printf("using cached sender verify result\n");
2051     }
2052
2053   /* Do a new verification, and cache the result. The cache is used to avoid
2054   verifying the sender multiple times for multiple RCPTs when callouts are not
2055   specified (see comments above).
2056
2057   The cache is also used on failure to give details in response to the first
2058   RCPT that gets bounced for this reason. However, this can be suppressed by
2059   the no_details option, which sets the flag that says "this detail has already
2060   been sent". The cache normally contains just one address, but there may be
2061   more in esoteric circumstances. */
2062
2063   else
2064     {
2065     BOOL routed = TRUE;
2066     uschar *save_address_data = deliver_address_data;
2067
2068     sender_vaddr = deliver_make_addr(verify_sender_address, TRUE);
2069     if (no_details) setflag(sender_vaddr, af_sverify_told);
2070     if (verify_sender_address[0] != 0)
2071       {
2072       /* If this is the real sender address, save the unrewritten version
2073       for use later in receive. Otherwise, set a flag so that rewriting the
2074       sender in verify_address() does not update sender_address. */
2075
2076       if (verify_sender_address == sender_address)
2077         sender_address_unrewritten = sender_address;
2078       else
2079         verify_options |= vopt_fake_sender;
2080
2081       if (success_on_redirect)
2082         verify_options |= vopt_success_on_redirect;
2083
2084       /* The recipient, qualify, and expn options are never set in
2085       verify_options. */
2086
2087       rc = verify_address(sender_vaddr, NULL, verify_options, callout,
2088         callout_overall, callout_connect, se_mailfrom, pm_mailfrom, &routed);
2089
2090       HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
2091
2092       if (rc == OK)
2093         {
2094         if (Ustrcmp(sender_vaddr->address, verify_sender_address) != 0)
2095           {
2096           DEBUG(D_acl) debug_printf("sender %s verified ok as %s\n",
2097             verify_sender_address, sender_vaddr->address);
2098           }
2099         else
2100           {
2101           DEBUG(D_acl) debug_printf("sender %s verified ok\n",
2102             verify_sender_address);
2103           }
2104         }
2105       else *basic_errno = sender_vaddr->basic_errno;
2106       }
2107     else rc = OK;  /* Null sender */
2108
2109     /* Cache the result code */
2110
2111     if (routed) setflag(sender_vaddr, af_verify_routed);
2112     if (callout > 0) setflag(sender_vaddr, af_verify_callout);
2113     sender_vaddr->special_action = rc;
2114     sender_vaddr->next = sender_verified_list;
2115     sender_verified_list = sender_vaddr;
2116
2117     /* Restore the recipient address data, which might have been clobbered by
2118     the sender verification. */
2119
2120     deliver_address_data = save_address_data;
2121     }
2122
2123   /* Put the sender address_data value into $sender_address_data */
2124
2125   sender_address_data = sender_vaddr->p.address_data;
2126   }
2127
2128 /* A recipient address just gets a straightforward verify; again we must handle
2129 the DEFER overrides. */
2130
2131 else
2132   {
2133   address_item addr2;
2134
2135   if (success_on_redirect)
2136     verify_options |= vopt_success_on_redirect;
2137
2138   /* We must use a copy of the address for verification, because it might
2139   get rewritten. */
2140
2141   addr2 = *addr;
2142   rc = verify_address(&addr2, NULL, verify_options|vopt_is_recipient, callout,
2143     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, NULL);
2144   HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
2145
2146   *basic_errno = addr2.basic_errno;
2147   *log_msgptr = addr2.message;
2148   *user_msgptr = (addr2.user_message != NULL)?
2149     addr2.user_message : addr2.message;
2150
2151   /* Allow details for temporary error if the address is so flagged. */
2152   if (testflag((&addr2), af_pass_message)) acl_temp_details = TRUE;
2153
2154   /* Make $address_data visible */
2155   deliver_address_data = addr2.p.address_data;
2156   }
2157
2158 /* We have a result from the relevant test. Handle defer overrides first. */
2159
2160 if (rc == DEFER && (defer_ok ||
2161    (callout_defer_ok && *basic_errno == ERRNO_CALLOUTDEFER)))
2162   {
2163   HDEBUG(D_acl) debug_printf("verify defer overridden by %s\n",
2164     defer_ok? "defer_ok" : "callout_defer_ok");
2165   rc = OK;
2166   }
2167
2168 /* If we've failed a sender, set up a recipient message, and point
2169 sender_verified_failed to the address item that actually failed. */
2170
2171 if (rc != OK && verify_sender_address != NULL)
2172   {
2173   if (rc != DEFER)
2174     {
2175     *log_msgptr = *user_msgptr = US"Sender verify failed";
2176     }
2177   else if (*basic_errno != ERRNO_CALLOUTDEFER)
2178     {
2179     *log_msgptr = *user_msgptr = US"Could not complete sender verify";
2180     }
2181   else
2182     {
2183     *log_msgptr = US"Could not complete sender verify callout";
2184     *user_msgptr = smtp_return_error_details? sender_vaddr->user_message :
2185       *log_msgptr;
2186     }
2187
2188   sender_verified_failed = sender_vaddr;
2189   }
2190
2191 /* Verifying an address messes up the values of $domain and $local_part,
2192 so reset them before returning if this is a RCPT ACL. */
2193
2194 if (addr != NULL)
2195   {
2196   deliver_domain = addr->domain;
2197   deliver_localpart = addr->local_part;
2198   }
2199 return rc;
2200
2201 /* Syntax errors in the verify argument come here. */
2202
2203 BAD_VERIFY:
2204 *log_msgptr = string_sprintf("expected \"sender[=address]\", \"recipient\", "
2205   "\"helo\", \"header_syntax\", \"header_sender\" or "
2206   "\"reverse_host_lookup\" at start of ACL condition "
2207   "\"verify %s\"", arg);
2208 return ERROR;
2209 }
2210
2211
2212
2213
2214 /*************************************************
2215 *        Check argument for control= modifier    *
2216 *************************************************/
2217
2218 /* Called from acl_check_condition() below
2219
2220 Arguments:
2221   arg         the argument string for control=
2222   pptr        set to point to the terminating character
2223   where       which ACL we are in
2224   log_msgptr  for error messages
2225
2226 Returns:      CONTROL_xxx value
2227 */
2228
2229 static int
2230 decode_control(uschar *arg, uschar **pptr, int where, uschar **log_msgptr)
2231 {
2232 int len;
2233 control_def *d;
2234
2235 for (d = controls_list;
2236      d < controls_list + sizeof(controls_list)/sizeof(control_def);
2237      d++)
2238   {
2239   len = Ustrlen(d->name);
2240   if (Ustrncmp(d->name, arg, len) == 0) break;
2241   }
2242
2243 if (d >= controls_list + sizeof(controls_list)/sizeof(control_def) ||
2244    (arg[len] != 0 && (!d->has_option || arg[len] != '/')))
2245   {
2246   *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
2247   return CONTROL_ERROR;
2248   }
2249
2250 *pptr = arg + len;
2251 return d->value;
2252 }
2253
2254
2255
2256
2257 /*************************************************
2258 *        Return a ratelimit error                *
2259 *************************************************/
2260
2261 /* Called from acl_ratelimit() below
2262
2263 Arguments:
2264   log_msgptr  for error messages
2265   format      format string
2266   ...         supplementary arguments
2267   ss          ratelimit option name
2268   where       ACL_WHERE_xxxx indicating which ACL this is
2269
2270 Returns:      ERROR
2271 */
2272
2273 static int
2274 ratelimit_error(uschar **log_msgptr, const char *format, ...)
2275 {
2276 va_list ap;
2277 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
2278 va_start(ap, format);
2279 if (!string_vformat(buffer, sizeof(buffer), format, ap))
2280   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
2281     "string_sprintf expansion was longer than " SIZE_T_FMT, sizeof(buffer));
2282 va_end(ap);
2283 *log_msgptr = string_sprintf(
2284   "error in arguments to \"ratelimit\" condition: %s", buffer);
2285 return ERROR;
2286 }
2287
2288
2289
2290
2291 /*************************************************
2292 *            Handle rate limiting                *
2293 *************************************************/
2294
2295 /* Called by acl_check_condition() below to calculate the result
2296 of the ACL ratelimit condition.
2297
2298 Note that the return value might be slightly unexpected: if the
2299 sender's rate is above the limit then the result is OK. This is
2300 similar to the dnslists condition, and is so that you can write
2301 ACL clauses like: defer ratelimit = 15 / 1h
2302
2303 Arguments:
2304   arg         the option string for ratelimit=
2305   where       ACL_WHERE_xxxx indicating which ACL this is
2306   log_msgptr  for error messages
2307
2308 Returns:       OK        - Sender's rate is above limit
2309                FAIL      - Sender's rate is below limit
2310                DEFER     - Problem opening ratelimit database
2311                ERROR     - Syntax error in options.
2312 */
2313
2314 static int
2315 acl_ratelimit(uschar *arg, int where, uschar **log_msgptr)
2316 {
2317 double limit, period, count;
2318 uschar *ss;
2319 uschar *key = NULL;
2320 uschar *unique = NULL;
2321 int sep = '/';
2322 BOOL leaky = FALSE, strict = FALSE, readonly = FALSE;
2323 BOOL noupdate = FALSE, badacl = FALSE;
2324 int mode = RATE_PER_WHAT;
2325 int old_pool, rc;
2326 tree_node **anchor, *t;
2327 open_db dbblock, *dbm;
2328 int dbdb_size;
2329 dbdata_ratelimit *dbd;
2330 dbdata_ratelimit_unique *dbdb;
2331 struct timeval tv;
2332
2333 /* Parse the first two options and record their values in expansion
2334 variables. These variables allow the configuration to have informative
2335 error messages based on rate limits obtained from a table lookup. */
2336
2337 /* First is the maximum number of messages per period / maximum burst
2338 size, which must be greater than or equal to zero. Zero is useful for
2339 rate measurement as opposed to rate limiting. */
2340
2341 sender_rate_limit = string_nextinlist(&arg, &sep, NULL, 0);
2342 if (sender_rate_limit == NULL)
2343   limit = -1.0;
2344 else
2345   {
2346   limit = Ustrtod(sender_rate_limit, &ss);
2347   if (tolower(*ss) == 'k') { limit *= 1024.0; ss++; }
2348   else if (tolower(*ss) == 'm') { limit *= 1024.0*1024.0; ss++; }
2349   else if (tolower(*ss) == 'g') { limit *= 1024.0*1024.0*1024.0; ss++; }
2350   }
2351 if (limit < 0.0 || *ss != '\0')
2352   return ratelimit_error(log_msgptr,
2353     "\"%s\" is not a positive number", sender_rate_limit);
2354
2355 /* Second is the rate measurement period / exponential smoothing time
2356 constant. This must be strictly greater than zero, because zero leads to
2357 run-time division errors. */
2358
2359 sender_rate_period = string_nextinlist(&arg, &sep, NULL, 0);
2360 if (sender_rate_period == NULL) period = -1.0;
2361 else period = readconf_readtime(sender_rate_period, 0, FALSE);
2362 if (period <= 0.0)
2363   return ratelimit_error(log_msgptr,
2364     "\"%s\" is not a time value", sender_rate_period);
2365
2366 /* By default we are counting one of something, but the per_rcpt,
2367 per_byte, and count options can change this. */
2368
2369 count = 1.0;
2370
2371 /* Parse the other options. */
2372
2373 while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
2374        != NULL)
2375   {
2376   if (strcmpic(ss, US"leaky") == 0) leaky = TRUE;
2377   else if (strcmpic(ss, US"strict") == 0) strict = TRUE;
2378   else if (strcmpic(ss, US"noupdate") == 0) noupdate = TRUE;
2379   else if (strcmpic(ss, US"readonly") == 0) readonly = TRUE;
2380   else if (strcmpic(ss, US"per_cmd") == 0) RATE_SET(mode, PER_CMD);
2381   else if (strcmpic(ss, US"per_conn") == 0)
2382     {
2383     RATE_SET(mode, PER_CONN);
2384     if (where == ACL_WHERE_NOTSMTP || where == ACL_WHERE_NOTSMTP_START)
2385       badacl = TRUE;
2386     }
2387   else if (strcmpic(ss, US"per_mail") == 0)
2388     {
2389     RATE_SET(mode, PER_MAIL);
2390     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2391     }
2392   else if (strcmpic(ss, US"per_rcpt") == 0)
2393     {
2394     /* If we are running in the RCPT ACL, then we'll count the recipients
2395     one by one, but if we are running when we have accumulated the whole
2396     list then we'll add them all in one batch. */
2397     if (where == ACL_WHERE_RCPT)
2398       RATE_SET(mode, PER_RCPT);
2399     else if (where >= ACL_WHERE_PREDATA && where <= ACL_WHERE_NOTSMTP)
2400       RATE_SET(mode, PER_ALLRCPTS), count = (double)recipients_count;
2401     else if (where == ACL_WHERE_MAIL || where > ACL_WHERE_NOTSMTP)
2402       RATE_SET(mode, PER_RCPT), badacl = TRUE;
2403     }
2404   else if (strcmpic(ss, US"per_byte") == 0)
2405     {
2406     /* If we have not yet received the message data and there was no SIZE
2407     declaration on the MAIL comand, then it's safe to just use a value of
2408     zero and let the recorded rate decay as if nothing happened. */
2409     RATE_SET(mode, PER_MAIL);
2410     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2411       else count = message_size < 0 ? 0.0 : (double)message_size;
2412     }
2413   else if (strcmpic(ss, US"per_addr") == 0)
2414     {
2415     RATE_SET(mode, PER_RCPT);
2416     if (where != ACL_WHERE_RCPT) badacl = TRUE, unique = US"*";
2417       else unique = string_sprintf("%s@%s", deliver_localpart, deliver_domain);
2418     }
2419   else if (strncmpic(ss, US"count=", 6) == 0)
2420     {
2421     uschar *e;
2422     count = Ustrtod(ss+6, &e);
2423     if (count < 0.0 || *e != '\0')
2424       return ratelimit_error(log_msgptr,
2425         "\"%s\" is not a positive number", ss);
2426     }
2427   else if (strncmpic(ss, US"unique=", 7) == 0)
2428     unique = string_copy(ss + 7);
2429   else if (key == NULL)
2430     key = string_copy(ss);
2431   else
2432     key = string_sprintf("%s/%s", key, ss);
2433   }
2434
2435 /* Sanity check. When the badacl flag is set the update mode must either
2436 be readonly (which is the default if it is omitted) or, for backwards
2437 compatibility, a combination of noupdate and strict or leaky. */
2438
2439 if (mode == RATE_PER_CLASH)
2440   return ratelimit_error(log_msgptr, "conflicting per_* options");
2441 if (leaky + strict + readonly > 1)
2442   return ratelimit_error(log_msgptr, "conflicting update modes");
2443 if (badacl && (leaky || strict) && !noupdate)
2444   return ratelimit_error(log_msgptr,
2445     "\"%s\" must not have /leaky or /strict option in %s ACL",
2446     ratelimit_option_string[mode], acl_wherenames[where]);
2447
2448 /* Set the default values of any unset options. In readonly mode we
2449 perform the rate computation without any increment so that its value
2450 decays to eventually allow over-limit senders through. */
2451
2452 if (noupdate) readonly = TRUE, leaky = strict = FALSE;
2453 if (badacl) readonly = TRUE;
2454 if (readonly) count = 0.0;
2455 if (!strict && !readonly) leaky = TRUE;
2456 if (mode == RATE_PER_WHAT) mode = RATE_PER_MAIL;
2457
2458 /* Create the lookup key. If there is no explicit key, use sender_host_address.
2459 If there is no sender_host_address (e.g. -bs or acl_not_smtp) then we simply
2460 omit it. The smoothing constant (sender_rate_period) and the per_xxx options
2461 are added to the key because they alter the meaning of the stored data. */
2462
2463 if (key == NULL)
2464   key = (sender_host_address == NULL)? US"" : sender_host_address;
2465
2466 key = string_sprintf("%s/%s/%s%s",
2467   sender_rate_period,
2468   ratelimit_option_string[mode],
2469   unique == NULL ? "" : "unique/",
2470   key);
2471
2472 HDEBUG(D_acl)
2473   debug_printf("ratelimit condition count=%.0f %.1f/%s\n", count, limit, key);
2474
2475 /* See if we have already computed the rate by looking in the relevant tree.
2476 For per-connection rate limiting, store tree nodes and dbdata in the permanent
2477 pool so that they survive across resets. In readonly mode we only remember the
2478 result for the rest of this command in case a later command changes it. After
2479 this bit of logic the code is independent of the per_* mode. */
2480
2481 old_pool = store_pool;
2482
2483 if (readonly)
2484   anchor = &ratelimiters_cmd;
2485 else switch(mode) {
2486 case RATE_PER_CONN:
2487   anchor = &ratelimiters_conn;
2488   store_pool = POOL_PERM;
2489   break;
2490 case RATE_PER_BYTE:
2491 case RATE_PER_MAIL:
2492 case RATE_PER_ALLRCPTS:
2493   anchor = &ratelimiters_mail;
2494   break;
2495 case RATE_PER_ADDR:
2496 case RATE_PER_CMD:
2497 case RATE_PER_RCPT:
2498   anchor = &ratelimiters_cmd;
2499   break;
2500 default:
2501   anchor = NULL; /* silence an "unused" complaint */
2502   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
2503     "internal ACL error: unknown ratelimit mode %d", mode);
2504   break;
2505 }
2506
2507 t = tree_search(*anchor, key);
2508 if (t != NULL)
2509   {
2510   dbd = t->data.ptr;
2511   /* The following few lines duplicate some of the code below. */
2512   rc = (dbd->rate < limit)? FAIL : OK;
2513   store_pool = old_pool;
2514   sender_rate = string_sprintf("%.1f", dbd->rate);
2515   HDEBUG(D_acl)
2516     debug_printf("ratelimit found pre-computed rate %s\n", sender_rate);
2517   return rc;
2518   }
2519
2520 /* We aren't using a pre-computed rate, so get a previously recorded rate
2521 from the database, which will be updated and written back if required. */
2522
2523 dbm = dbfn_open(US"ratelimit", O_RDWR, &dbblock, TRUE);
2524 if (dbm == NULL)
2525   {
2526   store_pool = old_pool;
2527   sender_rate = NULL;
2528   HDEBUG(D_acl) debug_printf("ratelimit database not available\n");
2529   *log_msgptr = US"ratelimit database not available";
2530   return DEFER;
2531   }
2532 dbdb = dbfn_read_with_length(dbm, key, &dbdb_size);
2533 dbd = NULL;
2534
2535 gettimeofday(&tv, NULL);
2536
2537 if (dbdb != NULL)
2538   {
2539   /* Locate the basic ratelimit block inside the DB data. */
2540   HDEBUG(D_acl) debug_printf("ratelimit found key in database\n");
2541   dbd = &dbdb->dbd;
2542
2543   /* Forget the old Bloom filter if it is too old, so that we count each
2544   repeating event once per period. We don't simply clear and re-use the old
2545   filter because we want its size to change if the limit changes. Note that
2546   we keep the dbd pointer for copying the rate into the new data block. */
2547
2548   if(unique != NULL && tv.tv_sec > dbdb->bloom_epoch + period)
2549     {
2550     HDEBUG(D_acl) debug_printf("ratelimit discarding old Bloom filter\n");
2551     dbdb = NULL;
2552     }
2553
2554   /* Sanity check. */
2555
2556   if(unique != NULL && dbdb_size < sizeof(*dbdb))
2557     {
2558     HDEBUG(D_acl) debug_printf("ratelimit discarding undersize Bloom filter\n");
2559     dbdb = NULL;
2560     }
2561   }
2562
2563 /* Allocate a new data block if the database lookup failed
2564 or the Bloom filter passed its age limit. */
2565
2566 if (dbdb == NULL)
2567   {
2568   if (unique == NULL)
2569     {
2570     /* No Bloom filter. This basic ratelimit block is initialized below. */
2571     HDEBUG(D_acl) debug_printf("ratelimit creating new rate data block\n");
2572     dbdb_size = sizeof(*dbd);
2573     dbdb = store_get(dbdb_size);
2574     }
2575   else
2576     {
2577     int extra;
2578     HDEBUG(D_acl) debug_printf("ratelimit creating new Bloom filter\n");
2579
2580     /* See the long comment below for an explanation of the magic number 2.
2581     The filter has a minimum size in case the rate limit is very small;
2582     this is determined by the definition of dbdata_ratelimit_unique. */
2583
2584     extra = (int)limit * 2 - sizeof(dbdb->bloom);
2585     if (extra < 0) extra = 0;
2586     dbdb_size = sizeof(*dbdb) + extra;
2587     dbdb = store_get(dbdb_size);
2588     dbdb->bloom_epoch = tv.tv_sec;
2589     dbdb->bloom_size = sizeof(dbdb->bloom) + extra;
2590     memset(dbdb->bloom, 0, dbdb->bloom_size);
2591
2592     /* Preserve any basic ratelimit data (which is our longer-term memory)
2593     by copying it from the discarded block. */
2594
2595     if (dbd != NULL)
2596       {
2597       dbdb->dbd = *dbd;
2598       dbd = &dbdb->dbd;
2599       }
2600     }
2601   }
2602
2603 /* If we are counting unique events, find out if this event is new or not.
2604 If the client repeats the event during the current period then it should be
2605 counted. We skip this code in readonly mode for efficiency, because any
2606 changes to the filter will be discarded and because count is already set to
2607 zero. */
2608
2609 if (unique != NULL && !readonly)
2610   {
2611   /* We identify unique events using a Bloom filter. (You can find my
2612   notes on Bloom filters at http://fanf.livejournal.com/81696.html)
2613   With the per_addr option, an "event" is a recipient address, though the
2614   user can use the unique option to define their own events. We only count
2615   an event if we have not seen it before.
2616
2617   We size the filter according to the rate limit, which (in leaky mode)
2618   is the limit on the population of the filter. We allow 16 bits of space
2619   per entry (see the construction code above) and we set (up to) 8 of them
2620   when inserting an element (see the loop below). The probability of a false
2621   positive (an event we have not seen before but which we fail to count) is
2622
2623     size    = limit * 16
2624     numhash = 8
2625     allzero = exp(-numhash * pop / size)
2626             = exp(-0.5 * pop / limit)
2627     fpr     = pow(1 - allzero, numhash)
2628
2629   For senders at the limit the fpr is      0.06%    or  1 in 1700
2630   and for senders at half the limit it is  0.0006%  or  1 in 170000
2631
2632   In strict mode the Bloom filter can fill up beyond the normal limit, in
2633   which case the false positive rate will rise. This means that the
2634   measured rate for very fast senders can bogusly drop off after a while.
2635
2636   At twice the limit, the fpr is  2.5%  or  1 in 40
2637   At four times the limit, it is  31%   or  1 in 3.2
2638
2639   It takes ln(pop/limit) periods for an over-limit burst of pop events to
2640   decay below the limit, and if this is more than one then the Bloom filter
2641   will be discarded before the decay gets that far. The false positive rate
2642   at this threshold is 9.3% or 1 in 10.7. */
2643
2644   BOOL seen;
2645   unsigned n, hash, hinc;
2646   uschar md5sum[16];
2647   md5 md5info;
2648
2649   /* Instead of using eight independent hash values, we combine two values
2650   using the formula h1 + n * h2. This does not harm the Bloom filter's
2651   performance, and means the amount of hash we need is independent of the
2652   number of bits we set in the filter. */
2653
2654   md5_start(&md5info);
2655   md5_end(&md5info, unique, Ustrlen(unique), md5sum);
2656   hash = md5sum[0] | md5sum[1] << 8 | md5sum[2] << 16 | md5sum[3] << 24;
2657   hinc = md5sum[4] | md5sum[5] << 8 | md5sum[6] << 16 | md5sum[7] << 24;
2658
2659   /* Scan the bits corresponding to this event. A zero bit means we have
2660   not seen it before. Ensure all bits are set to record this event. */
2661
2662   HDEBUG(D_acl) debug_printf("ratelimit checking uniqueness of %s\n", unique);
2663
2664   seen = TRUE;
2665   for (n = 0; n < 8; n++, hash += hinc)
2666     {
2667     int bit = 1 << (hash % 8);
2668     int byte = (hash / 8) % dbdb->bloom_size;
2669     if ((dbdb->bloom[byte] & bit) == 0)
2670       {
2671       dbdb->bloom[byte] |= bit;
2672       seen = FALSE;
2673       }
2674     }
2675
2676   /* If this event has occurred before, do not count it. */
2677
2678   if (seen)
2679     {
2680     HDEBUG(D_acl) debug_printf("ratelimit event found in Bloom filter\n");
2681     count = 0.0;
2682     }
2683   else
2684     HDEBUG(D_acl) debug_printf("ratelimit event added to Bloom filter\n");
2685   }
2686
2687 /* If there was no previous ratelimit data block for this key, initialize
2688 the new one, otherwise update the block from the database. The initial rate
2689 is what would be computed by the code below for an infinite interval. */
2690
2691 if (dbd == NULL)
2692   {
2693   HDEBUG(D_acl) debug_printf("ratelimit initializing new key's rate data\n");
2694   dbd = &dbdb->dbd;
2695   dbd->time_stamp = tv.tv_sec;
2696   dbd->time_usec = tv.tv_usec;
2697   dbd->rate = count;
2698   }
2699 else
2700   {
2701   /* The smoothed rate is computed using an exponentially weighted moving
2702   average adjusted for variable sampling intervals. The standard EWMA for
2703   a fixed sampling interval is:  f'(t) = (1 - a) * f(t) + a * f'(t - 1)
2704   where f() is the measured value and f'() is the smoothed value.
2705
2706   Old data decays out of the smoothed value exponentially, such that data n
2707   samples old is multiplied by a^n. The exponential decay time constant p
2708   is defined such that data p samples old is multiplied by 1/e, which means
2709   that a = exp(-1/p). We can maintain the same time constant for a variable
2710   sampling interval i by using a = exp(-i/p).
2711
2712   The rate we are measuring is messages per period, suitable for directly
2713   comparing with the limit. The average rate between now and the previous
2714   message is period / interval, which we feed into the EWMA as the sample.
2715
2716   It turns out that the number of messages required for the smoothed rate
2717   to reach the limit when they are sent in a burst is equal to the limit.
2718   This can be seen by analysing the value of the smoothed rate after N
2719   messages sent at even intervals. Let k = (1 - a) * p/i
2720
2721     rate_1 = (1 - a) * p/i + a * rate_0
2722            = k + a * rate_0
2723     rate_2 = k + a * rate_1
2724            = k + a * k + a^2 * rate_0
2725     rate_3 = k + a * k + a^2 * k + a^3 * rate_0
2726     rate_N = rate_0 * a^N + k * SUM(x=0..N-1)(a^x)
2727            = rate_0 * a^N + k * (1 - a^N) / (1 - a)
2728            = rate_0 * a^N + p/i * (1 - a^N)
2729
2730   When N is large, a^N -> 0 so rate_N -> p/i as desired.
2731
2732     rate_N = p/i + (rate_0 - p/i) * a^N
2733     a^N = (rate_N - p/i) / (rate_0 - p/i)
2734     N * -i/p = log((rate_N - p/i) / (rate_0 - p/i))
2735     N = p/i * log((rate_0 - p/i) / (rate_N - p/i))
2736
2737   Numerical analysis of the above equation, setting the computed rate to
2738   increase from rate_0 = 0 to rate_N = limit, shows that for large sending
2739   rates, p/i, the number of messages N = limit. So limit serves as both the
2740   maximum rate measured in messages per period, and the maximum number of
2741   messages that can be sent in a fast burst. */
2742
2743   double this_time = (double)tv.tv_sec
2744                    + (double)tv.tv_usec / 1000000.0;
2745   double prev_time = (double)dbd->time_stamp
2746                    + (double)dbd->time_usec / 1000000.0;
2747
2748   /* We must avoid division by zero, and deal gracefully with the clock going
2749   backwards. If we blunder ahead when time is in reverse then the computed
2750   rate will be bogus. To be safe we clamp interval to a very small number. */
2751
2752   double interval = this_time - prev_time <= 0.0 ? 1e-9
2753                   : this_time - prev_time;
2754
2755   double i_over_p = interval / period;
2756   double a = exp(-i_over_p);
2757
2758   /* Combine the instantaneous rate (period / interval) with the previous rate
2759   using the smoothing factor a. In order to measure sized events, multiply the
2760   instantaneous rate by the count of bytes or recipients etc. */
2761
2762   dbd->time_stamp = tv.tv_sec;
2763   dbd->time_usec = tv.tv_usec;
2764   dbd->rate = (1 - a) * count / i_over_p + a * dbd->rate;
2765
2766   /* When events are very widely spaced the computed rate tends towards zero.
2767   Although this is accurate it turns out not to be useful for our purposes,
2768   especially when the first event after a long silence is the start of a spam
2769   run. A more useful model is that the rate for an isolated event should be the
2770   size of the event per the period size, ignoring the lack of events outside
2771   the current period and regardless of where the event falls in the period. So,
2772   if the interval was so long that the calculated rate is unhelpfully small, we
2773   re-intialize the rate. In the absence of higher-rate bursts, the condition
2774   below is true if the interval is greater than the period. */
2775
2776   if (dbd->rate < count) dbd->rate = count;
2777   }
2778
2779 /* Clients sending at the limit are considered to be over the limit.
2780 This matters for edge cases such as a limit of zero, when the client
2781 should be completely blocked. */
2782
2783 rc = (dbd->rate < limit)? FAIL : OK;
2784
2785 /* Update the state if the rate is low or if we are being strict. If we
2786 are in leaky mode and the sender's rate is too high, we do not update
2787 the recorded rate in order to avoid an over-aggressive sender's retry
2788 rate preventing them from getting any email through. If readonly is set,
2789 neither leaky nor strict are set, so we do not do any updates. */
2790
2791 if ((rc == FAIL && leaky) || strict)
2792   {
2793   dbfn_write(dbm, key, dbdb, dbdb_size);
2794   HDEBUG(D_acl) debug_printf("ratelimit db updated\n");
2795   }
2796 else
2797   {
2798   HDEBUG(D_acl) debug_printf("ratelimit db not updated: %s\n",
2799     readonly? "readonly mode" : "over the limit, but leaky");
2800   }
2801
2802 dbfn_close(dbm);
2803
2804 /* Store the result in the tree for future reference. */
2805
2806 t = store_get(sizeof(tree_node) + Ustrlen(key));
2807 t->data.ptr = dbd;
2808 Ustrcpy(t->name, key);
2809 (void)tree_insertnode(anchor, t);
2810
2811 /* We create the formatted version of the sender's rate very late in
2812 order to ensure that it is done using the correct storage pool. */
2813
2814 store_pool = old_pool;
2815 sender_rate = string_sprintf("%.1f", dbd->rate);
2816
2817 HDEBUG(D_acl)
2818   debug_printf("ratelimit computed rate %s\n", sender_rate);
2819
2820 return rc;
2821 }
2822
2823
2824
2825 /*************************************************
2826 *            The udpsend ACL modifier            *
2827 *************************************************/
2828
2829 /* Called by acl_check_condition() below.
2830
2831 Arguments:
2832   arg          the option string for udpsend=
2833   log_msgptr   for error messages
2834
2835 Returns:       OK        - Completed.
2836                DEFER     - Problem with DNS lookup.
2837                ERROR     - Syntax error in options.
2838 */
2839
2840 static int
2841 acl_udpsend(uschar *arg, uschar **log_msgptr)
2842 {
2843 int sep = 0;
2844 uschar *hostname;
2845 uschar *portstr;
2846 uschar *portend;
2847 host_item *h;
2848 int portnum;
2849 int host_af;
2850 int len;
2851 int r, s;
2852
2853 hostname = string_nextinlist(&arg, &sep, NULL, 0);
2854 portstr = string_nextinlist(&arg, &sep, NULL, 0);
2855
2856 if (hostname == NULL)
2857   {
2858   *log_msgptr = US"missing destination host in \"udpsend\" modifier";
2859   return ERROR;
2860   }
2861 if (portstr == NULL)
2862   {
2863   *log_msgptr = US"missing destination port in \"udpsend\" modifier";
2864   return ERROR;
2865   }
2866 if (arg == NULL)
2867   {
2868   *log_msgptr = US"missing datagram payload in \"udpsend\" modifier";
2869   return ERROR;
2870   }
2871 portnum = Ustrtol(portstr, &portend, 10);
2872 if (*portend != '\0')
2873   {
2874   *log_msgptr = US"bad destination port in \"udpsend\" modifier";
2875   return ERROR;
2876   }
2877
2878 /* Make a single-item host list. */
2879 h = store_get(sizeof(host_item));
2880 memset(h, 0, sizeof(host_item));
2881 h->name = hostname;
2882 h->port = portnum;
2883 h->mx = MX_NONE;
2884
2885 if (string_is_ip_address(hostname, NULL))
2886   h->address = hostname, r = HOST_FOUND;
2887 else
2888   r = host_find_byname(h, NULL, 0, NULL, FALSE);
2889 if (r == HOST_FIND_FAILED || r == HOST_FIND_AGAIN)
2890   {
2891   *log_msgptr = US"DNS lookup failed in \"udpsend\" modifier";
2892   return DEFER;
2893   }
2894
2895 HDEBUG(D_acl)
2896   debug_printf("udpsend [%s]:%d %s\n", h->address, portnum, arg);
2897
2898 host_af = (Ustrchr(h->address, ':') == NULL)? AF_INET:AF_INET6;
2899 r = s = ip_socket(SOCK_DGRAM, host_af);
2900 if (r < 0) goto defer;
2901 r = ip_connect(s, host_af, h->address, portnum, 1);
2902 if (r < 0) goto defer;
2903 len = Ustrlen(arg);
2904 r = send(s, arg, len, 0);
2905 if (r < 0) goto defer;
2906 if (r < len)
2907   {
2908   *log_msgptr =
2909     string_sprintf("\"udpsend\" truncated from %d to %d octets", len, r);
2910   return DEFER;
2911   }
2912
2913 HDEBUG(D_acl)
2914   debug_printf("udpsend %d bytes\n", r);
2915
2916 return OK;
2917
2918 defer:
2919 *log_msgptr = string_sprintf("\"udpsend\" failed: %s", strerror(errno));
2920 return DEFER;
2921 }
2922
2923
2924
2925 /*************************************************
2926 *   Handle conditions/modifiers on an ACL item   *
2927 *************************************************/
2928
2929 /* Called from acl_check() below.
2930
2931 Arguments:
2932   verb         ACL verb
2933   cb           ACL condition block - if NULL, result is OK
2934   where        where called from
2935   addr         the address being checked for RCPT, or NULL
2936   level        the nesting level
2937   epp          pointer to pass back TRUE if "endpass" encountered
2938                  (applies only to "accept" and "discard")
2939   user_msgptr  user message pointer
2940   log_msgptr   log message pointer
2941   basic_errno  pointer to where to put verify error
2942
2943 Returns:       OK        - all conditions are met
2944                DISCARD   - an "acl" condition returned DISCARD - only allowed
2945                              for "accept" or "discard" verbs
2946                FAIL      - at least one condition fails
2947                FAIL_DROP - an "acl" condition returned FAIL_DROP
2948                DEFER     - can't tell at the moment (typically, lookup defer,
2949                              but can be temporary callout problem)
2950                ERROR     - ERROR from nested ACL or expansion failure or other
2951                              error
2952 */
2953
2954 static int
2955 acl_check_condition(int verb, acl_condition_block *cb, int where,
2956   address_item *addr, int level, BOOL *epp, uschar **user_msgptr,
2957   uschar **log_msgptr, int *basic_errno)
2958 {
2959 uschar *user_message = NULL;
2960 uschar *log_message = NULL;
2961 uschar *debug_tag = NULL;
2962 uschar *debug_opts = NULL;
2963 uschar *p = NULL;
2964 int rc = OK;
2965 #ifdef WITH_CONTENT_SCAN
2966 int sep = '/';
2967 #endif
2968
2969 for (; cb != NULL; cb = cb->next)
2970   {
2971   uschar *arg;
2972   int control_type;
2973
2974   /* The message and log_message items set up messages to be used in
2975   case of rejection. They are expanded later. */
2976
2977   if (cb->type == ACLC_MESSAGE)
2978     {
2979     user_message = cb->arg;
2980     continue;
2981     }
2982
2983   if (cb->type == ACLC_LOG_MESSAGE)
2984     {
2985     log_message = cb->arg;
2986     continue;
2987     }
2988
2989   /* The endpass "condition" just sets a flag to show it occurred. This is
2990   checked at compile time to be on an "accept" or "discard" item. */
2991
2992   if (cb->type == ACLC_ENDPASS)
2993     {
2994     *epp = TRUE;
2995     continue;
2996     }
2997
2998   /* For other conditions and modifiers, the argument is expanded now for some
2999   of them, but not for all, because expansion happens down in some lower level
3000   checking functions in some cases. */
3001
3002   if (cond_expand_at_top[cb->type])
3003     {
3004     arg = expand_string(cb->arg);
3005     if (arg == NULL)
3006       {
3007       if (expand_string_forcedfail) continue;
3008       *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
3009         cb->arg, expand_string_message);
3010       return search_find_defer? DEFER : ERROR;
3011       }
3012     }
3013   else arg = cb->arg;
3014
3015   /* Show condition, and expanded condition if it's different */
3016
3017   HDEBUG(D_acl)
3018     {
3019     int lhswidth = 0;
3020     debug_printf("check %s%s %n",
3021       (!cond_modifiers[cb->type] && cb->u.negated)? "!":"",
3022       conditions[cb->type], &lhswidth);
3023
3024     if (cb->type == ACLC_SET)
3025       {
3026       debug_printf("acl_%s ", cb->u.varname);
3027       lhswidth += 5 + Ustrlen(cb->u.varname);
3028       }
3029
3030     debug_printf("= %s\n", cb->arg);
3031
3032     if (arg != cb->arg)
3033       debug_printf("%.*s= %s\n", lhswidth,
3034       US"                             ", CS arg);
3035     }
3036
3037   /* Check that this condition makes sense at this time */
3038
3039   if ((cond_forbids[cb->type] & (1 << where)) != 0)
3040     {
3041     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
3042       cond_modifiers[cb->type]? "use" : "test",
3043       conditions[cb->type], acl_wherenames[where]);
3044     return ERROR;
3045     }
3046
3047   /* Run the appropriate test for each condition, or take the appropriate
3048   action for the remaining modifiers. */
3049
3050   switch(cb->type)
3051     {
3052     case ACLC_ADD_HEADER:
3053     setup_header(arg);
3054     break;
3055
3056     /* A nested ACL that returns "discard" makes sense only for an "accept" or
3057     "discard" verb. */
3058
3059     case ACLC_ACL:
3060       rc = acl_check_wargs(where, addr, arg, level+1, user_msgptr, log_msgptr);
3061       if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
3062         {
3063         *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
3064           "\"%s\" command (only allowed with \"accept\" or \"discard\")",
3065           verbs[verb]);
3066         return ERROR;
3067         }
3068     break;
3069
3070     case ACLC_AUTHENTICATED:
3071     rc = (sender_host_authenticated == NULL)? FAIL :
3072       match_isinlist(sender_host_authenticated, &arg, 0, NULL, NULL, MCL_STRING,
3073         TRUE, NULL);
3074     break;
3075
3076     #ifdef EXPERIMENTAL_BRIGHTMAIL
3077     case ACLC_BMI_OPTIN:
3078       {
3079       int old_pool = store_pool;
3080       store_pool = POOL_PERM;
3081       bmi_current_optin = string_copy(arg);
3082       store_pool = old_pool;
3083       }
3084     break;
3085     #endif
3086
3087     case ACLC_CONDITION:
3088     /* The true/false parsing here should be kept in sync with that used in
3089     expand.c when dealing with ECOND_BOOL so that we don't have too many
3090     different definitions of what can be a boolean. */
3091     if (Ustrspn(arg, "0123456789") == Ustrlen(arg))     /* Digits, or empty */
3092       rc = (Uatoi(arg) == 0)? FAIL : OK;
3093     else
3094       rc = (strcmpic(arg, US"no") == 0 ||
3095             strcmpic(arg, US"false") == 0)? FAIL :
3096            (strcmpic(arg, US"yes") == 0 ||
3097             strcmpic(arg, US"true") == 0)? OK : DEFER;
3098     if (rc == DEFER)
3099       *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
3100     break;
3101
3102     case ACLC_CONTINUE:    /* Always succeeds */
3103     break;
3104
3105     case ACLC_CONTROL:
3106     control_type = decode_control(arg, &p, where, log_msgptr);
3107
3108     /* Check if this control makes sense at this time */
3109
3110     if ((control_forbids[control_type] & (1 << where)) != 0)
3111       {
3112       *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
3113         controls[control_type], acl_wherenames[where]);
3114       return ERROR;
3115       }
3116
3117     switch(control_type)
3118       {
3119       case CONTROL_AUTH_UNADVERTISED:
3120       allow_auth_unadvertised = TRUE;
3121       break;
3122
3123       #ifdef EXPERIMENTAL_BRIGHTMAIL
3124       case CONTROL_BMI_RUN:
3125       bmi_run = 1;
3126       break;
3127       #endif
3128
3129       #ifndef DISABLE_DKIM
3130       case CONTROL_DKIM_VERIFY:
3131       dkim_disable_verify = TRUE;
3132       #ifdef EXPERIMENTAL_DMARC
3133       /* Since DKIM was blocked, skip DMARC too */
3134       dmarc_disable_verify = TRUE;
3135       dmarc_enable_forensic = FALSE;
3136       #endif
3137       break;
3138       #endif
3139
3140       #ifdef EXPERIMENTAL_DMARC
3141       case CONTROL_DMARC_VERIFY:
3142       dmarc_disable_verify = TRUE;
3143       break;
3144
3145       case CONTROL_DMARC_FORENSIC:
3146       dmarc_enable_forensic = TRUE;
3147       break;
3148       #endif
3149
3150       case CONTROL_DSCP:
3151       if (*p == '/')
3152         {
3153         int fd, af, level, optname, value;
3154         /* If we are acting on stdin, the setsockopt may fail if stdin is not
3155         a socket; we can accept that, we'll just debug-log failures anyway. */
3156         fd = fileno(smtp_in);
3157         af = ip_get_address_family(fd);
3158         if (af < 0)
3159           {
3160           HDEBUG(D_acl)
3161             debug_printf("smtp input is probably not a socket [%s], not setting DSCP\n",
3162                 strerror(errno));
3163           break;
3164           }
3165         if (dscp_lookup(p+1, af, &level, &optname, &value))
3166           {
3167           if (setsockopt(fd, level, optname, &value, sizeof(value)) < 0)
3168             {
3169             HDEBUG(D_acl) debug_printf("failed to set input DSCP[%s]: %s\n",
3170                 p+1, strerror(errno));
3171             }
3172           else
3173             {
3174             HDEBUG(D_acl) debug_printf("set input DSCP to \"%s\"\n", p+1);
3175             }
3176           }
3177         else
3178           {
3179           *log_msgptr = string_sprintf("unrecognised DSCP value in \"control=%s\"", arg);
3180           return ERROR;
3181           }
3182         }
3183       else
3184         {
3185         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3186         return ERROR;
3187         }
3188       break;
3189
3190       case CONTROL_ERROR:
3191       return ERROR;
3192
3193       case CONTROL_CASEFUL_LOCAL_PART:
3194       deliver_localpart = addr->cc_local_part;
3195       break;
3196
3197       case CONTROL_CASELOWER_LOCAL_PART:
3198       deliver_localpart = addr->lc_local_part;
3199       break;
3200
3201       case CONTROL_ENFORCE_SYNC:
3202       smtp_enforce_sync = TRUE;
3203       break;
3204
3205       case CONTROL_NO_ENFORCE_SYNC:
3206       smtp_enforce_sync = FALSE;
3207       break;
3208
3209       #ifdef WITH_CONTENT_SCAN
3210       case CONTROL_NO_MBOX_UNSPOOL:
3211       no_mbox_unspool = TRUE;
3212       break;
3213       #endif
3214
3215       case CONTROL_NO_MULTILINE:
3216       no_multiline_responses = TRUE;
3217       break;
3218
3219       case CONTROL_NO_PIPELINING:
3220       pipelining_enable = FALSE;
3221       break;
3222
3223       case CONTROL_NO_DELAY_FLUSH:
3224       disable_delay_flush = TRUE;
3225       break;
3226
3227       case CONTROL_NO_CALLOUT_FLUSH:
3228       disable_callout_flush = TRUE;
3229       break;
3230
3231       case CONTROL_FAKEDEFER:
3232       case CONTROL_FAKEREJECT:
3233       fake_response = (control_type == CONTROL_FAKEDEFER) ? DEFER : FAIL;
3234       if (*p == '/')
3235         {
3236         uschar *pp = p + 1;
3237         while (*pp != 0) pp++;
3238         fake_response_text = expand_string(string_copyn(p+1, pp-p-1));
3239         p = pp;
3240         }
3241        else
3242         {
3243         /* Explicitly reset to default string */
3244         fake_response_text = US"Your message has been rejected but is being kept for evaluation.\nIf it was a legitimate message, it may still be delivered to the target recipient(s).";
3245         }
3246       break;
3247
3248       case CONTROL_FREEZE:
3249       deliver_freeze = TRUE;
3250       deliver_frozen_at = time(NULL);
3251       freeze_tell = freeze_tell_config;       /* Reset to configured value */
3252       if (Ustrncmp(p, "/no_tell", 8) == 0)
3253         {
3254         p += 8;
3255         freeze_tell = NULL;
3256         }
3257       if (*p != 0)
3258         {
3259         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3260         return ERROR;
3261         }
3262       break;
3263
3264       case CONTROL_QUEUE_ONLY:
3265       queue_only_policy = TRUE;
3266       break;
3267
3268       case CONTROL_SUBMISSION:
3269       originator_name = US"";
3270       submission_mode = TRUE;
3271       while (*p == '/')
3272         {
3273         if (Ustrncmp(p, "/sender_retain", 14) == 0)
3274           {
3275           p += 14;
3276           active_local_sender_retain = TRUE;
3277           active_local_from_check = FALSE;
3278           }
3279         else if (Ustrncmp(p, "/domain=", 8) == 0)
3280           {
3281           uschar *pp = p + 8;
3282           while (*pp != 0 && *pp != '/') pp++;
3283           submission_domain = string_copyn(p+8, pp-p-8);
3284           p = pp;
3285           }
3286         /* The name= option must be last, because it swallows the rest of
3287         the string. */
3288         else if (Ustrncmp(p, "/name=", 6) == 0)
3289           {
3290           uschar *pp = p + 6;
3291           while (*pp != 0) pp++;
3292           submission_name = string_copy(parse_fix_phrase(p+6, pp-p-6,
3293             big_buffer, big_buffer_size));
3294           p = pp;
3295           }
3296         else break;
3297         }
3298       if (*p != 0)
3299         {
3300         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3301         return ERROR;
3302         }
3303       break;
3304
3305       case CONTROL_DEBUG:
3306       while (*p == '/')
3307         {
3308         if (Ustrncmp(p, "/tag=", 5) == 0)
3309           {
3310           uschar *pp = p + 5;
3311           while (*pp != '\0' && *pp != '/') pp++;
3312           debug_tag = string_copyn(p+5, pp-p-5);
3313           p = pp;
3314           }
3315         else if (Ustrncmp(p, "/opts=", 6) == 0)
3316           {
3317           uschar *pp = p + 6;
3318           while (*pp != '\0' && *pp != '/') pp++;
3319           debug_opts = string_copyn(p+6, pp-p-6);
3320           p = pp;
3321           }
3322         }
3323         debug_logging_activate(debug_tag, debug_opts);
3324       break;
3325
3326       case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3327       suppress_local_fixups = TRUE;
3328       break;
3329
3330       case CONTROL_CUTTHROUGH_DELIVERY:
3331       if (deliver_freeze)
3332         {
3333         *log_msgptr = string_sprintf("\"control=%s\" on frozen item", arg);
3334         return ERROR;
3335         }
3336        if (queue_only_policy)
3337         {
3338         *log_msgptr = string_sprintf("\"control=%s\" on queue-only item", arg);
3339         return ERROR;
3340         }
3341       cutthrough_delivery = TRUE;
3342       break;
3343       }
3344     break;
3345
3346     #ifdef EXPERIMENTAL_DCC
3347     case ACLC_DCC:
3348       {
3349       /* Seperate the regular expression and any optional parameters. */
3350       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
3351       /* Run the dcc backend. */
3352       rc = dcc_process(&ss);
3353       /* Modify return code based upon the existance of options. */
3354       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
3355             != NULL) {
3356         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3357           {
3358           /* FAIL so that the message is passed to the next ACL */
3359           rc = FAIL;
3360           }
3361         }
3362       }
3363     break;
3364     #endif
3365
3366     #ifdef WITH_CONTENT_SCAN
3367     case ACLC_DECODE:
3368     rc = mime_decode(&arg);
3369     break;
3370     #endif
3371
3372     case ACLC_DELAY:
3373       {
3374       int delay = readconf_readtime(arg, 0, FALSE);
3375       if (delay < 0)
3376         {
3377         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3378           "modifier: \"%s\" is not a time value", arg);
3379         return ERROR;
3380         }
3381       else
3382         {
3383         HDEBUG(D_acl) debug_printf("delay modifier requests %d-second delay\n",
3384           delay);
3385         if (host_checking)
3386           {
3387           HDEBUG(D_acl)
3388             debug_printf("delay skipped in -bh checking mode\n");
3389           }
3390
3391         /* It appears to be impossible to detect that a TCP/IP connection has
3392         gone away without reading from it. This means that we cannot shorten
3393         the delay below if the client goes away, because we cannot discover
3394         that the client has closed its end of the connection. (The connection
3395         is actually in a half-closed state, waiting for the server to close its
3396         end.) It would be nice to be able to detect this state, so that the
3397         Exim process is not held up unnecessarily. However, it seems that we
3398         can't. The poll() function does not do the right thing, and in any case
3399         it is not always available.
3400
3401         NOTE 1: If ever this state of affairs changes, remember that we may be
3402         dealing with stdin/stdout here, in addition to TCP/IP connections.
3403         Also, delays may be specified for non-SMTP input, where smtp_out and
3404         smtp_in will be NULL. Whatever is done must work in all cases.
3405
3406         NOTE 2: The added feature of flushing the output before a delay must
3407         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3408         */
3409
3410         else
3411           {
3412           if (smtp_out != NULL && !disable_delay_flush) mac_smtp_fflush();
3413           while (delay > 0) delay = sleep(delay);
3414           }
3415         }
3416       }
3417     break;
3418
3419     #ifdef WITH_OLD_DEMIME
3420     case ACLC_DEMIME:
3421       rc = demime(&arg);
3422     break;
3423     #endif
3424
3425     #ifndef DISABLE_DKIM
3426     case ACLC_DKIM_SIGNER:
3427     if (dkim_cur_signer != NULL)
3428       rc = match_isinlist(dkim_cur_signer,
3429                           &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3430     else
3431        rc = FAIL;
3432     break;
3433
3434     case ACLC_DKIM_STATUS:
3435     rc = match_isinlist(dkim_exim_expand_query(DKIM_VERIFY_STATUS),
3436                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3437     break;
3438     #endif
3439
3440     #ifdef EXPERIMENTAL_DMARC
3441     case ACLC_DMARC_STATUS:
3442     if (!dmarc_has_been_checked)
3443       dmarc_process();
3444     dmarc_has_been_checked = TRUE;
3445     /* used long way of dmarc_exim_expand_query() in case we need more
3446      * view into the process in the future. */
3447     rc = match_isinlist(dmarc_exim_expand_query(DMARC_VERIFY_STATUS),
3448                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3449     break;
3450     #endif
3451
3452     case ACLC_DNSLISTS:
3453     rc = verify_check_dnsbl(&arg);
3454     break;
3455
3456     case ACLC_DOMAINS:
3457     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3458       addr->domain_cache, MCL_DOMAIN, TRUE, &deliver_domain_data);
3459     break;
3460
3461     /* The value in tls_cipher is the full cipher name, for example,
3462     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3463     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3464     what may in practice come out of the SSL library - which at the time of
3465     writing is poorly documented. */
3466
3467     case ACLC_ENCRYPTED:
3468     if (tls_in.cipher == NULL) rc = FAIL; else
3469       {
3470       uschar *endcipher = NULL;
3471       uschar *cipher = Ustrchr(tls_in.cipher, ':');
3472       if (cipher == NULL) cipher = tls_in.cipher; else
3473         {
3474         endcipher = Ustrchr(++cipher, ':');
3475         if (endcipher != NULL) *endcipher = 0;
3476         }
3477       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3478       if (endcipher != NULL) *endcipher = ':';
3479       }
3480     break;
3481
3482     /* Use verify_check_this_host() instead of verify_check_host() so that
3483     we can pass over &host_data to catch any looked up data. Once it has been
3484     set, it retains its value so that it's still there if another ACL verb
3485     comes through here and uses the cache. However, we must put it into
3486     permanent store in case it is also expected to be used in a subsequent
3487     message in the same SMTP connection. */
3488
3489     case ACLC_HOSTS:
3490     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3491       (sender_host_address == NULL)? US"" : sender_host_address, &host_data);
3492     if (host_data != NULL) host_data = string_copy_malloc(host_data);
3493     break;
3494
3495     case ACLC_LOCAL_PARTS:
3496     rc = match_isinlist(addr->cc_local_part, &arg, 0,
3497       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3498       &deliver_localpart_data);
3499     break;
3500
3501     case ACLC_LOG_REJECT_TARGET:
3502       {
3503       int logbits = 0;
3504       int sep = 0;
3505       uschar *s = arg;
3506       uschar *ss;
3507       while ((ss = string_nextinlist(&s, &sep, big_buffer, big_buffer_size))
3508               != NULL)
3509         {
3510         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3511         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3512         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3513         else
3514           {
3515           logbits |= LOG_MAIN|LOG_REJECT;
3516           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3517             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3518           }
3519         }
3520       log_reject_target = logbits;
3521       }
3522     break;
3523
3524     case ACLC_LOGWRITE:
3525       {
3526       int logbits = 0;
3527       uschar *s = arg;
3528       if (*s == ':')
3529         {
3530         s++;
3531         while (*s != ':')
3532           {
3533           if (Ustrncmp(s, "main", 4) == 0)
3534             { logbits |= LOG_MAIN; s += 4; }
3535           else if (Ustrncmp(s, "panic", 5) == 0)
3536             { logbits |= LOG_PANIC; s += 5; }
3537           else if (Ustrncmp(s, "reject", 6) == 0)
3538             { logbits |= LOG_REJECT; s += 6; }
3539           else
3540             {
3541             logbits = LOG_MAIN|LOG_PANIC;
3542             s = string_sprintf(":unknown log name in \"%s\" in "
3543               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3544             }
3545           if (*s == ',') s++;
3546           }
3547         s++;
3548         }
3549       while (isspace(*s)) s++;
3550
3551
3552       if (logbits == 0) logbits = LOG_MAIN;
3553       log_write(0, logbits, "%s", string_printing(s));
3554       }
3555     break;
3556
3557     #ifdef WITH_CONTENT_SCAN
3558     case ACLC_MALWARE:
3559       {
3560       /* Separate the regular expression and any optional parameters. */
3561       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
3562       /* Run the malware backend. */
3563       rc = malware(&ss);
3564       /* Modify return code based upon the existance of options. */
3565       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
3566             != NULL) {
3567         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3568           {
3569           /* FAIL so that the message is passed to the next ACL */
3570           rc = FAIL;
3571           }
3572         }
3573       }
3574     break;
3575
3576     case ACLC_MIME_REGEX:
3577     rc = mime_regex(&arg);
3578     break;
3579     #endif
3580
3581     case ACLC_RATELIMIT:
3582     rc = acl_ratelimit(arg, where, log_msgptr);
3583     break;
3584
3585     case ACLC_RECIPIENTS:
3586     rc = match_address_list(addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3587       &recipient_data);
3588     break;
3589
3590     #ifdef WITH_CONTENT_SCAN
3591     case ACLC_REGEX:
3592     rc = regex(&arg);
3593     break;
3594     #endif
3595
3596     case ACLC_REMOVE_HEADER:
3597     setup_remove_header(arg);
3598     break;
3599
3600     case ACLC_SENDER_DOMAINS:
3601       {
3602       uschar *sdomain;
3603       sdomain = Ustrrchr(sender_address, '@');
3604       sdomain = (sdomain == NULL)? US"" : sdomain + 1;
3605       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3606         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3607       }
3608     break;
3609
3610     case ACLC_SENDERS:
3611     rc = match_address_list(sender_address, TRUE, TRUE, &arg,
3612       sender_address_cache, -1, 0, &sender_data);
3613     break;
3614
3615     /* Connection variables must persist forever */
3616
3617     case ACLC_SET:
3618       {
3619       int old_pool = store_pool;
3620       if (cb->u.varname[0] == 'c') store_pool = POOL_PERM;
3621       acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
3622       store_pool = old_pool;
3623       }
3624     break;
3625
3626     #ifdef WITH_CONTENT_SCAN
3627     case ACLC_SPAM:
3628       {
3629       /* Seperate the regular expression and any optional parameters. */
3630       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
3631       /* Run the spam backend. */
3632       rc = spam(&ss);
3633       /* Modify return code based upon the existance of options. */
3634       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
3635             != NULL) {
3636         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3637           {
3638           /* FAIL so that the message is passed to the next ACL */
3639           rc = FAIL;
3640           }
3641         }
3642       }
3643     break;
3644     #endif
3645
3646     #ifdef EXPERIMENTAL_SPF
3647     case ACLC_SPF:
3648       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
3649     break;
3650     case ACLC_SPF_GUESS:
3651       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
3652     break;
3653     #endif
3654
3655     case ACLC_UDPSEND:
3656     rc = acl_udpsend(arg, log_msgptr);
3657     break;
3658
3659     /* If the verb is WARN, discard any user message from verification, because
3660     such messages are SMTP responses, not header additions. The latter come
3661     only from explicit "message" modifiers. However, put the user message into
3662     $acl_verify_message so it can be used in subsequent conditions or modifiers
3663     (until something changes it). */
3664
3665     case ACLC_VERIFY:
3666     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
3667     acl_verify_message = *user_msgptr;
3668     if (verb == ACL_WARN) *user_msgptr = NULL;
3669     break;
3670
3671     default:
3672     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
3673       "condition %d", cb->type);
3674     break;
3675     }
3676
3677   /* If a condition was negated, invert OK/FAIL. */
3678
3679   if (!cond_modifiers[cb->type] && cb->u.negated)
3680     {
3681     if (rc == OK) rc = FAIL;
3682       else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
3683     }
3684
3685   if (rc != OK) break;   /* Conditions loop */
3686   }
3687
3688
3689 /* If the result is the one for which "message" and/or "log_message" are used,
3690 handle the values of these modifiers. If there isn't a log message set, we make
3691 it the same as the user message.
3692
3693 "message" is a user message that will be included in an SMTP response. Unless
3694 it is empty, it overrides any previously set user message.
3695
3696 "log_message" is a non-user message, and it adds to any existing non-user
3697 message that is already set.
3698
3699 Most verbs have but a single return for which the messages are relevant, but
3700 for "discard", it's useful to have the log message both when it succeeds and
3701 when it fails. For "accept", the message is used in the OK case if there is no
3702 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
3703 present. */
3704
3705 if (*epp && rc == OK) user_message = NULL;
3706
3707 if (((1<<rc) & msgcond[verb]) != 0)
3708   {
3709   uschar *expmessage;
3710   uschar *old_user_msgptr = *user_msgptr;
3711   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
3712
3713   /* If the verb is "warn", messages generated by conditions (verification or
3714   nested ACLs) are always discarded. This also happens for acceptance verbs
3715   when they actually do accept. Only messages specified at this level are used.
3716   However, the value of an existing message is available in $acl_verify_message
3717   during expansions. */
3718
3719   if (verb == ACL_WARN ||
3720       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
3721     *log_msgptr = *user_msgptr = NULL;
3722
3723   if (user_message != NULL)
3724     {
3725     acl_verify_message = old_user_msgptr;
3726     expmessage = expand_string(user_message);
3727     if (expmessage == NULL)
3728       {
3729       if (!expand_string_forcedfail)
3730         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3731           user_message, expand_string_message);
3732       }
3733     else if (expmessage[0] != 0) *user_msgptr = expmessage;
3734     }
3735
3736   if (log_message != NULL)
3737     {
3738     acl_verify_message = old_log_msgptr;
3739     expmessage = expand_string(log_message);
3740     if (expmessage == NULL)
3741       {
3742       if (!expand_string_forcedfail)
3743         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3744           log_message, expand_string_message);
3745       }
3746     else if (expmessage[0] != 0)
3747       {
3748       *log_msgptr = (*log_msgptr == NULL)? expmessage :
3749         string_sprintf("%s: %s", expmessage, *log_msgptr);
3750       }
3751     }
3752
3753   /* If no log message, default it to the user message */
3754
3755   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
3756   }
3757
3758 acl_verify_message = NULL;
3759 return rc;
3760 }
3761
3762
3763
3764
3765
3766 /*************************************************
3767 *        Get line from a literal ACL             *
3768 *************************************************/
3769
3770 /* This function is passed to acl_read() in order to extract individual lines
3771 of a literal ACL, which we access via static pointers. We can destroy the
3772 contents because this is called only once (the compiled ACL is remembered).
3773
3774 This code is intended to treat the data in the same way as lines in the main
3775 Exim configuration file. That is:
3776
3777   . Leading spaces are ignored.
3778
3779   . A \ at the end of a line is a continuation - trailing spaces after the \
3780     are permitted (this is because I don't believe in making invisible things
3781     significant). Leading spaces on the continued part of a line are ignored.
3782
3783   . Physical lines starting (significantly) with # are totally ignored, and
3784     may appear within a sequence of backslash-continued lines.
3785
3786   . Blank lines are ignored, but will end a sequence of continuations.
3787
3788 Arguments: none
3789 Returns:   a pointer to the next line
3790 */
3791
3792
3793 static uschar *acl_text;          /* Current pointer in the text */
3794 static uschar *acl_text_end;      /* Points one past the terminating '0' */
3795
3796
3797 static uschar *
3798 acl_getline(void)
3799 {
3800 uschar *yield;
3801
3802 /* This loop handles leading blank lines and comments. */
3803
3804 for(;;)
3805   {
3806   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
3807   if (*acl_text == 0) return NULL;         /* No more data */
3808   yield = acl_text;                        /* Potential data line */
3809
3810   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3811
3812   /* If we hit the end before a newline, we have the whole logical line. If
3813   it's a comment, there's no more data to be given. Otherwise, yield it. */
3814
3815   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
3816
3817   /* After reaching a newline, end this loop if the physical line does not
3818   start with '#'. If it does, it's a comment, and the loop continues. */
3819
3820   if (*yield != '#') break;
3821   }
3822
3823 /* This loop handles continuations. We know we have some real data, ending in
3824 newline. See if there is a continuation marker at the end (ignoring trailing
3825 white space). We know that *yield is not white space, so no need to test for
3826 cont > yield in the backwards scanning loop. */
3827
3828 for(;;)
3829   {
3830   uschar *cont;
3831   for (cont = acl_text - 1; isspace(*cont); cont--);
3832
3833   /* If no continuation follows, we are done. Mark the end of the line and
3834   return it. */
3835
3836   if (*cont != '\\')
3837     {
3838     *acl_text++ = 0;
3839     return yield;
3840     }
3841
3842   /* We have encountered a continuation. Skip over whitespace at the start of
3843   the next line, and indeed the whole of the next line or lines if they are
3844   comment lines. */
3845
3846   for (;;)
3847     {
3848     while (*(++acl_text) == ' ' || *acl_text == '\t');
3849     if (*acl_text != '#') break;
3850     while (*(++acl_text) != 0 && *acl_text != '\n');
3851     }
3852
3853   /* We have the start of a continuation line. Move all the rest of the data
3854   to join onto the previous line, and then find its end. If the end is not a
3855   newline, we are done. Otherwise loop to look for another continuation. */
3856
3857   memmove(cont, acl_text, acl_text_end - acl_text);
3858   acl_text_end -= acl_text - cont;
3859   acl_text = cont;
3860   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3861   if (*acl_text == 0) return yield;
3862   }
3863
3864 /* Control does not reach here */
3865 }
3866
3867
3868
3869
3870
3871 /*************************************************
3872 *        Check access using an ACL               *
3873 *************************************************/
3874
3875 /* This function is called from address_check. It may recurse via
3876 acl_check_condition() - hence the use of a level to stop looping. The ACL is
3877 passed as a string which is expanded. A forced failure implies no access check
3878 is required. If the result is a single word, it is taken as the name of an ACL
3879 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
3880 text, complete with newlines, and parsed as such. In both cases, the ACL check
3881 is then run. This function uses an auxiliary function for acl_read() to call
3882 for reading individual lines of a literal ACL. This is acl_getline(), which
3883 appears immediately above.
3884
3885 Arguments:
3886   where        where called from
3887   addr         address item when called from RCPT; otherwise NULL
3888   s            the input string; NULL is the same as an empty ACL => DENY
3889   level        the nesting level
3890   user_msgptr  where to put a user error (for SMTP response)
3891   log_msgptr   where to put a logging message (not for SMTP response)
3892
3893 Returns:       OK         access is granted
3894                DISCARD    access is apparently granted...
3895                FAIL       access is denied
3896                FAIL_DROP  access is denied; drop the connection
3897                DEFER      can't tell at the moment
3898                ERROR      disaster
3899 */
3900
3901 static int
3902 acl_check_internal(int where, address_item *addr, uschar *s, int level,
3903   uschar **user_msgptr, uschar **log_msgptr)
3904 {
3905 int fd = -1;
3906 acl_block *acl = NULL;
3907 uschar *acl_name = US"inline ACL";
3908 uschar *ss;
3909
3910 /* Catch configuration loops */
3911
3912 if (level > 20)
3913   {
3914   *log_msgptr = US"ACL nested too deep: possible loop";
3915   return ERROR;
3916   }
3917
3918 if (s == NULL)
3919   {
3920   HDEBUG(D_acl) debug_printf("ACL is NULL: implicit DENY\n");
3921   return FAIL;
3922   }
3923
3924 /* At top level, we expand the incoming string. At lower levels, it has already
3925 been expanded as part of condition processing. */
3926
3927 if (level == 0)
3928   {
3929   ss = expand_string(s);
3930   if (ss == NULL)
3931     {
3932     if (expand_string_forcedfail) return OK;
3933     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
3934       expand_string_message);
3935     return ERROR;
3936     }
3937   }
3938 else ss = s;
3939
3940 while (isspace(*ss))ss++;
3941
3942 /* If we can't find a named ACL, the default is to parse it as an inline one.
3943 (Unless it begins with a slash; non-existent files give rise to an error.) */
3944
3945 acl_text = ss;
3946
3947 /* Handle the case of a string that does not contain any spaces. Look for a
3948 named ACL among those read from the configuration, or a previously read file.
3949 It is possible that the pointer to the ACL is NULL if the configuration
3950 contains a name with no data. If not found, and the text begins with '/',
3951 read an ACL from a file, and save it so it can be re-used. */
3952
3953 if (Ustrchr(ss, ' ') == NULL)
3954   {
3955   tree_node *t = tree_search(acl_anchor, ss);
3956   if (t != NULL)
3957     {
3958     acl = (acl_block *)(t->data.ptr);
3959     if (acl == NULL)
3960       {
3961       HDEBUG(D_acl) debug_printf("ACL \"%s\" is empty: implicit DENY\n", ss);
3962       return FAIL;
3963       }
3964     acl_name = string_sprintf("ACL \"%s\"", ss);
3965     HDEBUG(D_acl) debug_printf("using ACL \"%s\"\n", ss);
3966     }
3967
3968   else if (*ss == '/')
3969     {
3970     struct stat statbuf;
3971     fd = Uopen(ss, O_RDONLY, 0);
3972     if (fd < 0)
3973       {
3974       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
3975         strerror(errno));
3976       return ERROR;
3977       }
3978
3979     if (fstat(fd, &statbuf) != 0)
3980       {
3981       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
3982         strerror(errno));
3983       return ERROR;
3984       }
3985
3986     acl_text = store_get(statbuf.st_size + 1);
3987     acl_text_end = acl_text + statbuf.st_size + 1;
3988
3989     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
3990       {
3991       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
3992         ss, strerror(errno));
3993       return ERROR;
3994       }
3995     acl_text[statbuf.st_size] = 0;
3996     (void)close(fd);
3997
3998     acl_name = string_sprintf("ACL \"%s\"", ss);
3999     HDEBUG(D_acl) debug_printf("read ACL from file %s\n", ss);
4000     }
4001   }
4002
4003 /* Parse an ACL that is still in text form. If it came from a file, remember it
4004 in the ACL tree, having read it into the POOL_PERM store pool so that it
4005 persists between multiple messages. */
4006
4007 if (acl == NULL)
4008   {
4009   int old_pool = store_pool;
4010   if (fd >= 0) store_pool = POOL_PERM;
4011   acl = acl_read(acl_getline, log_msgptr);
4012   store_pool = old_pool;
4013   if (acl == NULL && *log_msgptr != NULL) return ERROR;
4014   if (fd >= 0)
4015     {
4016     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
4017     Ustrcpy(t->name, ss);
4018     t->data.ptr = acl;
4019     (void)tree_insertnode(&acl_anchor, t);
4020     }
4021   }
4022
4023 /* Now we have an ACL to use. It's possible it may be NULL. */
4024
4025 while (acl != NULL)
4026   {
4027   int cond;
4028   int basic_errno = 0;
4029   BOOL endpass_seen = FALSE;
4030
4031   *log_msgptr = *user_msgptr = NULL;
4032   acl_temp_details = FALSE;
4033
4034   if ((where == ACL_WHERE_QUIT || where == ACL_WHERE_NOTQUIT) &&
4035       acl->verb != ACL_ACCEPT &&
4036       acl->verb != ACL_WARN)
4037     {
4038     *log_msgptr = string_sprintf("\"%s\" is not allowed in a QUIT or not-QUIT ACL",
4039       verbs[acl->verb]);
4040     return ERROR;
4041     }
4042
4043   HDEBUG(D_acl) debug_printf("processing \"%s\"\n", verbs[acl->verb]);
4044
4045   /* Clear out any search error message from a previous check before testing
4046   this condition. */
4047
4048   search_error_message = NULL;
4049   cond = acl_check_condition(acl->verb, acl->condition, where, addr, level,
4050     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
4051
4052   /* Handle special returns: DEFER causes a return except on a WARN verb;
4053   ERROR always causes a return. */
4054
4055   switch (cond)
4056     {
4057     case DEFER:
4058     HDEBUG(D_acl) debug_printf("%s: condition test deferred in %s\n", verbs[acl->verb], acl_name);
4059     if (basic_errno != ERRNO_CALLOUTDEFER)
4060       {
4061       if (search_error_message != NULL && *search_error_message != 0)
4062         *log_msgptr = search_error_message;
4063       if (smtp_return_error_details) acl_temp_details = TRUE;
4064       }
4065     else
4066       {
4067       acl_temp_details = TRUE;
4068       }
4069     if (acl->verb != ACL_WARN) return DEFER;
4070     break;
4071
4072     default:      /* Paranoia */
4073     case ERROR:
4074     HDEBUG(D_acl) debug_printf("%s: condition test error in %s\n", verbs[acl->verb], acl_name);
4075     return ERROR;
4076
4077     case OK:
4078     HDEBUG(D_acl) debug_printf("%s: condition test succeeded in %s\n",
4079       verbs[acl->verb], acl_name);
4080     break;
4081
4082     case FAIL:
4083     HDEBUG(D_acl) debug_printf("%s: condition test failed in %s\n", verbs[acl->verb], acl_name);
4084     break;
4085
4086     /* DISCARD and DROP can happen only from a nested ACL condition, and
4087     DISCARD can happen only for an "accept" or "discard" verb. */
4088
4089     case DISCARD:
4090     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"discard\" in %s\n",
4091       verbs[acl->verb], acl_name);
4092     break;
4093
4094     case FAIL_DROP:
4095     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"drop\" in %s\n",
4096       verbs[acl->verb], acl_name);
4097     break;
4098     }
4099
4100   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
4101   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
4102   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
4103
4104   switch(acl->verb)
4105     {
4106     case ACL_ACCEPT:
4107     if (cond == OK || cond == DISCARD) return cond;
4108     if (endpass_seen)
4109       {
4110       HDEBUG(D_acl) debug_printf("accept: endpass encountered - denying access\n");
4111       return cond;
4112       }
4113     break;
4114
4115     case ACL_DEFER:
4116     if (cond == OK)
4117       {
4118       acl_temp_details = TRUE;
4119       return DEFER;
4120       }
4121     break;
4122
4123     case ACL_DENY:
4124     if (cond == OK) return FAIL;
4125     break;
4126
4127     case ACL_DISCARD:
4128     if (cond == OK || cond == DISCARD) return DISCARD;
4129     if (endpass_seen)
4130       {
4131       HDEBUG(D_acl) debug_printf("discard: endpass encountered - denying access\n");
4132       return cond;
4133       }
4134     break;
4135
4136     case ACL_DROP:
4137     if (cond == OK) return FAIL_DROP;
4138     break;
4139
4140     case ACL_REQUIRE:
4141     if (cond != OK) return cond;
4142     break;
4143
4144     case ACL_WARN:
4145     if (cond == OK)
4146       acl_warn(where, *user_msgptr, *log_msgptr);
4147     else if (cond == DEFER && (log_extra_selector & LX_acl_warn_skipped) != 0)
4148       log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
4149         "condition test deferred%s%s", host_and_ident(TRUE),
4150         (*log_msgptr == NULL)? US"" : US": ",
4151         (*log_msgptr == NULL)? US"" : *log_msgptr);
4152     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
4153     break;
4154
4155     default:
4156     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
4157       acl->verb);
4158     break;
4159     }
4160
4161   /* Pass to the next ACL item */
4162
4163   acl = acl->next;
4164   }
4165
4166 /* We have reached the end of the ACL. This is an implicit DENY. */
4167
4168 HDEBUG(D_acl) debug_printf("end of %s: implicit DENY\n", acl_name);
4169 return FAIL;
4170 }
4171
4172
4173
4174
4175 /* Same args as acl_check_internal() above, but the string s is
4176 the name of an ACL followed optionally by up to 9 space-separated arguments.
4177 The name and args are separately expanded.  Args go into $acl_arg globals. */
4178 static int
4179 acl_check_wargs(int where, address_item *addr, uschar *s, int level,
4180   uschar **user_msgptr, uschar **log_msgptr)
4181 {
4182 uschar * tmp;
4183 uschar * tmp_arg[9];    /* must match acl_arg[] */
4184 uschar * sav_arg[9];    /* must match acl_arg[] */
4185 int sav_narg;
4186 uschar * name;
4187 int i;
4188 int ret;
4189
4190 if (!(tmp = string_dequote(&s)) || !(name = expand_string(tmp)))
4191   goto bad;
4192
4193 for (i = 0; i < 9; i++)
4194   {
4195   while (*s && isspace(*s)) s++;
4196   if (!*s) break;
4197   if (!(tmp = string_dequote(&s)) || !(tmp_arg[i] = expand_string(tmp)))
4198     {
4199     tmp = name;
4200     goto bad;
4201     }
4202   }
4203
4204 sav_narg = acl_narg;
4205 acl_narg = i;
4206 for (i = 0; i < acl_narg; i++)
4207   {
4208   sav_arg[i] = acl_arg[i];
4209   acl_arg[i] = tmp_arg[i];
4210   }
4211 while (i < 9)
4212   {
4213   sav_arg[i] = acl_arg[i];
4214   acl_arg[i++] = NULL;
4215   }
4216
4217 ret = acl_check_internal(where, addr, name, level, user_msgptr, log_msgptr);
4218
4219 acl_narg = sav_narg;
4220 for (i = 0; i < 9; i++) acl_arg[i] = sav_arg[i];
4221 return ret;
4222
4223 bad:
4224 if (expand_string_forcedfail) return ERROR;
4225 *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
4226   tmp, expand_string_message);
4227 return search_find_defer?DEFER:ERROR;
4228 }
4229
4230
4231
4232 /*************************************************
4233 *        Check access using an ACL               *
4234 *************************************************/
4235
4236 /* Alternate interface for ACL, used by expansions */
4237 int
4238 acl_eval(int where, uschar *s, uschar **user_msgptr, uschar **log_msgptr)
4239 {
4240 address_item adb;
4241 address_item *addr = NULL;
4242
4243 *user_msgptr = *log_msgptr = NULL;
4244 sender_verified_failed = NULL;
4245 ratelimiters_cmd = NULL;
4246 log_reject_target = LOG_MAIN|LOG_REJECT;
4247
4248 if (where == ACL_WHERE_RCPT)
4249   {
4250   adb = address_defaults;
4251   addr = &adb;
4252   addr->address = expand_string(US"$local_part@$domain");
4253   addr->domain = deliver_domain;
4254   addr->local_part = deliver_localpart;
4255   addr->cc_local_part = deliver_localpart;
4256   addr->lc_local_part = deliver_localpart;
4257   }
4258
4259 return acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
4260 }
4261
4262
4263
4264 /* This is the external interface for ACL checks. It sets up an address and the
4265 expansions for $domain and $local_part when called after RCPT, then calls
4266 acl_check_internal() to do the actual work.
4267
4268 Arguments:
4269   where        ACL_WHERE_xxxx indicating where called from
4270   recipient    RCPT address for RCPT check, else NULL
4271   s            the input string; NULL is the same as an empty ACL => DENY
4272   user_msgptr  where to put a user error (for SMTP response)
4273   log_msgptr   where to put a logging message (not for SMTP response)
4274
4275 Returns:       OK         access is granted by an ACCEPT verb
4276                DISCARD    access is granted by a DISCARD verb
4277                FAIL       access is denied
4278                FAIL_DROP  access is denied; drop the connection
4279                DEFER      can't tell at the moment
4280                ERROR      disaster
4281 */
4282 int acl_where = ACL_WHERE_UNKNOWN;
4283
4284 int
4285 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
4286   uschar **log_msgptr)
4287 {
4288 int rc;
4289 address_item adb;
4290 address_item *addr = NULL;
4291
4292 *user_msgptr = *log_msgptr = NULL;
4293 sender_verified_failed = NULL;
4294 ratelimiters_cmd = NULL;
4295 log_reject_target = LOG_MAIN|LOG_REJECT;
4296
4297 #ifdef EXPERIMENTAL_PRDR
4298 if (where == ACL_WHERE_RCPT || where == ACL_WHERE_PRDR )
4299 #else
4300 if (where == ACL_WHERE_RCPT )
4301 #endif
4302   {
4303   adb = address_defaults;
4304   addr = &adb;
4305   addr->address = recipient;
4306   if (deliver_split_address(addr) == DEFER)
4307     {
4308     *log_msgptr = US"defer in percent_hack_domains check";
4309     return DEFER;
4310     }
4311   deliver_domain = addr->domain;
4312   deliver_localpart = addr->local_part;
4313   }
4314
4315 acl_where = where;
4316 rc = acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
4317 acl_where = ACL_WHERE_UNKNOWN;
4318
4319 /* Cutthrough - if requested,
4320 and WHERE_RCPT and not yet opened conn as result of recipient-verify,
4321 and rcpt acl returned accept,
4322 and first recipient (cancel on any subsequents)
4323 open one now and run it up to RCPT acceptance.
4324 A failed verify should cancel cutthrough request.
4325
4326 Initial implementation:  dual-write to spool.
4327 Assume the rxd datastream is now being copied byte-for-byte to an open cutthrough connection.
4328
4329 Cease cutthrough copy on rxd final dot; do not send one.
4330
4331 On a data acl, if not accept and a cutthrough conn is open, hard-close it (no SMTP niceness).
4332
4333 On data acl accept, terminate the dataphase on an open cutthrough conn.  If accepted or
4334 perm-rejected, reflect that to the original sender - and dump the spooled copy.
4335 If temp-reject, close the conn (and keep the spooled copy).
4336 If conn-failure, no action (and keep the spooled copy).
4337 */
4338 switch (where)
4339 {
4340 case ACL_WHERE_RCPT:
4341 #ifdef EXPERIMENTAL_PRDR
4342 case ACL_WHERE_PRDR:
4343 #endif
4344   if( rcpt_count > 1 )
4345     cancel_cutthrough_connection("more than one recipient");
4346   else if (rc == OK  &&  cutthrough_delivery  &&  cutthrough_fd < 0)
4347     open_cutthrough_connection(addr);
4348   break;
4349
4350 case ACL_WHERE_PREDATA:
4351   if( rc == OK )
4352     cutthrough_predata();
4353   else
4354     cancel_cutthrough_connection("predata acl not ok");
4355   break;
4356
4357 case ACL_WHERE_QUIT:
4358 case ACL_WHERE_NOTQUIT:
4359   cancel_cutthrough_connection("quit or notquit");
4360   break;
4361
4362 default:
4363   break;
4364 }
4365
4366 deliver_domain = deliver_localpart = deliver_address_data =
4367   sender_address_data = NULL;
4368
4369 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
4370 ACL, which is really in the middle of an SMTP command. */
4371
4372 if (rc == DISCARD)
4373   {
4374   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
4375     {
4376     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
4377       "ACL", acl_wherenames[where]);
4378     return ERROR;
4379     }
4380   return DISCARD;
4381   }
4382
4383 /* A DROP response is not permitted from MAILAUTH */
4384
4385 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
4386   {
4387   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
4388     "ACL", acl_wherenames[where]);
4389   return ERROR;
4390   }
4391
4392 /* Before giving a response, take a look at the length of any user message, and
4393 split it up into multiple lines if possible. */
4394
4395 *user_msgptr = string_split_message(*user_msgptr);
4396 if (fake_response != OK)
4397   fake_response_text = string_split_message(fake_response_text);
4398
4399 return rc;
4400 }
4401
4402
4403 /*************************************************
4404 *             Create ACL variable                *
4405 *************************************************/
4406
4407 /* Create an ACL variable or reuse an existing one. ACL variables are in a
4408 binary tree (see tree.c) with acl_var_c and acl_var_m as root nodes.
4409
4410 Argument:
4411   name    pointer to the variable's name, starting with c or m
4412
4413 Returns   the pointer to variable's tree node
4414 */
4415
4416 tree_node *
4417 acl_var_create(uschar *name)
4418 {
4419 tree_node *node, **root;
4420 root = (name[0] == 'c')? &acl_var_c : &acl_var_m;
4421 node = tree_search(*root, name);
4422 if (node == NULL)
4423   {
4424   node = store_get(sizeof(tree_node) + Ustrlen(name));
4425   Ustrcpy(node->name, name);
4426   (void)tree_insertnode(root, node);
4427   }
4428 node->data.ptr = NULL;
4429 return node;
4430 }
4431
4432
4433
4434 /*************************************************
4435 *       Write an ACL variable in spool format    *
4436 *************************************************/
4437
4438 /* This function is used as a callback for tree_walk when writing variables to
4439 the spool file. To retain spool file compatibility, what is written is -aclc or
4440 -aclm followed by the rest of the name and the data length, space separated,
4441 then the value itself, starting on a new line, and terminated by an additional
4442 newline. When we had only numbered ACL variables, the first line might look
4443 like this: "-aclc 5 20". Now it might be "-aclc foo 20" for the variable called
4444 acl_cfoo.
4445
4446 Arguments:
4447   name    of the variable
4448   value   of the variable
4449   ctx     FILE pointer (as a void pointer)
4450
4451 Returns:  nothing
4452 */
4453
4454 void
4455 acl_var_write(uschar *name, uschar *value, void *ctx)
4456 {
4457 FILE *f = (FILE *)ctx;
4458 fprintf(f, "-acl%c %s %d\n%s\n", name[0], name+1, Ustrlen(value), value);
4459 }
4460
4461 /* End of acl.c */