src/src/acl.c

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