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