src/src/acl.c

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