src/src/acl.c

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