src/src/acl.c

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