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