src/src/acl.c

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