src/src/acl.c

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