src/src/acl.c

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