src/src/acl.c

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