src/src/acl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
   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   if (rr_bad_size(rr, 3 * sizeof(uint16_t))) continue;
1438   GETSHORT(priority, p);
1439   GETSHORT(weight, p);
1440   GETSHORT(port, p);
1441
1442   DEBUG(D_acl)
1443     debug_printf_indent("CSA priority=%d weight=%d port=%d\n", priority, weight, port);
1444
1445   /* Check the CSA version number */
1446
1447   if (priority != 1) continue;
1448
1449   /* If the domain does not have a CSA SRV record of its own (i.e. the domain
1450   found by dns_special_lookup() is a parent of the one we asked for), we check
1451   the subdomain assertions in the port field. At the moment there's only one
1452   assertion: legitimate SMTP clients are all explicitly authorized with CSA
1453   SRV records of their own. */
1454
1455   if (Ustrcmp(found, domain) != 0)
1456     {
1457     yield = port & 1 ? CSA_FAIL_EXPLICIT : CSA_UNKNOWN;
1458     goto out;
1459     }
1460
1461   /* This CSA SRV record refers directly to our domain, so we check the value
1462   in the weight field to work out the domain's authorization. 0 and 1 are
1463   unauthorized; 3 means the client is authorized but we can't check the IP
1464   address in order to authenticate it, so we treat it as unknown; values
1465   greater than 3 are undefined. */
1466
1467   if (weight < 2)
1468     {
1469     yield = CSA_FAIL_DOMAIN;
1470     goto out;
1471     }
1472
1473   if (weight > 2) continue;
1474
1475   /* Weight == 2, which means the domain is authorized. We must check that the
1476   client's IP address is listed as one of the SRV target addresses. Save the
1477   target hostname then break to scan the additional data for its addresses. */
1478
1479   (void)dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, p,
1480     (DN_EXPAND_ARG4_TYPE)target, TARGET_SIZE);
1481
1482   DEBUG(D_acl) debug_printf_indent("CSA target is %s\n", target);
1483
1484   break;
1485   }
1486
1487 /* If we didn't break the loop then no appropriate records were found. */
1488
1489 if (!rr)
1490   {
1491   yield = CSA_UNKNOWN;
1492   goto out;
1493   }
1494
1495 /* Do not check addresses if the target is ".", in accordance with RFC 2782.
1496 A target of "." indicates there are no valid addresses, so the client cannot
1497 be authorized. (This is an odd configuration because weight=2 target=. is
1498 equivalent to weight=1, but we check for it in order to keep load off the
1499 root name servers.) Note that dn_expand() turns "." into "". */
1500
1501 if (Ustrcmp(target, "") == 0)
1502   {
1503   yield = CSA_FAIL_NOADDR;
1504   goto out;
1505   }
1506
1507 /* Scan the additional section of the CSA SRV reply for addresses belonging
1508 to the target. If the name server didn't return any additional data (e.g.
1509 because it does not fully support SRV records), we need to do another lookup
1510 to obtain the target addresses; otherwise we have a definitive result. */
1511
1512 rc = acl_verify_csa_address(dnsa, &dnss, RESET_ADDITIONAL, target);
1513 if (rc != CSA_FAIL_NOADDR)
1514   {
1515   yield = rc;
1516   goto out;
1517   }
1518
1519 /* The DNS lookup type corresponds to the IP version used by the client. */
1520
1521 #if HAVE_IPV6
1522 if (Ustrchr(sender_host_address, ':') != NULL)
1523   type = T_AAAA;
1524 else
1525 #endif /* HAVE_IPV6 */
1526   type = T_A;
1527
1528
1529 lookup_dnssec_authenticated = NULL;
1530 switch (dns_lookup(dnsa, target, type, NULL))
1531   {
1532   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1533
1534   default:
1535     yield = CSA_DEFER_ADDR;
1536     break;
1537
1538   /* If the query succeeded, scan the addresses and return the result. */
1539
1540   case DNS_SUCCEED:
1541     rc = acl_verify_csa_address(dnsa, &dnss, RESET_ANSWERS, target);
1542     if (rc != CSA_FAIL_NOADDR)
1543       {
1544       yield = rc;
1545       break;
1546       }
1547     /* else fall through */
1548
1549   /* If the target has no IP addresses, the client cannot have an authorized
1550   IP address. However, if the target site uses A6 records (not AAAA records)
1551   we have to do yet another lookup in order to check them. */
1552
1553   case DNS_NOMATCH:
1554   case DNS_NODATA:
1555     yield = CSA_FAIL_NOADDR;
1556     break;
1557   }
1558
1559 out:
1560
1561 store_free_dns_answer(dnsa);
1562 return t->data.val = yield;
1563 }
1564
1565
1566
1567 /*************************************************
1568 *     Handle verification (address & other)      *
1569 *************************************************/
1570
1571 enum { VERIFY_REV_HOST_LKUP, VERIFY_CERT, VERIFY_HELO, VERIFY_CSA, VERIFY_HDR_SYNTAX,
1572        VERIFY_NOT_BLIND, VERIFY_HDR_SNDR, VERIFY_SNDR, VERIFY_RCPT,
1573        VERIFY_HDR_NAMES_ASCII, VERIFY_ARC
1574   };
1575 typedef struct {
1576   uschar * name;
1577   int      value;
1578   unsigned where_allowed;       /* bitmap */
1579   BOOL     no_options;          /* Never has /option(s) following */
1580   unsigned alt_opt_sep;         /* >0 Non-/ option separator (custom parser) */
1581   } verify_type_t;
1582 static verify_type_t verify_type_list[] = {
1583     /*  name                    value                   where           no-opt opt-sep */
1584     { US"reverse_host_lookup",  VERIFY_REV_HOST_LKUP,   (unsigned)~0,   FALSE, 0 },
1585     { US"certificate",          VERIFY_CERT,            (unsigned)~0,   TRUE,  0 },
1586     { US"helo",                 VERIFY_HELO,            (unsigned)~0,   TRUE,  0 },
1587     { US"csa",                  VERIFY_CSA,             (unsigned)~0,   FALSE, 0 },
1588     { US"header_syntax",        VERIFY_HDR_SYNTAX,      ACL_BITS_HAVEDATA, TRUE, 0 },
1589     { US"not_blind",            VERIFY_NOT_BLIND,       ACL_BITS_HAVEDATA, FALSE, 0 },
1590     { US"header_sender",        VERIFY_HDR_SNDR,        ACL_BITS_HAVEDATA, FALSE, 0 },
1591     { US"sender",               VERIFY_SNDR,            ACL_BIT_MAIL | ACL_BIT_RCPT
1592                         | ACL_BIT_PREDATA | ACL_BIT_DATA | ACL_BIT_NOTSMTP,
1593                                                                                 FALSE, 6 },
1594     { US"recipient",            VERIFY_RCPT,            ACL_BIT_RCPT,   FALSE, 0 },
1595     { US"header_names_ascii",   VERIFY_HDR_NAMES_ASCII, ACL_BITS_HAVEDATA, TRUE, 0 },
1596 #ifdef EXPERIMENTAL_ARC
1597     { US"arc",                  VERIFY_ARC,             ACL_BIT_DATA,   FALSE , 0 },
1598 #endif
1599   };
1600
1601
1602 enum { CALLOUT_DEFER_OK, CALLOUT_NOCACHE, CALLOUT_RANDOM, CALLOUT_USE_SENDER,
1603   CALLOUT_USE_POSTMASTER, CALLOUT_POSTMASTER, CALLOUT_FULLPOSTMASTER,
1604   CALLOUT_MAILFROM, CALLOUT_POSTMASTER_MAILFROM, CALLOUT_MAXWAIT, CALLOUT_CONNECT,
1605   CALLOUT_HOLD, CALLOUT_TIME    /* TIME must be last */
1606   };
1607 typedef struct {
1608   uschar * name;
1609   int      value;
1610   int      flag;
1611   BOOL     has_option;  /* Has =option(s) following */
1612   BOOL     timeval;     /* Has a time value */
1613   } callout_opt_t;
1614 static callout_opt_t callout_opt_list[] = {
1615     /*  name                    value                   flag            has-opt         has-time */
1616     { US"defer_ok",       CALLOUT_DEFER_OK,      0,                             FALSE, FALSE },
1617     { US"no_cache",       CALLOUT_NOCACHE,       vopt_callout_no_cache,         FALSE, FALSE },
1618     { US"random",         CALLOUT_RANDOM,        vopt_callout_random,           FALSE, FALSE },
1619     { US"use_sender",     CALLOUT_USE_SENDER,    vopt_callout_recipsender,      FALSE, FALSE },
1620     { US"use_postmaster", CALLOUT_USE_POSTMASTER,vopt_callout_recippmaster,     FALSE, FALSE },
1621     { US"postmaster_mailfrom",CALLOUT_POSTMASTER_MAILFROM,0,                    TRUE,  FALSE },
1622     { US"postmaster",     CALLOUT_POSTMASTER,    0,                             FALSE, FALSE },
1623     { US"fullpostmaster", CALLOUT_FULLPOSTMASTER,vopt_callout_fullpm,           FALSE, FALSE },
1624     { US"mailfrom",       CALLOUT_MAILFROM,      0,                             TRUE,  FALSE },
1625     { US"maxwait",        CALLOUT_MAXWAIT,       0,                             TRUE,  TRUE },
1626     { US"connect",        CALLOUT_CONNECT,       0,                             TRUE,  TRUE },
1627     { US"hold",           CALLOUT_HOLD,          vopt_callout_hold,             FALSE, FALSE },
1628     { NULL,               CALLOUT_TIME,          0,                             FALSE, TRUE }
1629   };
1630
1631
1632
1633 static int
1634 v_period(const uschar * s, const uschar * arg, uschar ** log_msgptr)
1635 {
1636 int period;
1637 if ((period = readconf_readtime(s, 0, FALSE)) < 0)
1638   {
1639   *log_msgptr = string_sprintf("bad time value in ACL condition "
1640     "\"verify %s\"", arg);
1641   }
1642 return period;
1643 }
1644
1645
1646
1647 static BOOL
1648 sender_helo_verified_internal(void)
1649 {
1650 /* We can test the result of optional HELO verification that might have
1651 occurred earlier. If not, we can attempt the verification now. */
1652
1653 if (!f.helo_verified && !f.helo_verify_failed) smtp_verify_helo();
1654 return f.helo_verified;
1655 }
1656
1657 static int
1658 sender_helo_verified_cond(void)
1659 {
1660 return sender_helo_verified_internal() ? OK : FAIL;
1661 }
1662
1663 uschar *
1664 sender_helo_verified_boolstr(void)
1665 {
1666 return sender_helo_verified_internal() ? US"yes" : US"no";
1667 }
1668
1669
1670
1671 /* This function implements the "verify" condition. It is called when
1672 encountered in any ACL, because some tests are almost always permitted. Some
1673 just don't make sense, and always fail (for example, an attempt to test a host
1674 lookup for a non-TCP/IP message). Others are restricted to certain ACLs.
1675
1676 Arguments:
1677   where        where called from
1678   addr         the recipient address that the ACL is handling, or NULL
1679   arg          the argument of "verify"
1680   user_msgptr  pointer for user message
1681   log_msgptr   pointer for log message
1682   basic_errno  where to put verify errno
1683
1684 Returns:       OK        verification condition succeeded
1685                FAIL      verification failed
1686                DEFER     there was a problem verifying
1687                ERROR     syntax error
1688 */
1689
1690 static int
1691 acl_verify(int where, address_item *addr, const uschar *arg,
1692   uschar **user_msgptr, uschar **log_msgptr, int *basic_errno)
1693 {
1694 int sep = '/';
1695 int callout = -1;
1696 int callout_overall = -1;
1697 int callout_connect = -1;
1698 int verify_options = 0;
1699 int rc;
1700 BOOL verify_header_sender = FALSE;
1701 BOOL defer_ok = FALSE;
1702 BOOL callout_defer_ok = FALSE;
1703 BOOL no_details = FALSE;
1704 BOOL success_on_redirect = FALSE;
1705 BOOL quota = FALSE;
1706 int quota_pos_cache = QUOTA_POS_DEFAULT, quota_neg_cache = QUOTA_NEG_DEFAULT;
1707 address_item *sender_vaddr = NULL;
1708 uschar *verify_sender_address = NULL;
1709 uschar *pm_mailfrom = NULL;
1710 uschar *se_mailfrom = NULL;
1711
1712 /* Some of the verify items have slash-separated options; some do not. Diagnose
1713 an error if options are given for items that don't expect them.
1714 */
1715
1716 uschar *slash = Ustrchr(arg, '/');
1717 const uschar *list = arg;
1718 uschar *ss = string_nextinlist(&list, &sep, NULL, 0);
1719 verify_type_t * vp;
1720
1721 if (!ss) goto BAD_VERIFY;
1722
1723 /* Handle name/address consistency verification in a separate function. */
1724
1725 for (vp = verify_type_list;
1726      CS vp < CS verify_type_list + sizeof(verify_type_list);
1727      vp++
1728     )
1729   if (vp->alt_opt_sep ? strncmpic(ss, vp->name, vp->alt_opt_sep) == 0
1730                       : strcmpic (ss, vp->name) == 0)
1731    break;
1732 if (CS vp >= CS verify_type_list + sizeof(verify_type_list))
1733   goto BAD_VERIFY;
1734
1735 if (vp->no_options && slash)
1736   {
1737   *log_msgptr = string_sprintf("unexpected '/' found in \"%s\" "
1738     "(this verify item has no options)", arg);
1739   return ERROR;
1740   }
1741 if (!(vp->where_allowed & BIT(where)))
1742   {
1743   *log_msgptr = string_sprintf("cannot verify %s in ACL for %s",
1744                   vp->name, acl_wherenames[where]);
1745   return ERROR;
1746   }
1747 switch(vp->value)
1748   {
1749   case VERIFY_REV_HOST_LKUP:
1750     if (!sender_host_address) return OK;
1751     if ((rc = acl_verify_reverse(user_msgptr, log_msgptr)) == DEFER)
1752       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
1753         if (strcmpic(ss, US"defer_ok") == 0)
1754           return OK;
1755     return rc;
1756
1757   case VERIFY_CERT:
1758     /* TLS certificate verification is done at STARTTLS time; here we just
1759     test whether it was successful or not. (This is for optional verification; for
1760     mandatory verification, the connection doesn't last this long.) */
1761
1762     if (tls_in.certificate_verified) return OK;
1763     *user_msgptr = US"no verified certificate";
1764     return FAIL;
1765
1766   case VERIFY_HELO:
1767     return sender_helo_verified_cond();
1768
1769   case VERIFY_CSA:
1770     /* Do Client SMTP Authorization checks in a separate function, and turn the
1771     result code into user-friendly strings. */
1772
1773     rc = acl_verify_csa(list);
1774     *log_msgptr = *user_msgptr = string_sprintf("client SMTP authorization %s",
1775                                               csa_reason_string[rc]);
1776     csa_status = csa_status_string[rc];
1777     DEBUG(D_acl) debug_printf_indent("CSA result %s\n", csa_status);
1778     return csa_return_code[rc];
1779
1780 #ifdef EXPERIMENTAL_ARC
1781   case VERIFY_ARC:
1782     {   /* Do Authenticated Received Chain checks in a separate function. */
1783     const uschar * condlist = CUS string_nextinlist(&list, &sep, NULL, 0);
1784     int csep = 0;
1785     uschar * cond;
1786
1787     if (!(arc_state = acl_verify_arc())) return DEFER;
1788     DEBUG(D_acl) debug_printf_indent("ARC verify result %s %s%s%s\n", arc_state,
1789       arc_state_reason ? "(":"", arc_state_reason, arc_state_reason ? ")":"");
1790
1791     if (!condlist) condlist = US"none:pass";
1792     while ((cond = string_nextinlist(&condlist, &csep, NULL, 0)))
1793       if (Ustrcmp(arc_state, cond) == 0) return OK;
1794     return FAIL;
1795     }
1796 #endif
1797
1798   case VERIFY_HDR_SYNTAX:
1799     /* Check that all relevant header lines have the correct 5322-syntax. If there is
1800     a syntax error, we return details of the error to the sender if configured to
1801     send out full details. (But a "message" setting on the ACL can override, as
1802     always). */
1803
1804     rc = verify_check_headers(log_msgptr);
1805     if (rc != OK && *log_msgptr)
1806       if (smtp_return_error_details)
1807         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1808       else
1809         acl_verify_message = *log_msgptr;
1810     return rc;
1811
1812   case VERIFY_HDR_NAMES_ASCII:
1813     /* Check that all header names are true 7 bit strings
1814     See RFC 5322, 2.2. and RFC 6532, 3. */
1815
1816     rc = verify_check_header_names_ascii(log_msgptr);
1817     if (rc != OK && smtp_return_error_details && *log_msgptr)
1818       *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1819     return rc;
1820
1821   case VERIFY_NOT_BLIND:
1822     /* Check that no recipient of this message is "blind", that is, every envelope
1823     recipient must be mentioned in either To: or Cc:. */
1824     {
1825     BOOL case_sensitive = TRUE;
1826
1827     while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
1828       if (strcmpic(ss, US"case_insensitive") == 0)
1829         case_sensitive = FALSE;
1830       else
1831         {
1832         *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
1833            "condition \"verify %s\"", ss, arg);
1834         return ERROR;
1835         }
1836
1837     if ((rc = verify_check_notblind(case_sensitive)) != OK)
1838       {
1839       *log_msgptr = US"bcc recipient detected";
1840       if (smtp_return_error_details)
1841         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1842       }
1843     return rc;
1844     }
1845
1846   /* The remaining verification tests check recipient and sender addresses,
1847   either from the envelope or from the header. There are a number of
1848   slash-separated options that are common to all of them. */
1849
1850   case VERIFY_HDR_SNDR:
1851     verify_header_sender = TRUE;
1852     break;
1853
1854   case VERIFY_SNDR:
1855     /* In the case of a sender, this can optionally be followed by an address to use
1856     in place of the actual sender (rare special-case requirement). */
1857     {
1858     uschar *s = ss + 6;
1859     if (!*s)
1860       verify_sender_address = sender_address;
1861     else
1862       {
1863       while (isspace(*s)) s++;
1864       if (*s++ != '=') goto BAD_VERIFY;
1865       while (isspace(*s)) s++;
1866       verify_sender_address = string_copy(s);
1867       }
1868     }
1869     break;
1870
1871   case VERIFY_RCPT:
1872     break;
1873   }
1874
1875
1876
1877 /* Remaining items are optional; they apply to sender and recipient
1878 verification, including "header sender" verification. */
1879
1880 while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
1881   {
1882   if (strcmpic(ss, US"defer_ok") == 0) defer_ok = TRUE;
1883   else if (strcmpic(ss, US"no_details") == 0) no_details = TRUE;
1884   else if (strcmpic(ss, US"success_on_redirect") == 0) success_on_redirect = TRUE;
1885
1886   /* These two old options are left for backwards compatibility */
1887
1888   else if (strcmpic(ss, US"callout_defer_ok") == 0)
1889     {
1890     callout_defer_ok = TRUE;
1891     if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1892     }
1893
1894   else if (strcmpic(ss, US"check_postmaster") == 0)
1895      {
1896      pm_mailfrom = US"";
1897      if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1898      }
1899
1900   /* The callout option has a number of sub-options, comma separated */
1901
1902   else if (strncmpic(ss, US"callout", 7) == 0)
1903     {
1904     callout = CALLOUT_TIMEOUT_DEFAULT;
1905     if (*(ss += 7))
1906       {
1907       while (isspace(*ss)) ss++;
1908       if (*ss++ == '=')
1909         {
1910         const uschar * sublist = ss;
1911         int optsep = ',';
1912
1913         while (isspace(*sublist)) sublist++;
1914         for (uschar * opt; opt = string_nextinlist(&sublist, &optsep, NULL, 0); )
1915           {
1916           callout_opt_t * op;
1917           double period = 1.0F;
1918
1919           for (op= callout_opt_list; op->name; op++)
1920             if (strncmpic(opt, op->name, Ustrlen(op->name)) == 0)
1921               break;
1922
1923           verify_options |= op->flag;
1924           if (op->has_option)
1925             {
1926             opt += Ustrlen(op->name);
1927             while (isspace(*opt)) opt++;
1928             if (*opt++ != '=')
1929               {
1930               *log_msgptr = string_sprintf("'=' expected after "
1931                 "\"%s\" in ACL verify condition \"%s\"", op->name, arg);
1932               return ERROR;
1933               }
1934             while (isspace(*opt)) opt++;
1935             }
1936           if (op->timeval && (period = v_period(opt, arg, log_msgptr)) < 0)
1937             return ERROR;
1938
1939           switch(op->value)
1940             {
1941             case CALLOUT_DEFER_OK:              callout_defer_ok = TRUE; break;
1942             case CALLOUT_POSTMASTER:            pm_mailfrom = US"";     break;
1943             case CALLOUT_FULLPOSTMASTER:        pm_mailfrom = US"";     break;
1944             case CALLOUT_MAILFROM:
1945               if (!verify_header_sender)
1946                 {
1947                 *log_msgptr = string_sprintf("\"mailfrom\" is allowed as a "
1948                   "callout option only for verify=header_sender (detected in ACL "
1949                   "condition \"%s\")", arg);
1950                 return ERROR;
1951                 }
1952               se_mailfrom = string_copy(opt);
1953               break;
1954             case CALLOUT_POSTMASTER_MAILFROM:   pm_mailfrom = string_copy(opt); break;
1955             case CALLOUT_MAXWAIT:               callout_overall = period;       break;
1956             case CALLOUT_CONNECT:               callout_connect = period;       break;
1957             case CALLOUT_TIME:                  callout = period;               break;
1958             }
1959           }
1960         }
1961       else
1962         {
1963         *log_msgptr = string_sprintf("'=' expected after \"callout\" in "
1964           "ACL condition \"%s\"", arg);
1965         return ERROR;
1966         }
1967       }
1968     }
1969
1970   /* The quota option has sub-options, comma-separated */
1971
1972   else if (strncmpic(ss, US"quota", 5) == 0)
1973     {
1974     quota = TRUE;
1975     if (*(ss += 5))
1976       {
1977       while (isspace(*ss)) ss++;
1978       if (*ss++ == '=')
1979         {
1980         const uschar * sublist = ss;
1981         int optsep = ',';
1982         int period;
1983
1984         while (isspace(*sublist)) sublist++;
1985         for (uschar * opt; opt = string_nextinlist(&sublist, &optsep, NULL, 0); )
1986           if (Ustrncmp(opt, "cachepos=", 9) == 0)
1987             if ((period = v_period(opt += 9, arg, log_msgptr)) < 0)
1988               return ERROR;
1989             else
1990               quota_pos_cache = period;
1991           else if (Ustrncmp(opt, "cacheneg=", 9) == 0)
1992             if ((period = v_period(opt += 9, arg, log_msgptr)) < 0)
1993               return ERROR;
1994             else
1995               quota_neg_cache = period;
1996           else if (Ustrcmp(opt, "no_cache") == 0)
1997             quota_pos_cache = quota_neg_cache = 0;
1998         }
1999       }
2000     }
2001
2002   /* Option not recognized */
2003
2004   else
2005     {
2006     *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
2007       "condition \"verify %s\"", ss, arg);
2008     return ERROR;
2009     }
2010   }
2011
2012 if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)) ==
2013       (vopt_callout_recipsender|vopt_callout_recippmaster))
2014   {
2015   *log_msgptr = US"only one of use_sender and use_postmaster can be set "
2016     "for a recipient callout";
2017   return ERROR;
2018   }
2019
2020 /* Handle quota verification */
2021 if (quota)
2022   {
2023   if (vp->value != VERIFY_RCPT)
2024     {
2025     *log_msgptr = US"can only verify quota of recipient";
2026     return ERROR;
2027     }
2028
2029   if ((rc = verify_quota_call(addr->address,
2030               quota_pos_cache, quota_neg_cache, log_msgptr)) != OK)
2031     {
2032     *basic_errno = errno;
2033     if (smtp_return_error_details)
2034       {
2035       if (!*user_msgptr && *log_msgptr)
2036         *user_msgptr = string_sprintf("Rejected after %s: %s",
2037             smtp_names[smtp_connection_had[SMTP_HBUFF_PREV(smtp_ch_index)]],
2038             *log_msgptr);
2039       if (rc == DEFER) f.acl_temp_details = TRUE;
2040       }
2041     }
2042
2043   return rc;
2044   }
2045
2046 /* Handle sender-in-header verification. Default the user message to the log
2047 message if giving out verification details. */
2048
2049 if (verify_header_sender)
2050   {
2051   int verrno;
2052
2053   if ((rc = verify_check_header_address(user_msgptr, log_msgptr, callout,
2054     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, verify_options,
2055     &verrno)) != OK)
2056     {
2057     *basic_errno = verrno;
2058     if (smtp_return_error_details)
2059       {
2060       if (!*user_msgptr && *log_msgptr)
2061         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
2062       if (rc == DEFER) f.acl_temp_details = TRUE;
2063       }
2064     }
2065   }
2066
2067 /* Handle a sender address. The default is to verify *the* sender address, but
2068 optionally a different address can be given, for special requirements. If the
2069 address is empty, we are dealing with a bounce message that has no sender, so
2070 we cannot do any checking. If the real sender address gets rewritten during
2071 verification (e.g. DNS widening), set the flag to stop it being rewritten again
2072 during message reception.
2073
2074 A list of verified "sender" addresses is kept to try to avoid doing to much
2075 work repetitively when there are multiple recipients in a message and they all
2076 require sender verification. However, when callouts are involved, it gets too
2077 complicated because different recipients may require different callout options.
2078 Therefore, we always do a full sender verify when any kind of callout is
2079 specified. Caching elsewhere, for instance in the DNS resolver and in the
2080 callout handling, should ensure that this is not terribly inefficient. */
2081
2082 else if (verify_sender_address)
2083   {
2084   if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)))
2085     {
2086     *log_msgptr = US"use_sender or use_postmaster cannot be used for a "
2087       "sender verify callout";
2088     return ERROR;
2089     }
2090
2091   sender_vaddr = verify_checked_sender(verify_sender_address);
2092   if (   sender_vaddr                           /* Previously checked */
2093       && callout <= 0)                          /* No callout needed this time */
2094     {
2095     /* If the "routed" flag is set, it means that routing worked before, so
2096     this check can give OK (the saved return code value, if set, belongs to a
2097     callout that was done previously). If the "routed" flag is not set, routing
2098     must have failed, so we use the saved return code. */
2099
2100     if (testflag(sender_vaddr, af_verify_routed))
2101       rc = OK;
2102     else
2103       {
2104       rc = sender_vaddr->special_action;
2105       *basic_errno = sender_vaddr->basic_errno;
2106       }
2107     HDEBUG(D_acl) debug_printf_indent("using cached sender verify result\n");
2108     }
2109
2110   /* Do a new verification, and cache the result. The cache is used to avoid
2111   verifying the sender multiple times for multiple RCPTs when callouts are not
2112   specified (see comments above).
2113
2114   The cache is also used on failure to give details in response to the first
2115   RCPT that gets bounced for this reason. However, this can be suppressed by
2116   the no_details option, which sets the flag that says "this detail has already
2117   been sent". The cache normally contains just one address, but there may be
2118   more in esoteric circumstances. */
2119
2120   else
2121     {
2122     BOOL routed = TRUE;
2123     uschar *save_address_data = deliver_address_data;
2124
2125     sender_vaddr = deliver_make_addr(verify_sender_address, TRUE);
2126 #ifdef SUPPORT_I18N
2127     if ((sender_vaddr->prop.utf8_msg = message_smtputf8))
2128       {
2129       sender_vaddr->prop.utf8_downcvt =       message_utf8_downconvert == 1;
2130       sender_vaddr->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
2131       }
2132 #endif
2133     if (no_details) setflag(sender_vaddr, af_sverify_told);
2134     if (verify_sender_address[0] != 0)
2135       {
2136       /* If this is the real sender address, save the unrewritten version
2137       for use later in receive. Otherwise, set a flag so that rewriting the
2138       sender in verify_address() does not update sender_address. */
2139
2140       if (verify_sender_address == sender_address)
2141         sender_address_unrewritten = sender_address;
2142       else
2143         verify_options |= vopt_fake_sender;
2144
2145       if (success_on_redirect)
2146         verify_options |= vopt_success_on_redirect;
2147
2148       /* The recipient, qualify, and expn options are never set in
2149       verify_options. */
2150
2151       rc = verify_address(sender_vaddr, NULL, verify_options, callout,
2152         callout_overall, callout_connect, se_mailfrom, pm_mailfrom, &routed);
2153
2154       HDEBUG(D_acl) debug_printf_indent("----------- end verify ------------\n");
2155
2156       if (rc != OK)
2157         *basic_errno = sender_vaddr->basic_errno;
2158       else
2159         DEBUG(D_acl)
2160           if (Ustrcmp(sender_vaddr->address, verify_sender_address) != 0)
2161             debug_printf_indent("sender %s verified ok as %s\n",
2162               verify_sender_address, sender_vaddr->address);
2163           else
2164             debug_printf_indent("sender %s verified ok\n",
2165               verify_sender_address);
2166       }
2167     else
2168       rc = OK;  /* Null sender */
2169
2170     /* Cache the result code */
2171
2172     if (routed) setflag(sender_vaddr, af_verify_routed);
2173     if (callout > 0) setflag(sender_vaddr, af_verify_callout);
2174     sender_vaddr->special_action = rc;
2175     sender_vaddr->next = sender_verified_list;
2176     sender_verified_list = sender_vaddr;
2177
2178     /* Restore the recipient address data, which might have been clobbered by
2179     the sender verification. */
2180
2181     deliver_address_data = save_address_data;
2182     }
2183
2184   /* Put the sender address_data value into $sender_address_data */
2185
2186   sender_address_data = sender_vaddr->prop.address_data;
2187   }
2188
2189 /* A recipient address just gets a straightforward verify; again we must handle
2190 the DEFER overrides. */
2191
2192 else
2193   {
2194   address_item addr2;
2195
2196   if (success_on_redirect)
2197     verify_options |= vopt_success_on_redirect;
2198
2199   /* We must use a copy of the address for verification, because it might
2200   get rewritten. */
2201
2202   addr2 = *addr;
2203   rc = verify_address(&addr2, NULL, verify_options|vopt_is_recipient, callout,
2204     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, NULL);
2205   HDEBUG(D_acl) debug_printf_indent("----------- end verify ------------\n");
2206
2207   *basic_errno = addr2.basic_errno;
2208   *log_msgptr = addr2.message;
2209   *user_msgptr = addr2.user_message ? addr2.user_message : addr2.message;
2210
2211   /* Allow details for temporary error if the address is so flagged. */
2212   if (testflag((&addr2), af_pass_message)) f.acl_temp_details = TRUE;
2213
2214   /* Make $address_data visible */
2215   deliver_address_data = addr2.prop.address_data;
2216   }
2217
2218 /* We have a result from the relevant test. Handle defer overrides first. */
2219
2220 if (  rc == DEFER
2221    && (  defer_ok
2222       || callout_defer_ok && *basic_errno == ERRNO_CALLOUTDEFER
2223    )  )
2224   {
2225   HDEBUG(D_acl) debug_printf_indent("verify defer overridden by %s\n",
2226     defer_ok? "defer_ok" : "callout_defer_ok");
2227   rc = OK;
2228   }
2229
2230 /* If we've failed a sender, set up a recipient message, and point
2231 sender_verified_failed to the address item that actually failed. */
2232
2233 if (rc != OK && verify_sender_address)
2234   {
2235   if (rc != DEFER)
2236     *log_msgptr = *user_msgptr = US"Sender verify failed";
2237   else if (*basic_errno != ERRNO_CALLOUTDEFER)
2238     *log_msgptr = *user_msgptr = US"Could not complete sender verify";
2239   else
2240     {
2241     *log_msgptr = US"Could not complete sender verify callout";
2242     *user_msgptr = smtp_return_error_details? sender_vaddr->user_message :
2243       *log_msgptr;
2244     }
2245
2246   sender_verified_failed = sender_vaddr;
2247   }
2248
2249 /* Verifying an address messes up the values of $domain and $local_part,
2250 so reset them before returning if this is a RCPT ACL. */
2251
2252 if (addr)
2253   {
2254   deliver_domain = addr->domain;
2255   deliver_localpart = addr->local_part;
2256   }
2257 return rc;
2258
2259 /* Syntax errors in the verify argument come here. */
2260
2261 BAD_VERIFY:
2262 *log_msgptr = string_sprintf("expected \"sender[=address]\", \"recipient\", "
2263   "\"helo\", \"header_syntax\", \"header_sender\", \"header_names_ascii\" "
2264   "or \"reverse_host_lookup\" at start of ACL condition "
2265   "\"verify %s\"", arg);
2266 return ERROR;
2267 }
2268
2269
2270
2271
2272 /*************************************************
2273 *        Check argument for control= modifier    *
2274 *************************************************/
2275
2276 /* Called from acl_check_condition() below.
2277 To handle the case "queue_only" we accept an _ in the
2278 initial / option-switch position.
2279
2280 Arguments:
2281   arg         the argument string for control=
2282   pptr        set to point to the terminating character
2283   where       which ACL we are in
2284   log_msgptr  for error messages
2285
2286 Returns:      CONTROL_xxx value
2287 */
2288
2289 static int
2290 decode_control(const uschar *arg, const uschar **pptr, int where, uschar **log_msgptr)
2291 {
2292 int idx, len;
2293 control_def * d;
2294 uschar c;
2295
2296 if (  (idx = find_control(arg, controls_list, nelem(controls_list))) < 0
2297    || (  (c = arg[len = Ustrlen((d = controls_list+idx)->name)]) != 0
2298       && (!d->has_option || c != '/' && c != '_')
2299    )  )
2300   {
2301   *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
2302   return CONTROL_ERROR;
2303   }
2304
2305 *pptr = arg + len;
2306 return idx;
2307 }
2308
2309
2310
2311
2312 /*************************************************
2313 *        Return a ratelimit error                *
2314 *************************************************/
2315
2316 /* Called from acl_ratelimit() below
2317
2318 Arguments:
2319   log_msgptr  for error messages
2320   format      format string
2321   ...         supplementary arguments
2322
2323 Returns:      ERROR
2324 */
2325
2326 static int
2327 ratelimit_error(uschar **log_msgptr, const char *format, ...)
2328 {
2329 va_list ap;
2330 gstring * g =
2331   string_cat(NULL, US"error in arguments to \"ratelimit\" condition: ");
2332
2333 va_start(ap, format);
2334 g = string_vformat(g, SVFMT_EXTEND|SVFMT_REBUFFER, format, ap);
2335 va_end(ap);
2336
2337 gstring_release_unused(g);
2338 *log_msgptr = string_from_gstring(g);
2339 return ERROR;
2340 }
2341
2342
2343
2344
2345 /*************************************************
2346 *            Handle rate limiting                *
2347 *************************************************/
2348
2349 /* Called by acl_check_condition() below to calculate the result
2350 of the ACL ratelimit condition.
2351
2352 Note that the return value might be slightly unexpected: if the
2353 sender's rate is above the limit then the result is OK. This is
2354 similar to the dnslists condition, and is so that you can write
2355 ACL clauses like: defer ratelimit = 15 / 1h
2356
2357 Arguments:
2358   arg         the option string for ratelimit=
2359   where       ACL_WHERE_xxxx indicating which ACL this is
2360   log_msgptr  for error messages
2361
2362 Returns:       OK        - Sender's rate is above limit
2363                FAIL      - Sender's rate is below limit
2364                DEFER     - Problem opening ratelimit database
2365                ERROR     - Syntax error in options.
2366 */
2367
2368 static int
2369 acl_ratelimit(const uschar *arg, int where, uschar **log_msgptr)
2370 {
2371 double limit, period, count;
2372 uschar *ss;
2373 uschar *key = NULL;
2374 uschar *unique = NULL;
2375 int sep = '/';
2376 BOOL leaky = FALSE, strict = FALSE, readonly = FALSE;
2377 BOOL noupdate = FALSE, badacl = FALSE;
2378 int mode = RATE_PER_WHAT;
2379 int old_pool, rc;
2380 tree_node **anchor, *t;
2381 open_db dbblock, *dbm;
2382 int dbdb_size;
2383 dbdata_ratelimit *dbd;
2384 dbdata_ratelimit_unique *dbdb;
2385 struct timeval tv;
2386
2387 /* Parse the first two options and record their values in expansion
2388 variables. These variables allow the configuration to have informative
2389 error messages based on rate limits obtained from a table lookup. */
2390
2391 /* First is the maximum number of messages per period / maximum burst
2392 size, which must be greater than or equal to zero. Zero is useful for
2393 rate measurement as opposed to rate limiting. */
2394
2395 if (!(sender_rate_limit = string_nextinlist(&arg, &sep, NULL, 0)))
2396   return ratelimit_error(log_msgptr, "sender rate limit not set");
2397
2398 limit = Ustrtod(sender_rate_limit, &ss);
2399 if      (tolower(*ss) == 'k') { limit *= 1024.0; ss++; }
2400 else if (tolower(*ss) == 'm') { limit *= 1024.0*1024.0; ss++; }
2401 else if (tolower(*ss) == 'g') { limit *= 1024.0*1024.0*1024.0; ss++; }
2402
2403 if (limit < 0.0 || *ss != '\0')
2404   return ratelimit_error(log_msgptr,
2405     "\"%s\" is not a positive number", sender_rate_limit);
2406
2407 /* Second is the rate measurement period / exponential smoothing time
2408 constant. This must be strictly greater than zero, because zero leads to
2409 run-time division errors. */
2410
2411 period = !(sender_rate_period = string_nextinlist(&arg, &sep, NULL, 0))
2412   ? -1.0 : readconf_readtime(sender_rate_period, 0, FALSE);
2413 if (period <= 0.0)
2414   return ratelimit_error(log_msgptr,
2415     "\"%s\" is not a time value", sender_rate_period);
2416
2417 /* By default we are counting one of something, but the per_rcpt,
2418 per_byte, and count options can change this. */
2419
2420 count = 1.0;
2421
2422 /* Parse the other options. */
2423
2424 while ((ss = string_nextinlist(&arg, &sep, NULL, 0)))
2425   {
2426   if (strcmpic(ss, US"leaky") == 0) leaky = TRUE;
2427   else if (strcmpic(ss, US"strict") == 0) strict = TRUE;
2428   else if (strcmpic(ss, US"noupdate") == 0) noupdate = TRUE;
2429   else if (strcmpic(ss, US"readonly") == 0) readonly = TRUE;
2430   else if (strcmpic(ss, US"per_cmd") == 0) RATE_SET(mode, PER_CMD);
2431   else if (strcmpic(ss, US"per_conn") == 0)
2432     {
2433     RATE_SET(mode, PER_CONN);
2434     if (where == ACL_WHERE_NOTSMTP || where == ACL_WHERE_NOTSMTP_START)
2435       badacl = TRUE;
2436     }
2437   else if (strcmpic(ss, US"per_mail") == 0)
2438     {
2439     RATE_SET(mode, PER_MAIL);
2440     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2441     }
2442   else if (strcmpic(ss, US"per_rcpt") == 0)
2443     {
2444     /* If we are running in the RCPT ACL, then we'll count the recipients
2445     one by one, but if we are running when we have accumulated the whole
2446     list then we'll add them all in one batch. */
2447     if (where == ACL_WHERE_RCPT)
2448       RATE_SET(mode, PER_RCPT);
2449     else if (where >= ACL_WHERE_PREDATA && where <= ACL_WHERE_NOTSMTP)
2450       RATE_SET(mode, PER_ALLRCPTS), count = (double)recipients_count;
2451     else if (where == ACL_WHERE_MAIL || where > ACL_WHERE_NOTSMTP)
2452       RATE_SET(mode, PER_RCPT), badacl = TRUE;
2453     }
2454   else if (strcmpic(ss, US"per_byte") == 0)
2455     {
2456     /* If we have not yet received the message data and there was no SIZE
2457     declaration on the MAIL command, then it's safe to just use a value of
2458     zero and let the recorded rate decay as if nothing happened. */
2459     RATE_SET(mode, PER_MAIL);
2460     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2461     else count = message_size < 0 ? 0.0 : (double)message_size;
2462     }
2463   else if (strcmpic(ss, US"per_addr") == 0)
2464     {
2465     RATE_SET(mode, PER_RCPT);
2466     if (where != ACL_WHERE_RCPT) badacl = TRUE, unique = US"*";
2467     else unique = string_sprintf("%s@%s", deliver_localpart, deliver_domain);
2468     }
2469   else if (strncmpic(ss, US"count=", 6) == 0)
2470     {
2471     uschar *e;
2472     count = Ustrtod(ss+6, &e);
2473     if (count < 0.0 || *e != '\0')
2474       return ratelimit_error(log_msgptr, "\"%s\" is not a positive number", ss);
2475     }
2476   else if (strncmpic(ss, US"unique=", 7) == 0)
2477     unique = string_copy(ss + 7);
2478   else if (!key)
2479     key = string_copy(ss);
2480   else
2481     key = string_sprintf("%s/%s", key, ss);
2482   }
2483
2484 /* Sanity check. When the badacl flag is set the update mode must either
2485 be readonly (which is the default if it is omitted) or, for backwards
2486 compatibility, a combination of noupdate and strict or leaky. */
2487
2488 if (mode == RATE_PER_CLASH)
2489   return ratelimit_error(log_msgptr, "conflicting per_* options");
2490 if (leaky + strict + readonly > 1)
2491   return ratelimit_error(log_msgptr, "conflicting update modes");
2492 if (badacl && (leaky || strict) && !noupdate)
2493   return ratelimit_error(log_msgptr,
2494     "\"%s\" must not have /leaky or /strict option, or cannot be used in %s ACL",
2495     ratelimit_option_string[mode], acl_wherenames[where]);
2496
2497 /* Set the default values of any unset options. In readonly mode we
2498 perform the rate computation without any increment so that its value
2499 decays to eventually allow over-limit senders through. */
2500
2501 if (noupdate) readonly = TRUE, leaky = strict = FALSE;
2502 if (badacl) readonly = TRUE;
2503 if (readonly) count = 0.0;
2504 if (!strict && !readonly) leaky = TRUE;
2505 if (mode == RATE_PER_WHAT) mode = RATE_PER_MAIL;
2506
2507 /* Create the lookup key. If there is no explicit key, use sender_host_address.
2508 If there is no sender_host_address (e.g. -bs or acl_not_smtp) then we simply
2509 omit it. The smoothing constant (sender_rate_period) and the per_xxx options
2510 are added to the key because they alter the meaning of the stored data. */
2511
2512 if (!key)
2513   key = !sender_host_address ? US"" : sender_host_address;
2514
2515 key = string_sprintf("%s/%s/%s%s",
2516   sender_rate_period,
2517   ratelimit_option_string[mode],
2518   unique == NULL ? "" : "unique/",
2519   key);
2520
2521 HDEBUG(D_acl)
2522   debug_printf_indent("ratelimit condition count=%.0f %.1f/%s\n", count, limit, key);
2523
2524 /* See if we have already computed the rate by looking in the relevant tree.
2525 For per-connection rate limiting, store tree nodes and dbdata in the permanent
2526 pool so that they survive across resets. In readonly mode we only remember the
2527 result for the rest of this command in case a later command changes it. After
2528 this bit of logic the code is independent of the per_* mode. */
2529
2530 old_pool = store_pool;
2531
2532 if (readonly)
2533   anchor = &ratelimiters_cmd;
2534 else switch(mode)
2535   {
2536   case RATE_PER_CONN:
2537     anchor = &ratelimiters_conn;
2538     store_pool = POOL_PERM;
2539     break;
2540   case RATE_PER_BYTE:
2541   case RATE_PER_MAIL:
2542   case RATE_PER_ALLRCPTS:
2543     anchor = &ratelimiters_mail;
2544     break;
2545   case RATE_PER_ADDR:
2546   case RATE_PER_CMD:
2547   case RATE_PER_RCPT:
2548     anchor = &ratelimiters_cmd;
2549     break;
2550   default:
2551     anchor = NULL; /* silence an "unused" complaint */
2552     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
2553       "internal ACL error: unknown ratelimit mode %d", mode);
2554     /*NOTREACHED*/
2555     break;
2556   }
2557
2558 if ((t = tree_search(*anchor, key)))
2559   {
2560   dbd = t->data.ptr;
2561   /* The following few lines duplicate some of the code below. */
2562   rc = (dbd->rate < limit)? FAIL : OK;
2563   store_pool = old_pool;
2564   sender_rate = string_sprintf("%.1f", dbd->rate);
2565   HDEBUG(D_acl)
2566     debug_printf_indent("ratelimit found pre-computed rate %s\n", sender_rate);
2567   return rc;
2568   }
2569
2570 /* We aren't using a pre-computed rate, so get a previously recorded rate
2571 from the database, which will be updated and written back if required. */
2572
2573 if (!(dbm = dbfn_open(US"ratelimit", O_RDWR, &dbblock, TRUE, TRUE)))
2574   {
2575   store_pool = old_pool;
2576   sender_rate = NULL;
2577   HDEBUG(D_acl) debug_printf_indent("ratelimit database not available\n");
2578   *log_msgptr = US"ratelimit database not available";
2579   return DEFER;
2580   }
2581 dbdb = dbfn_read_with_length(dbm, key, &dbdb_size);
2582 dbd = NULL;
2583
2584 gettimeofday(&tv, NULL);
2585
2586 if (dbdb)
2587   {
2588   /* Locate the basic ratelimit block inside the DB data. */
2589   HDEBUG(D_acl) debug_printf_indent("ratelimit found key in database\n");
2590   dbd = &dbdb->dbd;
2591
2592   /* Forget the old Bloom filter if it is too old, so that we count each
2593   repeating event once per period. We don't simply clear and re-use the old
2594   filter because we want its size to change if the limit changes. Note that
2595   we keep the dbd pointer for copying the rate into the new data block. */
2596
2597   if(unique && tv.tv_sec > dbdb->bloom_epoch + period)
2598     {
2599     HDEBUG(D_acl) debug_printf_indent("ratelimit discarding old Bloom filter\n");
2600     dbdb = NULL;
2601     }
2602
2603   /* Sanity check. */
2604
2605   if(unique && dbdb_size < sizeof(*dbdb))
2606     {
2607     HDEBUG(D_acl) debug_printf_indent("ratelimit discarding undersize Bloom filter\n");
2608     dbdb = NULL;
2609     }
2610   }
2611
2612 /* Allocate a new data block if the database lookup failed
2613 or the Bloom filter passed its age limit. */
2614
2615 if (!dbdb)
2616   {
2617   if (!unique)
2618     {
2619     /* No Bloom filter. This basic ratelimit block is initialized below. */
2620     HDEBUG(D_acl) debug_printf_indent("ratelimit creating new rate data block\n");
2621     dbdb_size = sizeof(*dbd);
2622     dbdb = store_get(dbdb_size, GET_UNTAINTED);
2623     }
2624   else
2625     {
2626     int extra;
2627     HDEBUG(D_acl) debug_printf_indent("ratelimit creating new Bloom filter\n");
2628
2629     /* See the long comment below for an explanation of the magic number 2.
2630     The filter has a minimum size in case the rate limit is very small;
2631     this is determined by the definition of dbdata_ratelimit_unique. */
2632
2633     extra = (int)limit * 2 - sizeof(dbdb->bloom);
2634     if (extra < 0) extra = 0;
2635     dbdb_size = sizeof(*dbdb) + extra;
2636     dbdb = store_get(dbdb_size, GET_UNTAINTED);
2637     dbdb->bloom_epoch = tv.tv_sec;
2638     dbdb->bloom_size = sizeof(dbdb->bloom) + extra;
2639     memset(dbdb->bloom, 0, dbdb->bloom_size);
2640
2641     /* Preserve any basic ratelimit data (which is our longer-term memory)
2642     by copying it from the discarded block. */
2643
2644     if (dbd)
2645       {
2646       dbdb->dbd = *dbd;
2647       dbd = &dbdb->dbd;
2648       }
2649     }
2650   }
2651
2652 /* If we are counting unique events, find out if this event is new or not.
2653 If the client repeats the event during the current period then it should be
2654 counted. We skip this code in readonly mode for efficiency, because any
2655 changes to the filter will be discarded and because count is already set to
2656 zero. */
2657
2658 if (unique && !readonly)
2659   {
2660   /* We identify unique events using a Bloom filter. (You can find my
2661   notes on Bloom filters at http://fanf.livejournal.com/81696.html)
2662   With the per_addr option, an "event" is a recipient address, though the
2663   user can use the unique option to define their own events. We only count
2664   an event if we have not seen it before.
2665
2666   We size the filter according to the rate limit, which (in leaky mode)
2667   is the limit on the population of the filter. We allow 16 bits of space
2668   per entry (see the construction code above) and we set (up to) 8 of them
2669   when inserting an element (see the loop below). The probability of a false
2670   positive (an event we have not seen before but which we fail to count) is
2671
2672     size    = limit * 16
2673     numhash = 8
2674     allzero = exp(-numhash * pop / size)
2675             = exp(-0.5 * pop / limit)
2676     fpr     = pow(1 - allzero, numhash)
2677
2678   For senders at the limit the fpr is      0.06%    or  1 in 1700
2679   and for senders at half the limit it is  0.0006%  or  1 in 170000
2680
2681   In strict mode the Bloom filter can fill up beyond the normal limit, in
2682   which case the false positive rate will rise. This means that the
2683   measured rate for very fast senders can bogusly drop off after a while.
2684
2685   At twice the limit, the fpr is  2.5%  or  1 in 40
2686   At four times the limit, it is  31%   or  1 in 3.2
2687
2688   It takes ln(pop/limit) periods for an over-limit burst of pop events to
2689   decay below the limit, and if this is more than one then the Bloom filter
2690   will be discarded before the decay gets that far. The false positive rate
2691   at this threshold is 9.3% or 1 in 10.7. */
2692
2693   BOOL seen;
2694   unsigned n, hash, hinc;
2695   uschar md5sum[16];
2696   md5 md5info;
2697
2698   /* Instead of using eight independent hash values, we combine two values
2699   using the formula h1 + n * h2. This does not harm the Bloom filter's
2700   performance, and means the amount of hash we need is independent of the
2701   number of bits we set in the filter. */
2702
2703   md5_start(&md5info);
2704   md5_end(&md5info, unique, Ustrlen(unique), md5sum);
2705   hash = md5sum[0] | md5sum[1] << 8 | md5sum[2] << 16 | md5sum[3] << 24;
2706   hinc = md5sum[4] | md5sum[5] << 8 | md5sum[6] << 16 | md5sum[7] << 24;
2707
2708   /* Scan the bits corresponding to this event. A zero bit means we have
2709   not seen it before. Ensure all bits are set to record this event. */
2710
2711   HDEBUG(D_acl) debug_printf_indent("ratelimit checking uniqueness of %s\n", unique);
2712
2713   seen = TRUE;
2714   for (n = 0; n < 8; n++, hash += hinc)
2715     {
2716     int bit = 1 << (hash % 8);
2717     int byte = (hash / 8) % dbdb->bloom_size;
2718     if ((dbdb->bloom[byte] & bit) == 0)
2719       {
2720       dbdb->bloom[byte] |= bit;
2721       seen = FALSE;
2722       }
2723     }
2724
2725   /* If this event has occurred before, do not count it. */
2726
2727   if (seen)
2728     {
2729     HDEBUG(D_acl) debug_printf_indent("ratelimit event found in Bloom filter\n");
2730     count = 0.0;
2731     }
2732   else
2733     HDEBUG(D_acl) debug_printf_indent("ratelimit event added to Bloom filter\n");
2734   }
2735
2736 /* If there was no previous ratelimit data block for this key, initialize
2737 the new one, otherwise update the block from the database. The initial rate
2738 is what would be computed by the code below for an infinite interval. */
2739
2740 if (!dbd)
2741   {
2742   HDEBUG(D_acl) debug_printf_indent("ratelimit initializing new key's rate data\n");
2743   dbd = &dbdb->dbd;
2744   dbd->time_stamp = tv.tv_sec;
2745   dbd->time_usec = tv.tv_usec;
2746   dbd->rate = count;
2747   }
2748 else
2749   {
2750   /* The smoothed rate is computed using an exponentially weighted moving
2751   average adjusted for variable sampling intervals. The standard EWMA for
2752   a fixed sampling interval is:  f'(t) = (1 - a) * f(t) + a * f'(t - 1)
2753   where f() is the measured value and f'() is the smoothed value.
2754
2755   Old data decays out of the smoothed value exponentially, such that data n
2756   samples old is multiplied by a^n. The exponential decay time constant p
2757   is defined such that data p samples old is multiplied by 1/e, which means
2758   that a = exp(-1/p). We can maintain the same time constant for a variable
2759   sampling interval i by using a = exp(-i/p).
2760
2761   The rate we are measuring is messages per period, suitable for directly
2762   comparing with the limit. The average rate between now and the previous
2763   message is period / interval, which we feed into the EWMA as the sample.
2764
2765   It turns out that the number of messages required for the smoothed rate
2766   to reach the limit when they are sent in a burst is equal to the limit.
2767   This can be seen by analysing the value of the smoothed rate after N
2768   messages sent at even intervals. Let k = (1 - a) * p/i
2769
2770     rate_1 = (1 - a) * p/i + a * rate_0
2771            = k + a * rate_0
2772     rate_2 = k + a * rate_1
2773            = k + a * k + a^2 * rate_0
2774     rate_3 = k + a * k + a^2 * k + a^3 * rate_0
2775     rate_N = rate_0 * a^N + k * SUM(x=0..N-1)(a^x)
2776            = rate_0 * a^N + k * (1 - a^N) / (1 - a)
2777            = rate_0 * a^N + p/i * (1 - a^N)
2778
2779   When N is large, a^N -> 0 so rate_N -> p/i as desired.
2780
2781     rate_N = p/i + (rate_0 - p/i) * a^N
2782     a^N = (rate_N - p/i) / (rate_0 - p/i)
2783     N * -i/p = log((rate_N - p/i) / (rate_0 - p/i))
2784     N = p/i * log((rate_0 - p/i) / (rate_N - p/i))
2785
2786   Numerical analysis of the above equation, setting the computed rate to
2787   increase from rate_0 = 0 to rate_N = limit, shows that for large sending
2788   rates, p/i, the number of messages N = limit. So limit serves as both the
2789   maximum rate measured in messages per period, and the maximum number of
2790   messages that can be sent in a fast burst. */
2791
2792   double this_time = (double)tv.tv_sec
2793                    + (double)tv.tv_usec / 1000000.0;
2794   double prev_time = (double)dbd->time_stamp
2795                    + (double)dbd->time_usec / 1000000.0;
2796
2797   /* We must avoid division by zero, and deal gracefully with the clock going
2798   backwards. If we blunder ahead when time is in reverse then the computed
2799   rate will be bogus. To be safe we clamp interval to a very small number. */
2800
2801   double interval = this_time - prev_time <= 0.0 ? 1e-9
2802                   : this_time - prev_time;
2803
2804   double i_over_p = interval / period;
2805   double a = exp(-i_over_p);
2806
2807   /* Combine the instantaneous rate (period / interval) with the previous rate
2808   using the smoothing factor a. In order to measure sized events, multiply the
2809   instantaneous rate by the count of bytes or recipients etc. */
2810
2811   dbd->time_stamp = tv.tv_sec;
2812   dbd->time_usec = tv.tv_usec;
2813   dbd->rate = (1 - a) * count / i_over_p + a * dbd->rate;
2814
2815   /* When events are very widely spaced the computed rate tends towards zero.
2816   Although this is accurate it turns out not to be useful for our purposes,
2817   especially when the first event after a long silence is the start of a spam
2818   run. A more useful model is that the rate for an isolated event should be the
2819   size of the event per the period size, ignoring the lack of events outside
2820   the current period and regardless of where the event falls in the period. So,
2821   if the interval was so long that the calculated rate is unhelpfully small, we
2822   re-initialize the rate. In the absence of higher-rate bursts, the condition
2823   below is true if the interval is greater than the period. */
2824
2825   if (dbd->rate < count) dbd->rate = count;
2826   }
2827
2828 /* Clients sending at the limit are considered to be over the limit.
2829 This matters for edge cases such as a limit of zero, when the client
2830 should be completely blocked. */
2831
2832 rc = dbd->rate < limit ? FAIL : OK;
2833
2834 /* Update the state if the rate is low or if we are being strict. If we
2835 are in leaky mode and the sender's rate is too high, we do not update
2836 the recorded rate in order to avoid an over-aggressive sender's retry
2837 rate preventing them from getting any email through. If readonly is set,
2838 neither leaky nor strict are set, so we do not do any updates. */
2839
2840 if ((rc == FAIL && leaky) || strict)
2841   {
2842   dbfn_write(dbm, key, dbdb, dbdb_size);
2843   HDEBUG(D_acl) debug_printf_indent("ratelimit db updated\n");
2844   }
2845 else
2846   {
2847   HDEBUG(D_acl) debug_printf_indent("ratelimit db not updated: %s\n",
2848     readonly? "readonly mode" : "over the limit, but leaky");
2849   }
2850
2851 dbfn_close(dbm);
2852
2853 /* Store the result in the tree for future reference.  Take the taint status
2854 from the key for consistency even though it's unlikely we'll ever expand this. */
2855
2856 t = store_get(sizeof(tree_node) + Ustrlen(key), key);
2857 t->data.ptr = dbd;
2858 Ustrcpy(t->name, key);
2859 (void)tree_insertnode(anchor, t);
2860
2861 /* We create the formatted version of the sender's rate very late in
2862 order to ensure that it is done using the correct storage pool. */
2863
2864 store_pool = old_pool;
2865 sender_rate = string_sprintf("%.1f", dbd->rate);
2866
2867 HDEBUG(D_acl)
2868   debug_printf_indent("ratelimit computed rate %s\n", sender_rate);
2869
2870 return rc;
2871 }
2872
2873
2874
2875 /*************************************************
2876 *      Handle a check for previously-seen        *
2877 *************************************************/
2878
2879 /*
2880 ACL clauses like:   seen = -5m / key=$foo / readonly
2881
2882 Return is true for condition-true - but the semantics
2883 depend heavily on the actual use-case.
2884
2885 Negative times test for seen-before, positive for seen-more-recently-than
2886 (the given interval before current time).
2887
2888 All are subject to history not having been cleaned from the DB.
2889
2890 Default for seen-before is to create if not present, and to
2891 update if older than 10d (with the seen-test time).
2892 Default for seen-since is to always create or update.
2893
2894 Options:
2895   key=value.  Default key is $sender_host_address
2896   readonly
2897   write
2898   refresh=<interval>:  update an existing DB entry older than given
2899                         amount.  Default refresh lacking this option is 10d.
2900                         The update sets the record timestamp to the seen-test time.
2901
2902 XXX do we need separate nocreate, noupdate controls?
2903
2904 Arguments:
2905   arg         the option string for seen=
2906   where       ACL_WHERE_xxxx indicating which ACL this is
2907   log_msgptr  for error messages
2908
2909 Returns:       OK        - Condition is true
2910                FAIL      - Condition is false
2911                DEFER     - Problem opening history database
2912                ERROR     - Syntax error in options
2913 */
2914
2915 static int
2916 acl_seen(const uschar * arg, int where, uschar ** log_msgptr)
2917 {
2918 enum { SEEN_DEFAULT, SEEN_READONLY, SEEN_WRITE };
2919
2920 const uschar * list = arg;
2921 int slash = '/', interval, mode = SEEN_DEFAULT, yield = FAIL;
2922 BOOL before;
2923 int refresh = 10 * 24 * 60 * 60;        /* 10 days */
2924 const uschar * ele, * key = sender_host_address;
2925 open_db dbblock, * dbm;
2926 dbdata_seen * dbd;
2927 time_t now;
2928
2929 /* Parse the first element, the time-relation. */
2930
2931 if (!(ele = string_nextinlist(&list, &slash, NULL, 0)))
2932   goto badparse;
2933 if ((before = *ele == '-'))
2934   ele++;
2935 if ((interval = readconf_readtime(ele, 0, FALSE)) < 0)
2936   goto badparse;
2937
2938 /* Remaining elements are options */
2939
2940 while ((ele = string_nextinlist(&list, &slash, NULL, 0)))
2941   if (Ustrncmp(ele, "key=", 4) == 0)
2942     key = ele + 4;
2943   else if (Ustrcmp(ele, "readonly") == 0)
2944     mode = SEEN_READONLY;
2945   else if (Ustrcmp(ele, "write") == 0)
2946     mode = SEEN_WRITE;
2947   else if (Ustrncmp(ele, "refresh=", 8) == 0)
2948     {
2949     if ((refresh = readconf_readtime(ele + 8, 0, FALSE)) < 0)
2950       goto badparse;
2951     }
2952   else
2953     goto badopt;
2954
2955 if (!(dbm = dbfn_open(US"seen", O_RDWR, &dbblock, TRUE, TRUE)))
2956   {
2957   HDEBUG(D_acl) debug_printf_indent("database for 'seen' not available\n");
2958   *log_msgptr = US"database for 'seen' not available";
2959   return DEFER;
2960   }
2961
2962 dbd = dbfn_read_with_length(dbm, key, NULL);
2963 now = time(NULL);
2964 if (dbd)                /* an existing record */
2965   {
2966   time_t diff = now - dbd->time_stamp;  /* time since the record was written */
2967
2968   if (before ? diff >= interval : diff < interval)
2969     yield = OK;
2970
2971   if (mode == SEEN_READONLY)
2972     { HDEBUG(D_acl) debug_printf_indent("seen db not written (readonly)\n"); }
2973   else if (mode == SEEN_WRITE || !before)
2974     {
2975     dbd->time_stamp = now;
2976     dbfn_write(dbm, key, dbd, sizeof(*dbd));
2977     HDEBUG(D_acl) debug_printf_indent("seen db written (update)\n");
2978     }
2979   else if (diff >= refresh)
2980     {
2981     dbd->time_stamp = now - interval;
2982     dbfn_write(dbm, key, dbd, sizeof(*dbd));
2983     HDEBUG(D_acl) debug_printf_indent("seen db written (refresh)\n");
2984     }
2985   }
2986 else
2987   {                     /* No record found, yield always FAIL */
2988   if (mode != SEEN_READONLY)
2989     {
2990     dbdata_seen d = {.time_stamp = now};
2991     dbfn_write(dbm, key, &d, sizeof(*dbd));
2992     HDEBUG(D_acl) debug_printf_indent("seen db written (create)\n");
2993     }
2994   else
2995     HDEBUG(D_acl) debug_printf_indent("seen db not written (readonly)\n");
2996   }
2997
2998 dbfn_close(dbm);
2999 return yield;
3000
3001
3002 badparse:
3003   *log_msgptr = string_sprintf("failed to parse '%s'", arg);
3004   return ERROR;
3005 badopt:
3006   *log_msgptr = string_sprintf("unrecognised option '%s' in '%s'", ele, arg);
3007   return ERROR;
3008 }
3009
3010
3011
3012 /*************************************************
3013 *            The udpsend ACL modifier            *
3014 *************************************************/
3015
3016 /* Called by acl_check_condition() below.
3017
3018 Arguments:
3019   arg          the option string for udpsend=
3020   log_msgptr   for error messages
3021
3022 Returns:       OK        - Completed.
3023                DEFER     - Problem with DNS lookup.
3024                ERROR     - Syntax error in options.
3025 */
3026
3027 static int
3028 acl_udpsend(const uschar *arg, uschar **log_msgptr)
3029 {
3030 int sep = 0;
3031 uschar *hostname;
3032 uschar *portstr;
3033 uschar *portend;
3034 host_item *h;
3035 int portnum;
3036 int len;
3037 int r, s;
3038 uschar * errstr;
3039
3040 hostname = string_nextinlist(&arg, &sep, NULL, 0);
3041 portstr = string_nextinlist(&arg, &sep, NULL, 0);
3042
3043 if (!hostname)
3044   {
3045   *log_msgptr = US"missing destination host in \"udpsend\" modifier";
3046   return ERROR;
3047   }
3048 if (!portstr)
3049   {
3050   *log_msgptr = US"missing destination port in \"udpsend\" modifier";
3051   return ERROR;
3052   }
3053 if (!arg)
3054   {
3055   *log_msgptr = US"missing datagram payload in \"udpsend\" modifier";
3056   return ERROR;
3057   }
3058 portnum = Ustrtol(portstr, &portend, 10);
3059 if (*portend != '\0')
3060   {
3061   *log_msgptr = US"bad destination port in \"udpsend\" modifier";
3062   return ERROR;
3063   }
3064
3065 /* Make a single-item host list. */
3066 h = store_get(sizeof(host_item), GET_UNTAINTED);
3067 memset(h, 0, sizeof(host_item));
3068 h->name = hostname;
3069 h->port = portnum;
3070 h->mx = MX_NONE;
3071
3072 if (string_is_ip_address(hostname, NULL))
3073   h->address = hostname, r = HOST_FOUND;
3074 else
3075   r = host_find_byname(h, NULL, 0, NULL, FALSE);
3076 if (r == HOST_FIND_FAILED || r == HOST_FIND_AGAIN)
3077   {
3078   *log_msgptr = US"DNS lookup failed in \"udpsend\" modifier";
3079   return DEFER;
3080   }
3081
3082 HDEBUG(D_acl)
3083   debug_printf_indent("udpsend [%s]:%d %s\n", h->address, portnum, arg);
3084
3085 /*XXX this could better use sendto */
3086 r = s = ip_connectedsocket(SOCK_DGRAM, h->address, portnum, portnum,
3087                 1, NULL, &errstr, NULL);
3088 if (r < 0) goto defer;
3089 len = Ustrlen(arg);
3090 r = send(s, arg, len, 0);
3091 if (r < 0)
3092   {
3093   errstr = US strerror(errno);
3094   close(s);
3095   goto defer;
3096   }
3097 close(s);
3098 if (r < len)
3099   {
3100   *log_msgptr =
3101     string_sprintf("\"udpsend\" truncated from %d to %d octets", len, r);
3102   return DEFER;
3103   }
3104
3105 HDEBUG(D_acl)
3106   debug_printf_indent("udpsend %d bytes\n", r);
3107
3108 return OK;
3109
3110 defer:
3111 *log_msgptr = string_sprintf("\"udpsend\" failed: %s", errstr);
3112 return DEFER;
3113 }
3114
3115
3116
3117 /*************************************************
3118 *   Handle conditions/modifiers on an ACL item   *
3119 *************************************************/
3120
3121 /* Called from acl_check() below.
3122
3123 Arguments:
3124   verb         ACL verb
3125   cb           ACL condition block - if NULL, result is OK
3126   where        where called from
3127   addr         the address being checked for RCPT, or NULL
3128   level        the nesting level
3129   epp          pointer to pass back TRUE if "endpass" encountered
3130                  (applies only to "accept" and "discard")
3131   user_msgptr  user message pointer
3132   log_msgptr   log message pointer
3133   basic_errno  pointer to where to put verify error
3134
3135 Returns:       OK        - all conditions are met
3136                DISCARD   - an "acl" condition returned DISCARD - only allowed
3137                              for "accept" or "discard" verbs
3138                FAIL      - at least one condition fails
3139                FAIL_DROP - an "acl" condition returned FAIL_DROP
3140                DEFER     - can't tell at the moment (typically, lookup defer,
3141                              but can be temporary callout problem)
3142                ERROR     - ERROR from nested ACL or expansion failure or other
3143                              error
3144 */
3145
3146 static int
3147 acl_check_condition(int verb, acl_condition_block *cb, int where,
3148   address_item *addr, int level, BOOL *epp, uschar **user_msgptr,
3149   uschar **log_msgptr, int *basic_errno)
3150 {
3151 uschar * user_message = NULL;
3152 uschar * log_message = NULL;
3153 int rc = OK;
3154
3155 for (; cb; cb = cb->next)
3156   {
3157   const uschar * arg;
3158   int control_type;
3159   BOOL textonly = FALSE;
3160
3161   /* The message and log_message items set up messages to be used in
3162   case of rejection. They are expanded later. */
3163
3164   if (cb->type == ACLC_MESSAGE)
3165     {
3166     HDEBUG(D_acl) debug_printf_indent("  message: %s\n", cb->arg);
3167     user_message = cb->arg;
3168     continue;
3169     }
3170
3171   if (cb->type == ACLC_LOG_MESSAGE)
3172     {
3173     HDEBUG(D_acl) debug_printf_indent("l_message: %s\n", cb->arg);
3174     log_message = cb->arg;
3175     continue;
3176     }
3177
3178   /* The endpass "condition" just sets a flag to show it occurred. This is
3179   checked at compile time to be on an "accept" or "discard" item. */
3180
3181   if (cb->type == ACLC_ENDPASS)
3182     {
3183     *epp = TRUE;
3184     continue;
3185     }
3186
3187   /* For other conditions and modifiers, the argument is expanded now for some
3188   of them, but not for all, because expansion happens down in some lower level
3189   checking functions in some cases. */
3190
3191   if (!conditions[cb->type].expand_at_top)
3192     arg = cb->arg;
3193
3194   else if (!(arg = expand_string_2(cb->arg, &textonly)))
3195     {
3196     if (f.expand_string_forcedfail) continue;
3197     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
3198       cb->arg, expand_string_message);
3199     return f.search_find_defer ? DEFER : ERROR;
3200     }
3201
3202   /* Show condition, and expanded condition if it's different */
3203
3204   HDEBUG(D_acl)
3205     {
3206     int lhswidth = 0;
3207     debug_printf_indent("check %s%s %n",
3208       (!conditions[cb->type].is_modifier && cb->u.negated)? "!":"",
3209       conditions[cb->type].name, &lhswidth);
3210
3211     if (cb->type == ACLC_SET)
3212       {
3213 #ifndef DISABLE_DKIM
3214       if (  Ustrcmp(cb->u.varname, "dkim_verify_status") == 0
3215          || Ustrcmp(cb->u.varname, "dkim_verify_reason") == 0)
3216         {
3217         debug_printf("%s ", cb->u.varname);
3218         lhswidth += 19;
3219         }
3220       else
3221 #endif
3222         {
3223         debug_printf("acl_%s ", cb->u.varname);
3224         lhswidth += 5 + Ustrlen(cb->u.varname);
3225         }
3226       }
3227
3228     debug_printf("= %s\n", cb->arg);
3229
3230     if (arg != cb->arg)
3231       debug_printf("%.*s= %s\n", lhswidth,
3232       US"                             ", CS arg);
3233     }
3234
3235   /* Check that this condition makes sense at this time */
3236
3237   if ((conditions[cb->type].forbids & (1 << where)) != 0)
3238     {
3239     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
3240       conditions[cb->type].is_modifier ? "use" : "test",
3241       conditions[cb->type].name, acl_wherenames[where]);
3242     return ERROR;
3243     }
3244
3245   /* Run the appropriate test for each condition, or take the appropriate
3246   action for the remaining modifiers. */
3247
3248   switch(cb->type)
3249     {
3250     case ACLC_ADD_HEADER:
3251       setup_header(arg);
3252       break;
3253
3254     /* A nested ACL that returns "discard" makes sense only for an "accept" or
3255     "discard" verb. */
3256
3257     case ACLC_ACL:
3258       rc = acl_check_wargs(where, addr, arg, user_msgptr, log_msgptr);
3259       if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
3260         {
3261         *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
3262           "\"%s\" command (only allowed with \"accept\" or \"discard\")",
3263           verbs[verb]);
3264         return ERROR;
3265         }
3266       break;
3267
3268     case ACLC_AUTHENTICATED:
3269       rc = sender_host_authenticated ? match_isinlist(sender_host_authenticated,
3270               &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL) : FAIL;
3271       break;
3272
3273     #ifdef EXPERIMENTAL_BRIGHTMAIL
3274     case ACLC_BMI_OPTIN:
3275       {
3276       int old_pool = store_pool;
3277       store_pool = POOL_PERM;
3278       bmi_current_optin = string_copy(arg);
3279       store_pool = old_pool;
3280       }
3281     break;
3282     #endif
3283
3284     case ACLC_CONDITION:
3285     /* The true/false parsing here should be kept in sync with that used in
3286     expand.c when dealing with ECOND_BOOL so that we don't have too many
3287     different definitions of what can be a boolean. */
3288       if (*arg == '-'
3289           ? Ustrspn(arg+1, "0123456789") == Ustrlen(arg+1)    /* Negative number */
3290           : Ustrspn(arg,   "0123456789") == Ustrlen(arg))     /* Digits, or empty */
3291         rc = (Uatoi(arg) == 0)? FAIL : OK;
3292       else
3293         rc = (strcmpic(arg, US"no") == 0 ||
3294               strcmpic(arg, US"false") == 0)? FAIL :
3295              (strcmpic(arg, US"yes") == 0 ||
3296               strcmpic(arg, US"true") == 0)? OK : DEFER;
3297       if (rc == DEFER)
3298         *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
3299       break;
3300
3301     case ACLC_CONTINUE:    /* Always succeeds */
3302       break;
3303
3304     case ACLC_CONTROL:
3305       {
3306       const uschar *p = NULL;
3307       control_type = decode_control(arg, &p, where, log_msgptr);
3308
3309       /* Check if this control makes sense at this time */
3310
3311       if (controls_list[control_type].forbids & (1 << where))
3312         {
3313         *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
3314           controls_list[control_type].name, acl_wherenames[where]);
3315         return ERROR;
3316         }
3317
3318       switch(control_type)
3319         {
3320         case CONTROL_AUTH_UNADVERTISED:
3321           f.allow_auth_unadvertised = TRUE;
3322           break;
3323
3324 #ifdef EXPERIMENTAL_BRIGHTMAIL
3325         case CONTROL_BMI_RUN:
3326           bmi_run = 1;
3327           break;
3328 #endif
3329
3330 #ifndef DISABLE_DKIM
3331         case CONTROL_DKIM_VERIFY:
3332           f.dkim_disable_verify = TRUE;
3333 # ifdef SUPPORT_DMARC
3334           /* Since DKIM was blocked, skip DMARC too */
3335           f.dmarc_disable_verify = TRUE;
3336           f.dmarc_enable_forensic = FALSE;
3337 # endif
3338         break;
3339 #endif
3340
3341 #ifdef SUPPORT_DMARC
3342         case CONTROL_DMARC_VERIFY:
3343           f.dmarc_disable_verify = TRUE;
3344           break;
3345
3346         case CONTROL_DMARC_FORENSIC:
3347           f.dmarc_enable_forensic = TRUE;
3348           break;
3349 #endif
3350
3351         case CONTROL_DSCP:
3352           if (*p == '/')
3353             {
3354             int fd, af, level, optname, value;
3355             /* If we are acting on stdin, the setsockopt may fail if stdin is not
3356             a socket; we can accept that, we'll just debug-log failures anyway. */
3357             fd = fileno(smtp_in);
3358             if ((af = ip_get_address_family(fd)) < 0)
3359               {
3360               HDEBUG(D_acl)
3361                 debug_printf_indent("smtp input is probably not a socket [%s], not setting DSCP\n",
3362                     strerror(errno));
3363               break;
3364               }
3365             if (dscp_lookup(p+1, af, &level, &optname, &value))
3366               if (setsockopt(fd, level, optname, &value, sizeof(value)) < 0)
3367                 {
3368                 HDEBUG(D_acl) debug_printf_indent("failed to set input DSCP[%s]: %s\n",
3369                     p+1, strerror(errno));
3370                 }
3371               else
3372                 {
3373                 HDEBUG(D_acl) debug_printf_indent("set input DSCP to \"%s\"\n", p+1);
3374                 }
3375             else
3376               {
3377               *log_msgptr = string_sprintf("unrecognised DSCP value in \"control=%s\"", arg);
3378               return ERROR;
3379               }
3380             }
3381           else
3382             {
3383             *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3384             return ERROR;
3385             }
3386           break;
3387
3388         case CONTROL_ERROR:
3389           return ERROR;
3390
3391         case CONTROL_CASEFUL_LOCAL_PART:
3392           deliver_localpart = addr->cc_local_part;
3393           break;
3394
3395         case CONTROL_CASELOWER_LOCAL_PART:
3396           deliver_localpart = addr->lc_local_part;
3397           break;
3398
3399         case CONTROL_ENFORCE_SYNC:
3400           smtp_enforce_sync = TRUE;
3401           break;
3402
3403         case CONTROL_NO_ENFORCE_SYNC:
3404           smtp_enforce_sync = FALSE;
3405           break;
3406
3407 #ifdef WITH_CONTENT_SCAN
3408         case CONTROL_NO_MBOX_UNSPOOL:
3409           f.no_mbox_unspool = TRUE;
3410           break;
3411 #endif
3412
3413         case CONTROL_NO_MULTILINE:
3414           f.no_multiline_responses = TRUE;
3415           break;
3416
3417         case CONTROL_NO_PIPELINING:
3418           f.pipelining_enable = FALSE;
3419           break;
3420
3421         case CONTROL_NO_DELAY_FLUSH:
3422           f.disable_delay_flush = TRUE;
3423           break;
3424
3425         case CONTROL_NO_CALLOUT_FLUSH:
3426           f.disable_callout_flush = TRUE;
3427           break;
3428
3429         case CONTROL_FAKEREJECT:
3430           cancel_cutthrough_connection(TRUE, US"fakereject");
3431         case CONTROL_FAKEDEFER:
3432           fake_response = control_type == CONTROL_FAKEDEFER ? DEFER : FAIL;
3433           if (*p == '/')
3434             {
3435             const uschar *pp = p + 1;
3436             while (*pp) pp++;
3437             /* The entire control= line was expanded at top so no need to expand
3438             the part after the / */
3439             fake_response_text = string_copyn(p+1, pp-p-1);
3440             p = pp;
3441             }
3442            else /* Explicitly reset to default string */
3443             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).";
3444           break;
3445
3446         case CONTROL_FREEZE:
3447           f.deliver_freeze = TRUE;
3448           deliver_frozen_at = time(NULL);
3449           freeze_tell = freeze_tell_config;       /* Reset to configured value */
3450           if (Ustrncmp(p, "/no_tell", 8) == 0)
3451             {
3452             p += 8;
3453             freeze_tell = NULL;
3454             }
3455           if (*p)
3456             {
3457             *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3458             return ERROR;
3459             }
3460           cancel_cutthrough_connection(TRUE, US"item frozen");
3461           break;
3462
3463         case CONTROL_QUEUE:
3464           f.queue_only_policy = TRUE;
3465           if (Ustrcmp(p, "_only") == 0)
3466             p += 5;
3467           else while (*p == '/')
3468             if (Ustrncmp(p, "/only", 5) == 0)
3469               { p += 5; f.queue_smtp = FALSE; }
3470             else if (Ustrncmp(p, "/first_pass_route", 17) == 0)
3471               { p += 17; f.queue_smtp = TRUE; }
3472             else
3473               break;
3474           cancel_cutthrough_connection(TRUE, US"queueing forced");
3475           break;
3476
3477         case CONTROL_SUBMISSION:
3478           originator_name = US"";
3479           f.submission_mode = TRUE;
3480           while (*p == '/')
3481             {
3482             if (Ustrncmp(p, "/sender_retain", 14) == 0)
3483               {
3484               p += 14;
3485               f.active_local_sender_retain = TRUE;
3486               f.active_local_from_check = FALSE;
3487               }
3488             else if (Ustrncmp(p, "/domain=", 8) == 0)
3489               {
3490               const uschar *pp = p + 8;
3491               while (*pp && *pp != '/') pp++;
3492               submission_domain = string_copyn(p+8, pp-p-8);
3493               p = pp;
3494               }
3495             /* The name= option must be last, because it swallows the rest of
3496             the string. */
3497             else if (Ustrncmp(p, "/name=", 6) == 0)
3498               {
3499               const uschar *pp = p + 6;
3500               while (*pp) pp++;
3501               submission_name = parse_fix_phrase(p+6, pp-p-6);
3502               p = pp;
3503               }
3504             else break;
3505             }
3506           if (*p)
3507             {
3508             *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3509             return ERROR;
3510             }
3511           break;
3512
3513         case CONTROL_DEBUG:
3514           {
3515           uschar * debug_tag = NULL, * debug_opts = NULL;
3516           BOOL kill = FALSE, stop = FALSE;
3517
3518           while (*p == '/')
3519             {
3520             const uschar * pp = p+1;
3521             if (Ustrncmp(pp, "tag=", 4) == 0)
3522               {
3523               for (pp += 4; *pp && *pp != '/';) pp++;
3524               debug_tag = string_copyn(p+5, pp-p-5);
3525               }
3526             else if (Ustrncmp(pp, "opts=", 5) == 0)
3527               {
3528               for (pp += 5; *pp && *pp != '/';) pp++;
3529               debug_opts = string_copyn(p+6, pp-p-6);
3530               }
3531             else if (Ustrncmp(pp, "kill", 4) == 0)
3532               {
3533               pp += 4;
3534               kill = TRUE;
3535               }
3536             else if (Ustrncmp(pp, "stop", 4) == 0)
3537               {
3538               pp += 4;
3539               stop = TRUE;
3540               }
3541             else if (Ustrncmp(pp, "pretrigger=", 11) == 0)
3542                 debug_pretrigger_setup(pp+11);
3543             else if (Ustrncmp(pp, "trigger=", 8) == 0)
3544               {
3545               if (Ustrncmp(pp += 8, "now", 3) == 0)
3546                 {
3547                 pp += 3;
3548                 debug_trigger_fire();
3549                 }
3550               else if (Ustrncmp(pp, "paniclog", 8) == 0)
3551                 {
3552                 pp += 8;
3553                 dtrigger_selector |= BIT(DTi_panictrigger);
3554                 }
3555               }
3556             while (*pp && *pp != '/') pp++;
3557             p = pp;
3558             }
3559
3560           if (kill)
3561             debug_logging_stop(TRUE);
3562           else if (stop)
3563             debug_logging_stop(FALSE);
3564           else if (debug_tag || debug_opts)
3565             debug_logging_activate(debug_tag, debug_opts);
3566           break;
3567           }
3568
3569         case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3570           f.suppress_local_fixups = TRUE;
3571           break;
3572
3573         case CONTROL_CUTTHROUGH_DELIVERY:
3574           {
3575           uschar * ignored = NULL;
3576 #ifndef DISABLE_PRDR
3577           if (prdr_requested)
3578 #else
3579           if (0)
3580 #endif
3581             /* Too hard to think about for now.  We might in future cutthrough
3582             the case where both sides handle prdr and this-node prdr acl
3583             is "accept" */
3584             ignored = US"PRDR active";
3585           else if (f.deliver_freeze)
3586             ignored = US"frozen";
3587           else if (f.queue_only_policy)
3588             ignored = US"queue-only";
3589           else if (fake_response == FAIL)
3590             ignored = US"fakereject";
3591           else if (rcpt_count != 1)
3592             ignored = US"nonfirst rcpt";
3593           else if (cutthrough.delivery)
3594             ignored = US"repeated";
3595           else if (cutthrough.callout_hold_only)
3596             {
3597             DEBUG(D_acl)
3598               debug_printf_indent(" cutthrough request upgrades callout hold\n");
3599             cutthrough.callout_hold_only = FALSE;
3600             cutthrough.delivery = TRUE; /* control accepted */
3601             }
3602           else
3603             {
3604             cutthrough.delivery = TRUE; /* control accepted */
3605             while (*p == '/')
3606               {
3607               const uschar * pp = p+1;
3608               if (Ustrncmp(pp, "defer=", 6) == 0)
3609                 {
3610                 pp += 6;
3611                 if (Ustrncmp(pp, "pass", 4) == 0) cutthrough.defer_pass = TRUE;
3612                 /* else if (Ustrncmp(pp, "spool") == 0) ;       default */
3613                 }
3614               else
3615                 while (*pp && *pp != '/') pp++;
3616               p = pp;
3617               }
3618             }
3619
3620           DEBUG(D_acl) if (ignored)
3621             debug_printf(" cutthrough request ignored on %s item\n", ignored);
3622           }
3623         break;
3624
3625 #ifdef SUPPORT_I18N
3626         case CONTROL_UTF8_DOWNCONVERT:
3627           if (*p == '/')
3628             {
3629             if (p[1] == '1')
3630               {
3631               message_utf8_downconvert = 1;
3632               addr->prop.utf8_downcvt = TRUE;
3633               addr->prop.utf8_downcvt_maybe = FALSE;
3634               p += 2;
3635               break;
3636               }
3637             if (p[1] == '0')
3638               {
3639               message_utf8_downconvert = 0;
3640               addr->prop.utf8_downcvt = FALSE;
3641               addr->prop.utf8_downcvt_maybe = FALSE;
3642               p += 2;
3643               break;
3644               }
3645             if (p[1] == '-' && p[2] == '1')
3646               {
3647               message_utf8_downconvert = -1;
3648               addr->prop.utf8_downcvt = FALSE;
3649               addr->prop.utf8_downcvt_maybe = TRUE;
3650               p += 3;
3651               break;
3652               }
3653             *log_msgptr = US"bad option value for control=utf8_downconvert";
3654             }
3655           else
3656             {
3657             message_utf8_downconvert = 1;
3658             addr->prop.utf8_downcvt = TRUE;
3659             addr->prop.utf8_downcvt_maybe = FALSE;
3660             break;
3661             }
3662           return ERROR;
3663 #endif
3664
3665         }
3666       break;
3667       }
3668
3669 #ifdef EXPERIMENTAL_DCC
3670     case ACLC_DCC:
3671       {
3672       /* Separate the regular expression and any optional parameters. */
3673       const uschar * list = arg;
3674       int sep = -'/';
3675       uschar * ss = string_nextinlist(&list, &sep, NULL, 0);
3676       /* Run the dcc backend. */
3677       rc = dcc_process(&ss);
3678       /* Modify return code based upon the existence of options. */
3679       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
3680         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3681           rc = FAIL;   /* FAIL so that the message is passed to the next ACL */
3682       break;
3683       }
3684 #endif
3685
3686 #ifdef WITH_CONTENT_SCAN
3687     case ACLC_DECODE:
3688       rc = mime_decode(&arg);
3689       break;
3690 #endif
3691
3692     case ACLC_DELAY:
3693       {
3694       int delay = readconf_readtime(arg, 0, FALSE);
3695       if (delay < 0)
3696         {
3697         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3698           "modifier: \"%s\" is not a time value", arg);
3699         return ERROR;
3700         }
3701       else
3702         {
3703         HDEBUG(D_acl) debug_printf_indent("delay modifier requests %d-second delay\n",
3704           delay);
3705         if (host_checking)
3706           {
3707           HDEBUG(D_acl)
3708             debug_printf_indent("delay skipped in -bh checking mode\n");
3709           }
3710
3711         /* NOTE 1: Remember that we may be
3712         dealing with stdin/stdout here, in addition to TCP/IP connections.
3713         Also, delays may be specified for non-SMTP input, where smtp_out and
3714         smtp_in will be NULL. Whatever is done must work in all cases.
3715
3716         NOTE 2: The added feature of flushing the output before a delay must
3717         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3718         */
3719
3720         else
3721           {
3722           if (smtp_out && !f.disable_delay_flush)
3723             mac_smtp_fflush();
3724
3725 #if !defined(NO_POLL_H) && defined (POLLRDHUP)
3726             {
3727             struct pollfd p;
3728             nfds_t n = 0;
3729             if (smtp_out)
3730               {
3731               p.fd = fileno(smtp_out);
3732               p.events = POLLRDHUP;
3733               n = 1;
3734               }
3735             if (poll(&p, n, delay*1000) > 0)
3736               HDEBUG(D_acl) debug_printf_indent("delay cancelled by peer close\n");
3737             }
3738 #else
3739           /* Lacking POLLRDHUP it appears to be impossible to detect that a
3740           TCP/IP connection has gone away without reading from it. This means
3741           that we cannot shorten the delay below if the client goes away,
3742           because we cannot discover that the client has closed its end of the
3743           connection. (The connection is actually in a half-closed state,
3744           waiting for the server to close its end.) It would be nice to be able
3745           to detect this state, so that the Exim process is not held up
3746           unnecessarily. However, it seems that we can't. The poll() function
3747           does not do the right thing, and in any case it is not always
3748           available.  */
3749
3750           while (delay > 0) delay = sleep(delay);
3751 #endif
3752           }
3753         }
3754       break;
3755       }
3756
3757 #ifndef DISABLE_DKIM
3758     case ACLC_DKIM_SIGNER:
3759       if (dkim_cur_signer)
3760         rc = match_isinlist(dkim_cur_signer,
3761                           &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3762       else
3763         rc = FAIL;
3764       break;
3765
3766     case ACLC_DKIM_STATUS:
3767       rc = match_isinlist(dkim_verify_status,
3768                           &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3769       break;
3770 #endif
3771
3772 #ifdef SUPPORT_DMARC
3773     case ACLC_DMARC_STATUS:
3774       if (!f.dmarc_has_been_checked)
3775         dmarc_process();
3776       f.dmarc_has_been_checked = TRUE;
3777
3778       /* used long way of dmarc_exim_expand_query() in case we need more
3779       view into the process in the future. */
3780       rc = match_isinlist(dmarc_exim_expand_query(DMARC_VERIFY_STATUS),
3781                           &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3782       break;
3783 #endif
3784
3785     case ACLC_DNSLISTS:
3786       rc = verify_check_dnsbl(where, &arg, log_msgptr);
3787       break;
3788
3789     case ACLC_DOMAINS:
3790       rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3791         addr->domain_cache, MCL_DOMAIN, TRUE, CUSS &deliver_domain_data);
3792       break;
3793
3794     /* The value in tls_cipher is the full cipher name, for example,
3795     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3796     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3797     what may in practice come out of the SSL library - which at the time of
3798     writing is poorly documented. */
3799
3800     case ACLC_ENCRYPTED:
3801       if (!tls_in.cipher) rc = FAIL;
3802       else
3803         {
3804         uschar *endcipher = NULL;
3805         uschar *cipher = Ustrchr(tls_in.cipher, ':');
3806         if (!cipher) cipher = tls_in.cipher; else
3807           {
3808           endcipher = Ustrchr(++cipher, ':');
3809           if (endcipher) *endcipher = 0;
3810           }
3811         rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3812         if (endcipher) *endcipher = ':';
3813         }
3814       break;
3815
3816     /* Use verify_check_this_host() instead of verify_check_host() so that
3817     we can pass over &host_data to catch any looked up data. Once it has been
3818     set, it retains its value so that it's still there if another ACL verb
3819     comes through here and uses the cache. However, we must put it into
3820     permanent store in case it is also expected to be used in a subsequent
3821     message in the same SMTP connection. */
3822
3823     case ACLC_HOSTS:
3824       rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3825         sender_host_address ? sender_host_address : US"", CUSS &host_data);
3826       if (rc == DEFER) *log_msgptr = search_error_message;
3827       if (host_data) host_data = string_copy_perm(host_data, TRUE);
3828       break;
3829
3830     case ACLC_LOCAL_PARTS:
3831       rc = match_isinlist(addr->cc_local_part, &arg, 0,
3832         &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3833         CUSS &deliver_localpart_data);
3834       break;
3835
3836     case ACLC_LOG_REJECT_TARGET:
3837       {
3838       int logbits = 0, sep = 0;
3839       const uschar * s = arg;
3840
3841       for (uschar * ss; ss = string_nextinlist(&s, &sep, NULL, 0); )
3842         {
3843         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3844         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3845         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3846         else
3847           {
3848           logbits |= LOG_MAIN|LOG_REJECT;
3849           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3850             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3851           }
3852         }
3853       log_reject_target = logbits;
3854       break;
3855       }
3856
3857     case ACLC_LOGWRITE:
3858       {
3859       int logbits = 0;
3860       const uschar *s = arg;
3861       if (*s == ':')
3862         {
3863         s++;
3864         while (*s != ':')
3865           {
3866           if (Ustrncmp(s, "main", 4) == 0)
3867             { logbits |= LOG_MAIN; s += 4; }
3868           else if (Ustrncmp(s, "panic", 5) == 0)
3869             { logbits |= LOG_PANIC; s += 5; }
3870           else if (Ustrncmp(s, "reject", 6) == 0)
3871             { logbits |= LOG_REJECT; s += 6; }
3872           else
3873             {
3874             logbits = LOG_MAIN|LOG_PANIC;
3875             s = string_sprintf(":unknown log name in \"%s\" in "
3876               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3877             }
3878           if (*s == ',') s++;
3879           }
3880         s++;
3881         }
3882       while (isspace(*s)) s++;
3883
3884       if (logbits == 0) logbits = LOG_MAIN;
3885       log_write(0, logbits, "%s", string_printing(s));
3886       break;
3887       }
3888
3889 #ifdef WITH_CONTENT_SCAN
3890     case ACLC_MALWARE:                  /* Run the malware backend. */
3891       {
3892       /* Separate the regular expression and any optional parameters. */
3893       const uschar * list = arg;
3894       BOOL defer_ok = FALSE;
3895       int timeout = 0, sep = -'/';
3896       uschar * ss = string_nextinlist(&list, &sep, NULL, 0);
3897
3898       for (uschar * opt; opt = string_nextinlist(&list, &sep, NULL, 0); )
3899         if (strcmpic(opt, US"defer_ok") == 0)
3900           defer_ok = TRUE;
3901         else if (  strncmpic(opt, US"tmo=", 4) == 0
3902                 && (timeout = readconf_readtime(opt+4, '\0', FALSE)) < 0
3903                 )
3904           {
3905           *log_msgptr = string_sprintf("bad timeout value in '%s'", opt);
3906           return ERROR;
3907           }
3908
3909       rc = malware(ss, textonly, timeout);
3910       if (rc == DEFER && defer_ok)
3911         rc = FAIL;      /* FAIL so that the message is passed to the next ACL */
3912       break;
3913       }
3914
3915     case ACLC_MIME_REGEX:
3916       rc = mime_regex(&arg, textonly);
3917       break;
3918 #endif
3919
3920     case ACLC_QUEUE:
3921       if (is_tainted(arg))
3922         {
3923         *log_msgptr = string_sprintf("Tainted name '%s' for queue not permitted",
3924                                       arg);
3925         return ERROR;
3926         }
3927       if (Ustrchr(arg, '/'))
3928         {
3929         *log_msgptr = string_sprintf(
3930                 "Directory separator not permitted in queue name: '%s'", arg);
3931         return ERROR;
3932         }
3933       queue_name = string_copy_perm(arg, FALSE);
3934       break;
3935
3936     case ACLC_RATELIMIT:
3937       rc = acl_ratelimit(arg, where, log_msgptr);
3938       break;
3939
3940     case ACLC_RECIPIENTS:
3941       rc = match_address_list(CUS addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3942         CUSS &recipient_data);
3943       break;
3944
3945     #ifdef WITH_CONTENT_SCAN
3946     case ACLC_REGEX:
3947       rc = regex(&arg, textonly);
3948       break;
3949     #endif
3950
3951     case ACLC_REMOVE_HEADER:
3952       setup_remove_header(arg);
3953       break;
3954
3955     case ACLC_SEEN:
3956       rc = acl_seen(arg, where, log_msgptr);
3957       break;
3958
3959     case ACLC_SENDER_DOMAINS:
3960       {
3961       uschar *sdomain;
3962       sdomain = Ustrrchr(sender_address, '@');
3963       sdomain = sdomain ? sdomain + 1 : US"";
3964       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3965         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3966       break;
3967       }
3968
3969     case ACLC_SENDERS:
3970       rc = match_address_list(CUS sender_address, TRUE, TRUE, &arg,
3971         sender_address_cache, -1, 0, CUSS &sender_data);
3972       break;
3973
3974     /* Connection variables must persist forever; message variables not */
3975
3976     case ACLC_SET:
3977       {
3978       int old_pool = store_pool;
3979       if (  cb->u.varname[0] != 'm'
3980 #ifndef DISABLE_EVENT
3981          || event_name          /* An event is being delivered */
3982 #endif
3983          )
3984         store_pool = POOL_PERM;
3985 #ifndef DISABLE_DKIM    /* Overwriteable dkim result variables */
3986       if (Ustrcmp(cb->u.varname, "dkim_verify_status") == 0)
3987         dkim_verify_status = string_copy(arg);
3988       else if (Ustrcmp(cb->u.varname, "dkim_verify_reason") == 0)
3989         dkim_verify_reason = string_copy(arg);
3990       else
3991 #endif
3992         acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
3993       store_pool = old_pool;
3994       break;
3995       }
3996
3997 #ifdef WITH_CONTENT_SCAN
3998     case ACLC_SPAM:
3999       {
4000       /* Separate the regular expression and any optional parameters. */
4001       const uschar * list = arg;
4002       int sep = -'/';
4003       uschar * ss = string_nextinlist(&list, &sep, NULL, 0);
4004
4005       rc = spam(CUSS &ss);
4006       /* Modify return code based upon the existence of options. */
4007       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
4008         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
4009           rc = FAIL;    /* FAIL so that the message is passed to the next ACL */
4010       break;
4011       }
4012 #endif
4013
4014 #ifdef SUPPORT_SPF
4015     case ACLC_SPF:
4016       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
4017       break;
4018
4019     case ACLC_SPF_GUESS:
4020       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
4021       break;
4022 #endif
4023
4024     case ACLC_UDPSEND:
4025       rc = acl_udpsend(arg, log_msgptr);
4026       break;
4027
4028     /* If the verb is WARN, discard any user message from verification, because
4029     such messages are SMTP responses, not header additions. The latter come
4030     only from explicit "message" modifiers. However, put the user message into
4031     $acl_verify_message so it can be used in subsequent conditions or modifiers
4032     (until something changes it). */
4033
4034     case ACLC_VERIFY:
4035       rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
4036       if (*user_msgptr)
4037         acl_verify_message = *user_msgptr;
4038       if (verb == ACL_WARN) *user_msgptr = NULL;
4039       break;
4040
4041     default:
4042       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
4043         "condition %d", cb->type);
4044       break;
4045     }
4046
4047   /* If a condition was negated, invert OK/FAIL. */
4048
4049   if (!conditions[cb->type].is_modifier && cb->u.negated)
4050     if (rc == OK) rc = FAIL;
4051     else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
4052
4053   if (rc != OK) break;   /* Conditions loop */
4054   }
4055
4056
4057 /* If the result is the one for which "message" and/or "log_message" are used,
4058 handle the values of these modifiers. If there isn't a log message set, we make
4059 it the same as the user message.
4060
4061 "message" is a user message that will be included in an SMTP response. Unless
4062 it is empty, it overrides any previously set user message.
4063
4064 "log_message" is a non-user message, and it adds to any existing non-user
4065 message that is already set.
4066
4067 Most verbs have but a single return for which the messages are relevant, but
4068 for "discard", it's useful to have the log message both when it succeeds and
4069 when it fails. For "accept", the message is used in the OK case if there is no
4070 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
4071 present. */
4072
4073 if (*epp && rc == OK) user_message = NULL;
4074
4075 if ((BIT(rc) & msgcond[verb]) != 0)
4076   {
4077   uschar *expmessage;
4078   uschar *old_user_msgptr = *user_msgptr;
4079   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
4080
4081   /* If the verb is "warn", messages generated by conditions (verification or
4082   nested ACLs) are always discarded. This also happens for acceptance verbs
4083   when they actually do accept. Only messages specified at this level are used.
4084   However, the value of an existing message is available in $acl_verify_message
4085   during expansions. */
4086
4087   if (verb == ACL_WARN ||
4088       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
4089     *log_msgptr = *user_msgptr = NULL;
4090
4091   if (user_message)
4092     {
4093     acl_verify_message = old_user_msgptr;
4094     expmessage = expand_string(user_message);
4095     if (!expmessage)
4096       {
4097       if (!f.expand_string_forcedfail)
4098         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
4099           user_message, expand_string_message);
4100       }
4101     else if (expmessage[0] != 0) *user_msgptr = expmessage;
4102     }
4103
4104   if (log_message)
4105     {
4106     acl_verify_message = old_log_msgptr;
4107     expmessage = expand_string(log_message);
4108     if (!expmessage)
4109       {
4110       if (!f.expand_string_forcedfail)
4111         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
4112           log_message, expand_string_message);
4113       }
4114     else if (expmessage[0] != 0)
4115       {
4116       *log_msgptr = (*log_msgptr == NULL)? expmessage :
4117         string_sprintf("%s: %s", expmessage, *log_msgptr);
4118       }
4119     }
4120
4121   /* If no log message, default it to the user message */
4122
4123   if (!*log_msgptr) *log_msgptr = *user_msgptr;
4124   }
4125
4126 acl_verify_message = NULL;
4127 return rc;
4128 }
4129
4130
4131
4132
4133
4134 /*************************************************
4135 *        Get line from a literal ACL             *
4136 *************************************************/
4137
4138 /* This function is passed to acl_read() in order to extract individual lines
4139 of a literal ACL, which we access via static pointers. We can destroy the
4140 contents because this is called only once (the compiled ACL is remembered).
4141
4142 This code is intended to treat the data in the same way as lines in the main
4143 Exim configuration file. That is:
4144
4145   . Leading spaces are ignored.
4146
4147   . A \ at the end of a line is a continuation - trailing spaces after the \
4148     are permitted (this is because I don't believe in making invisible things
4149     significant). Leading spaces on the continued part of a line are ignored.
4150
4151   . Physical lines starting (significantly) with # are totally ignored, and
4152     may appear within a sequence of backslash-continued lines.
4153
4154   . Blank lines are ignored, but will end a sequence of continuations.
4155
4156 Arguments: none
4157 Returns:   a pointer to the next line
4158 */
4159
4160
4161 static uschar *acl_text;          /* Current pointer in the text */
4162 static uschar *acl_text_end;      /* Points one past the terminating '0' */
4163
4164
4165 static uschar *
4166 acl_getline(void)
4167 {
4168 uschar *yield;
4169
4170 /* This loop handles leading blank lines and comments. */
4171
4172 for(;;)
4173   {
4174   Uskip_whitespace(&acl_text);          /* Leading spaces/empty lines */
4175   if (!*acl_text) return NULL;          /* No more data */
4176   yield = acl_text;                     /* Potential data line */
4177
4178   while (*acl_text && *acl_text != '\n') acl_text++;
4179
4180   /* If we hit the end before a newline, we have the whole logical line. If
4181   it's a comment, there's no more data to be given. Otherwise, yield it. */
4182
4183   if (!*acl_text) return *yield == '#' ? NULL : yield;
4184
4185   /* After reaching a newline, end this loop if the physical line does not
4186   start with '#'. If it does, it's a comment, and the loop continues. */
4187
4188   if (*yield != '#') break;
4189   }
4190
4191 /* This loop handles continuations. We know we have some real data, ending in
4192 newline. See if there is a continuation marker at the end (ignoring trailing
4193 white space). We know that *yield is not white space, so no need to test for
4194 cont > yield in the backwards scanning loop. */
4195
4196 for(;;)
4197   {
4198   uschar *cont;
4199   for (cont = acl_text - 1; isspace(*cont); cont--);
4200
4201   /* If no continuation follows, we are done. Mark the end of the line and
4202   return it. */
4203
4204   if (*cont != '\\')
4205     {
4206     *acl_text++ = 0;
4207     return yield;
4208     }
4209
4210   /* We have encountered a continuation. Skip over whitespace at the start of
4211   the next line, and indeed the whole of the next line or lines if they are
4212   comment lines. */
4213
4214   for (;;)
4215     {
4216     while (*(++acl_text) == ' ' || *acl_text == '\t');
4217     if (*acl_text != '#') break;
4218     while (*(++acl_text) != 0 && *acl_text != '\n');
4219     }
4220
4221   /* We have the start of a continuation line. Move all the rest of the data
4222   to join onto the previous line, and then find its end. If the end is not a
4223   newline, we are done. Otherwise loop to look for another continuation. */
4224
4225   memmove(cont, acl_text, acl_text_end - acl_text);
4226   acl_text_end -= acl_text - cont;
4227   acl_text = cont;
4228   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
4229   if (*acl_text == 0) return yield;
4230   }
4231
4232 /* Control does not reach here */
4233 }
4234
4235
4236
4237
4238
4239 /************************************************/
4240 /* For error messages, a string describing the config location
4241 associated with current processing. NULL if not in an ACL. */
4242
4243 uschar *
4244 acl_current_verb(void)
4245 {
4246 if (acl_current) return string_sprintf(" (ACL %s, %s %d)",
4247     verbs[acl_current->verb], acl_current->srcfile, acl_current->srcline);
4248 return NULL;
4249 }
4250
4251 /*************************************************
4252 *        Check access using an ACL               *
4253 *************************************************/
4254
4255 /* This function is called from address_check. It may recurse via
4256 acl_check_condition() - hence the use of a level to stop looping. The ACL is
4257 passed as a string which is expanded. A forced failure implies no access check
4258 is required. If the result is a single word, it is taken as the name of an ACL
4259 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
4260 text, complete with newlines, and parsed as such. In both cases, the ACL check
4261 is then run. This function uses an auxiliary function for acl_read() to call
4262 for reading individual lines of a literal ACL. This is acl_getline(), which
4263 appears immediately above.
4264
4265 Arguments:
4266   where        where called from
4267   addr         address item when called from RCPT; otherwise NULL
4268   s            the input string; NULL is the same as an empty ACL => DENY
4269   user_msgptr  where to put a user error (for SMTP response)
4270   log_msgptr   where to put a logging message (not for SMTP response)
4271
4272 Returns:       OK         access is granted
4273                DISCARD    access is apparently granted...
4274                FAIL       access is denied
4275                FAIL_DROP  access is denied; drop the connection
4276                DEFER      can't tell at the moment
4277                ERROR      disaster
4278 */
4279
4280 static int
4281 acl_check_internal(int where, address_item *addr, uschar *s,
4282   uschar **user_msgptr, uschar **log_msgptr)
4283 {
4284 int fd = -1;
4285 acl_block *acl = NULL;
4286 uschar *acl_name = US"inline ACL";
4287 uschar *ss;
4288
4289 /* Catch configuration loops */
4290
4291 if (acl_level > 20)
4292   {
4293   *log_msgptr = US"ACL nested too deep: possible loop";
4294   return ERROR;
4295   }
4296
4297 if (!s)
4298   {
4299   HDEBUG(D_acl) debug_printf_indent("ACL is NULL: implicit DENY\n");
4300   return FAIL;
4301   }
4302
4303 /* At top level, we expand the incoming string. At lower levels, it has already
4304 been expanded as part of condition processing. */
4305
4306 if (acl_level == 0)
4307   {
4308   if (!(ss = expand_string(s)))
4309     {
4310     if (f.expand_string_forcedfail) return OK;
4311     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
4312       expand_string_message);
4313     return ERROR;
4314     }
4315   }
4316 else ss = s;
4317
4318 while (isspace(*ss)) ss++;
4319
4320 /* If we can't find a named ACL, the default is to parse it as an inline one.
4321 (Unless it begins with a slash; non-existent files give rise to an error.) */
4322
4323 acl_text = ss;
4324
4325 if (is_tainted(acl_text) && !f.running_in_test_harness)
4326   {
4327   log_write(0, LOG_MAIN|LOG_PANIC,
4328     "attempt to use tainted ACL text \"%s\"", acl_text);
4329   /* Avoid leaking info to an attacker */
4330   *log_msgptr = US"internal configuration error";
4331   return ERROR;
4332   }
4333
4334 /* Handle the case of a string that does not contain any spaces. Look for a
4335 named ACL among those read from the configuration, or a previously read file.
4336 It is possible that the pointer to the ACL is NULL if the configuration
4337 contains a name with no data. If not found, and the text begins with '/',
4338 read an ACL from a file, and save it so it can be re-used. */
4339
4340 if (Ustrchr(ss, ' ') == NULL)
4341   {
4342   tree_node * t = tree_search(acl_anchor, ss);
4343   if (t)
4344     {
4345     if (!(acl = (acl_block *)(t->data.ptr)))
4346       {
4347       HDEBUG(D_acl) debug_printf_indent("ACL \"%s\" is empty: implicit DENY\n", ss);
4348       return FAIL;
4349       }
4350     acl_name = string_sprintf("ACL \"%s\"", ss);
4351     HDEBUG(D_acl) debug_printf_indent("using ACL \"%s\"\n", ss);
4352     }
4353
4354   else if (*ss == '/')
4355     {
4356     struct stat statbuf;
4357     if ((fd = Uopen(ss, O_RDONLY, 0)) < 0)
4358       {
4359       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
4360         strerror(errno));
4361       return ERROR;
4362       }
4363     if (fstat(fd, &statbuf) != 0)
4364       {
4365       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
4366         strerror(errno));
4367       return ERROR;
4368       }
4369
4370     /* If the string being used as a filename is tainted, so is the file content */
4371     acl_text = store_get(statbuf.st_size + 1, ss);
4372     acl_text_end = acl_text + statbuf.st_size + 1;
4373
4374     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
4375       {
4376       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
4377         ss, strerror(errno));
4378       return ERROR;
4379       }
4380     acl_text[statbuf.st_size] = 0;
4381     (void)close(fd);
4382
4383     acl_name = string_sprintf("ACL \"%s\"", ss);
4384     HDEBUG(D_acl) debug_printf_indent("read ACL from file %s\n", ss);
4385     }
4386   }
4387
4388 /* Parse an ACL that is still in text form. If it came from a file, remember it
4389 in the ACL tree, having read it into the POOL_PERM store pool so that it
4390 persists between multiple messages. */
4391
4392 if (!acl)
4393   {
4394   int old_pool = store_pool;
4395   if (fd >= 0) store_pool = POOL_PERM;
4396   acl = acl_read(acl_getline, log_msgptr);
4397   store_pool = old_pool;
4398   if (!acl && *log_msgptr) return ERROR;
4399   if (fd >= 0)
4400     {
4401     tree_node * t = store_get_perm(sizeof(tree_node) + Ustrlen(ss), ss);
4402     Ustrcpy(t->name, ss);
4403     t->data.ptr = acl;
4404     (void)tree_insertnode(&acl_anchor, t);
4405     }
4406   }
4407
4408 /* Now we have an ACL to use. It's possible it may be NULL. */
4409
4410 while ((acl_current = acl))
4411   {
4412   int cond;
4413   int basic_errno = 0;
4414   BOOL endpass_seen = FALSE;
4415   BOOL acl_quit_check = acl_level == 0
4416     && (where == ACL_WHERE_QUIT || where == ACL_WHERE_NOTQUIT);
4417
4418   *log_msgptr = *user_msgptr = NULL;
4419   f.acl_temp_details = FALSE;
4420
4421   HDEBUG(D_acl) debug_printf_indent("processing \"%s\" (%s %d)\n",
4422     verbs[acl->verb], acl->srcfile, acl->srcline);
4423
4424   /* Clear out any search error message from a previous check before testing
4425   this condition. */
4426
4427   search_error_message = NULL;
4428   cond = acl_check_condition(acl->verb, acl->condition, where, addr, acl_level,
4429     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
4430
4431   /* Handle special returns: DEFER causes a return except on a WARN verb;
4432   ERROR always causes a return. */
4433
4434   switch (cond)
4435     {
4436     case DEFER:
4437       HDEBUG(D_acl) debug_printf_indent("%s: condition test deferred in %s\n",
4438         verbs[acl->verb], acl_name);
4439       if (basic_errno != ERRNO_CALLOUTDEFER)
4440         {
4441         if (search_error_message != NULL && *search_error_message != 0)
4442           *log_msgptr = search_error_message;
4443         if (smtp_return_error_details) f.acl_temp_details = TRUE;
4444         }
4445       else
4446         f.acl_temp_details = TRUE;
4447       if (acl->verb != ACL_WARN) return DEFER;
4448       break;
4449
4450     default:      /* Paranoia */
4451     case ERROR:
4452       HDEBUG(D_acl) debug_printf_indent("%s: condition test error in %s\n",
4453         verbs[acl->verb], acl_name);
4454       return ERROR;
4455
4456     case OK:
4457       HDEBUG(D_acl) debug_printf_indent("%s: condition test succeeded in %s\n",
4458         verbs[acl->verb], acl_name);
4459       break;
4460
4461     case FAIL:
4462       HDEBUG(D_acl) debug_printf_indent("%s: condition test failed in %s\n",
4463         verbs[acl->verb], acl_name);
4464       break;
4465
4466     /* DISCARD and DROP can happen only from a nested ACL condition, and
4467     DISCARD can happen only for an "accept" or "discard" verb. */
4468
4469     case DISCARD:
4470       HDEBUG(D_acl) debug_printf_indent("%s: condition test yielded \"discard\" in %s\n",
4471         verbs[acl->verb], acl_name);
4472       break;
4473
4474     case FAIL_DROP:
4475       HDEBUG(D_acl) debug_printf_indent("%s: condition test yielded \"drop\" in %s\n",
4476         verbs[acl->verb], acl_name);
4477       break;
4478     }
4479
4480   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
4481   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
4482   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
4483
4484   switch(acl->verb)
4485     {
4486     case ACL_ACCEPT:
4487       if (cond == OK || cond == DISCARD)
4488         {
4489         HDEBUG(D_acl) debug_printf_indent("end of %s: ACCEPT\n", acl_name);
4490         return cond;
4491         }
4492       if (endpass_seen)
4493         {
4494         HDEBUG(D_acl) debug_printf_indent("accept: endpass encountered - denying access\n");
4495         return cond;
4496         }
4497       break;
4498
4499     case ACL_DEFER:
4500       if (cond == OK)
4501         {
4502         HDEBUG(D_acl) debug_printf_indent("end of %s: DEFER\n", acl_name);
4503         if (acl_quit_check) goto badquit;
4504         f.acl_temp_details = TRUE;
4505         return DEFER;
4506         }
4507       break;
4508
4509     case ACL_DENY:
4510       if (cond == OK)
4511         {
4512         HDEBUG(D_acl) debug_printf_indent("end of %s: DENY\n", acl_name);
4513         if (acl_quit_check) goto badquit;
4514         return FAIL;
4515         }
4516       break;
4517
4518     case ACL_DISCARD:
4519       if (cond == OK || cond == DISCARD)
4520         {
4521         HDEBUG(D_acl) debug_printf_indent("end of %s: DISCARD\n", acl_name);
4522         if (acl_quit_check) goto badquit;
4523         return DISCARD;
4524         }
4525       if (endpass_seen)
4526         {
4527         HDEBUG(D_acl)
4528           debug_printf_indent("discard: endpass encountered - denying access\n");
4529         return cond;
4530         }
4531       break;
4532
4533     case ACL_DROP:
4534       if (cond == OK)
4535         {
4536         HDEBUG(D_acl) debug_printf_indent("end of %s: DROP\n", acl_name);
4537         if (acl_quit_check) goto badquit;
4538         return FAIL_DROP;
4539         }
4540       break;
4541
4542     case ACL_REQUIRE:
4543       if (cond != OK)
4544         {
4545         HDEBUG(D_acl) debug_printf_indent("end of %s: not OK\n", acl_name);
4546         if (acl_quit_check) goto badquit;
4547         return cond;
4548         }
4549       break;
4550
4551     case ACL_WARN:
4552       if (cond == OK)
4553         acl_warn(where, *user_msgptr, *log_msgptr);
4554       else if (cond == DEFER && LOGGING(acl_warn_skipped))
4555         log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
4556           "condition test deferred%s%s", host_and_ident(TRUE),
4557           *log_msgptr ? US": " : US"",
4558           *log_msgptr ? *log_msgptr : US"");
4559       *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
4560       break;
4561
4562     default:
4563       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
4564         acl->verb);
4565       break;
4566     }
4567
4568   /* Pass to the next ACL item */
4569
4570   acl = acl->next;
4571   }
4572
4573 /* We have reached the end of the ACL. This is an implicit DENY. */
4574
4575 HDEBUG(D_acl) debug_printf_indent("end of %s: implicit DENY\n", acl_name);
4576 return FAIL;
4577
4578 badquit:
4579   *log_msgptr = string_sprintf("QUIT or not-QUIT toplevel ACL may not fail "
4580     "('%s' verb used incorrectly)", verbs[acl->verb]);
4581   return ERROR;
4582 }
4583
4584
4585
4586
4587 /* Same args as acl_check_internal() above, but the string s is
4588 the name of an ACL followed optionally by up to 9 space-separated arguments.
4589 The name and args are separately expanded.  Args go into $acl_arg globals. */
4590 static int
4591 acl_check_wargs(int where, address_item *addr, const uschar *s,
4592   uschar **user_msgptr, uschar **log_msgptr)
4593 {
4594 uschar * tmp;
4595 uschar * tmp_arg[9];    /* must match acl_arg[] */
4596 uschar * sav_arg[9];    /* must match acl_arg[] */
4597 int sav_narg;
4598 uschar * name;
4599 int i;
4600 int ret;
4601
4602 if (!(tmp = string_dequote(&s)) || !(name = expand_string(tmp)))
4603   goto bad;
4604
4605 for (i = 0; i < 9; i++)
4606   {
4607   while (*s && isspace(*s)) s++;
4608   if (!*s) break;
4609   if (!(tmp = string_dequote(&s)) || !(tmp_arg[i] = expand_string(tmp)))
4610     {
4611     tmp = name;
4612     goto bad;
4613     }
4614   }
4615
4616 sav_narg = acl_narg;
4617 acl_narg = i;
4618 for (i = 0; i < acl_narg; i++)
4619   {
4620   sav_arg[i] = acl_arg[i];
4621   acl_arg[i] = tmp_arg[i];
4622   }
4623 while (i < 9)
4624   {
4625   sav_arg[i] = acl_arg[i];
4626   acl_arg[i++] = NULL;
4627   }
4628
4629 acl_level++;
4630 ret = acl_check_internal(where, addr, name, user_msgptr, log_msgptr);
4631 acl_level--;
4632
4633 acl_narg = sav_narg;
4634 for (i = 0; i < 9; i++) acl_arg[i] = sav_arg[i];
4635 return ret;
4636
4637 bad:
4638 if (f.expand_string_forcedfail) return ERROR;
4639 *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
4640   tmp, expand_string_message);
4641 return f.search_find_defer ? DEFER : ERROR;
4642 }
4643
4644
4645
4646 /*************************************************
4647 *        Check access using an ACL               *
4648 *************************************************/
4649
4650 /* Alternate interface for ACL, used by expansions */
4651 int
4652 acl_eval(int where, uschar *s, uschar **user_msgptr, uschar **log_msgptr)
4653 {
4654 address_item adb;
4655 address_item *addr = NULL;
4656 int rc;
4657
4658 *user_msgptr = *log_msgptr = NULL;
4659 sender_verified_failed = NULL;
4660 ratelimiters_cmd = NULL;
4661 log_reject_target = LOG_MAIN|LOG_REJECT;
4662
4663 if (where == ACL_WHERE_RCPT)
4664   {
4665   adb = address_defaults;
4666   addr = &adb;
4667   addr->address = expand_string(US"$local_part@$domain");
4668   addr->domain = deliver_domain;
4669   addr->local_part = deliver_localpart;
4670   addr->cc_local_part = deliver_localpart;
4671   addr->lc_local_part = deliver_localpart;
4672   }
4673
4674 acl_level++;
4675 rc = acl_check_internal(where, addr, s, user_msgptr, log_msgptr);
4676 acl_level--;
4677 return rc;
4678 }
4679
4680
4681
4682 /* This is the external interface for ACL checks. It sets up an address and the
4683 expansions for $domain and $local_part when called after RCPT, then calls
4684 acl_check_internal() to do the actual work.
4685
4686 Arguments:
4687   where        ACL_WHERE_xxxx indicating where called from
4688   recipient    RCPT address for RCPT check, else NULL
4689   s            the input string; NULL is the same as an empty ACL => DENY
4690   user_msgptr  where to put a user error (for SMTP response)
4691   log_msgptr   where to put a logging message (not for SMTP response)
4692
4693 Returns:       OK         access is granted by an ACCEPT verb
4694                DISCARD    access is granted by a DISCARD verb
4695                FAIL       access is denied
4696                FAIL_DROP  access is denied; drop the connection
4697                DEFER      can't tell at the moment
4698                ERROR      disaster
4699 */
4700 int acl_where = ACL_WHERE_UNKNOWN;
4701
4702 int
4703 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
4704   uschar **log_msgptr)
4705 {
4706 int rc;
4707 address_item adb;
4708 address_item *addr = NULL;
4709
4710 *user_msgptr = *log_msgptr = NULL;
4711 sender_verified_failed = NULL;
4712 ratelimiters_cmd = NULL;
4713 log_reject_target = LOG_MAIN|LOG_REJECT;
4714
4715 #ifndef DISABLE_PRDR
4716 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY || where==ACL_WHERE_PRDR)
4717 #else
4718 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY)
4719 #endif
4720   {
4721   adb = address_defaults;
4722   addr = &adb;
4723   addr->address = recipient;
4724   if (deliver_split_address(addr) == DEFER)
4725     {
4726     *log_msgptr = US"defer in percent_hack_domains check";
4727     return DEFER;
4728     }
4729 #ifdef SUPPORT_I18N
4730   if ((addr->prop.utf8_msg = message_smtputf8))
4731     {
4732     addr->prop.utf8_downcvt =       message_utf8_downconvert == 1;
4733     addr->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
4734     }
4735 #endif
4736   deliver_domain = addr->domain;
4737   deliver_localpart = addr->local_part;
4738   }
4739
4740 acl_where = where;
4741 acl_level = 0;
4742 rc = acl_check_internal(where, addr, s, user_msgptr, log_msgptr);
4743 acl_level = 0;
4744 acl_where = ACL_WHERE_UNKNOWN;
4745
4746 /* Cutthrough - if requested,
4747 and WHERE_RCPT and not yet opened conn as result of recipient-verify,
4748 and rcpt acl returned accept,
4749 and first recipient (cancel on any subsequents)
4750 open one now and run it up to RCPT acceptance.
4751 A failed verify should cancel cutthrough request,
4752 and will pass the fail to the originator.
4753 Initial implementation:  dual-write to spool.
4754 Assume the rxd datastream is now being copied byte-for-byte to an open cutthrough connection.
4755
4756 Cease cutthrough copy on rxd final dot; do not send one.
4757
4758 On a data acl, if not accept and a cutthrough conn is open, hard-close it (no SMTP niceness).
4759
4760 On data acl accept, terminate the dataphase on an open cutthrough conn.  If accepted or
4761 perm-rejected, reflect that to the original sender - and dump the spooled copy.
4762 If temp-reject, close the conn (and keep the spooled copy).
4763 If conn-failure, no action (and keep the spooled copy).
4764 */
4765 switch (where)
4766   {
4767   case ACL_WHERE_RCPT:
4768 #ifndef DISABLE_PRDR
4769   case ACL_WHERE_PRDR:
4770 #endif
4771
4772     if (f.host_checking_callout)        /* -bhc mode */
4773       cancel_cutthrough_connection(TRUE, US"host-checking mode");
4774
4775     else if (  rc == OK
4776             && cutthrough.delivery
4777             && rcpt_count > cutthrough.nrcpt
4778             )
4779       {
4780       if ((rc = open_cutthrough_connection(addr)) == DEFER)
4781         if (cutthrough.defer_pass)
4782           {
4783           uschar * s = addr->message;
4784           /* Horrid kludge to recover target's SMTP message */
4785           while (*s) s++;
4786           do --s; while (!isdigit(*s));
4787           if (*--s && isdigit(*s) && *--s && isdigit(*s)) *user_msgptr = s;
4788           f.acl_temp_details = TRUE;
4789           }
4790         else
4791           {
4792           HDEBUG(D_acl) debug_printf_indent("cutthrough defer; will spool\n");
4793           rc = OK;
4794           }
4795       }
4796     else HDEBUG(D_acl) if (cutthrough.delivery)
4797       if (rcpt_count <= cutthrough.nrcpt)
4798         debug_printf_indent("ignore cutthrough request; nonfirst message\n");
4799       else if (rc != OK)
4800         debug_printf_indent("ignore cutthrough request; ACL did not accept\n");
4801     break;
4802
4803   case ACL_WHERE_PREDATA:
4804     if (rc == OK)
4805       cutthrough_predata();
4806     else
4807       cancel_cutthrough_connection(TRUE, US"predata acl not ok");
4808     break;
4809
4810   case ACL_WHERE_QUIT:
4811   case ACL_WHERE_NOTQUIT:
4812     /* Drop cutthrough conns, and drop heldopen verify conns if
4813     the previous was not DATA */
4814     {
4815     uschar prev =
4816       smtp_connection_had[SMTP_HBUFF_PREV(SMTP_HBUFF_PREV(smtp_ch_index))];
4817     BOOL dropverify = !(prev == SCH_DATA || prev == SCH_BDAT);
4818
4819     cancel_cutthrough_connection(dropverify, US"quit or conndrop");
4820     break;
4821     }
4822
4823   default:
4824     break;
4825   }
4826
4827 deliver_domain = deliver_localpart = deliver_address_data =
4828   deliver_domain_data = sender_address_data = NULL;
4829
4830 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
4831 ACL, which is really in the middle of an SMTP command. */
4832
4833 if (rc == DISCARD)
4834   {
4835   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
4836     {
4837     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
4838       "ACL", acl_wherenames[where]);
4839     return ERROR;
4840     }
4841   return DISCARD;
4842   }
4843
4844 /* A DROP response is not permitted from MAILAUTH */
4845
4846 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
4847   {
4848   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
4849     "ACL", acl_wherenames[where]);
4850   return ERROR;
4851   }
4852
4853 /* Before giving a response, take a look at the length of any user message, and
4854 split it up into multiple lines if possible. */
4855
4856 *user_msgptr = string_split_message(*user_msgptr);
4857 if (fake_response != OK)
4858   fake_response_text = string_split_message(fake_response_text);
4859
4860 return rc;
4861 }
4862
4863
4864 /*************************************************
4865 *             Create ACL variable                *
4866 *************************************************/
4867
4868 /* Create an ACL variable or reuse an existing one. ACL variables are in a
4869 binary tree (see tree.c) with acl_var_c and acl_var_m as root nodes.
4870
4871 Argument:
4872   name    pointer to the variable's name, starting with c or m
4873
4874 Returns   the pointer to variable's tree node
4875 */
4876
4877 tree_node *
4878 acl_var_create(uschar * name)
4879 {
4880 tree_node * node, ** root = name[0] == 'c' ? &acl_var_c : &acl_var_m;
4881 if (!(node = tree_search(*root, name)))
4882   {
4883   node = store_get(sizeof(tree_node) + Ustrlen(name), name);
4884   Ustrcpy(node->name, name);
4885   (void)tree_insertnode(root, node);
4886   }
4887 node->data.ptr = NULL;
4888 return node;
4889 }
4890
4891
4892
4893 /*************************************************
4894 *       Write an ACL variable in spool format    *
4895 *************************************************/
4896
4897 /* This function is used as a callback for tree_walk when writing variables to
4898 the spool file. To retain spool file compatibility, what is written is -aclc or
4899 -aclm followed by the rest of the name and the data length, space separated,
4900 then the value itself, starting on a new line, and terminated by an additional
4901 newline. When we had only numbered ACL variables, the first line might look
4902 like this: "-aclc 5 20". Now it might be "-aclc foo 20" for the variable called
4903 acl_cfoo.
4904
4905 Arguments:
4906   name    of the variable
4907   value   of the variable
4908   ctx     FILE pointer (as a void pointer)
4909
4910 Returns:  nothing
4911 */
4912
4913 void
4914 acl_var_write(uschar * name, uschar * value, void * ctx)
4915 {
4916 FILE * f = (FILE *)ctx;
4917 putc('-', f);
4918 if (is_tainted(value))
4919   {
4920   int q = quoter_for_address(value);
4921   putc('-', f);
4922   if (is_real_quoter(q)) fprintf(f, "(%s)", lookup_list[q]->name);
4923   }
4924 fprintf(f, "acl%c %s %d\n%s\n", name[0], name+1, Ustrlen(value), value);
4925 }
4926
4927
4928
4929
4930 uschar *
4931 acl_standalone_setvar(const uschar * s)
4932 {
4933 acl_condition_block * cond = store_get(sizeof(acl_condition_block), GET_UNTAINTED);
4934 uschar * errstr = NULL, * log_msg = NULL;
4935 BOOL endpass_seen;
4936 int e;
4937
4938 cond->next = NULL;
4939 cond->type = ACLC_SET;
4940 if (!acl_varname_to_cond(&s, cond, &errstr)) return errstr;
4941 if (!acl_data_to_cond(s, cond, US"'-be'", &errstr)) return errstr;
4942
4943 if (acl_check_condition(ACL_WARN, cond, ACL_WHERE_UNKNOWN,
4944                             NULL, 0, &endpass_seen, &errstr, &log_msg, &e) != OK)
4945   return string_sprintf("oops: %s", errstr);
4946 return string_sprintf("variable %s set", cond->u.varname);
4947 }
4948
4949
4950 #endif  /* !MACRO_PREDEF */
4951 /* vi: aw ai sw=2
4952 */
4953 /* End of acl.c */