src/src/acl.c

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