src/src/acl.c

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