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