src/src/acl.c

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