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