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_VERIFY] =
 432   { US"dmarc_disable_verify",    FALSE,
 433           (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
 434   },
 435 [CONTROL_DMARC_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 = US 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      CS vp < CS 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 (CS vp >= CS 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 /*XXX this could better use sendto */
2775 r = s = ip_connectedsocket(SOCK_DGRAM, h->address, portnum, portnum,
2776                 1, NULL, &errstr, NULL);
2777 if (r < 0) goto defer;
2778 len = Ustrlen(arg);
2779 r = send(s, arg, len, 0);
2780 if (r < 0)
2781   {
2782   errstr = US strerror(errno);
2783   close(s);
2784   goto defer;
2785   }
2786 close(s);
2787 if (r < len)
2788   {
2789   *log_msgptr =
2790     string_sprintf("\"udpsend\" truncated from %d to %d octets", len, r);
2791   return DEFER;
2792   }
2793
2794 HDEBUG(D_acl)
2795   debug_printf_indent("udpsend %d bytes\n", r);
2796
2797 return OK;
2798
2799 defer:
2800 *log_msgptr = string_sprintf("\"udpsend\" failed: %s", errstr);
2801 return DEFER;
2802 }
2803
2804
2805
2806 /*************************************************
2807 *   Handle conditions/modifiers on an ACL item   *
2808 *************************************************/
2809
2810 /* Called from acl_check() below.
2811
2812 Arguments:
2813   verb         ACL verb
2814   cb           ACL condition block - if NULL, result is OK
2815   where        where called from
2816   addr         the address being checked for RCPT, or NULL
2817   level        the nesting level
2818   epp          pointer to pass back TRUE if "endpass" encountered
2819                  (applies only to "accept" and "discard")
2820   user_msgptr  user message pointer
2821   log_msgptr   log message pointer
2822   basic_errno  pointer to where to put verify error
2823
2824 Returns:       OK        - all conditions are met
2825                DISCARD   - an "acl" condition returned DISCARD - only allowed
2826                              for "accept" or "discard" verbs
2827                FAIL      - at least one condition fails
2828                FAIL_DROP - an "acl" condition returned FAIL_DROP
2829                DEFER     - can't tell at the moment (typically, lookup defer,
2830                              but can be temporary callout problem)
2831                ERROR     - ERROR from nested ACL or expansion failure or other
2832                              error
2833 */
2834
2835 static int
2836 acl_check_condition(int verb, acl_condition_block *cb, int where,
2837   address_item *addr, int level, BOOL *epp, uschar **user_msgptr,
2838   uschar **log_msgptr, int *basic_errno)
2839 {
2840 uschar *user_message = NULL;
2841 uschar *log_message = NULL;
2842 int rc = OK;
2843 #ifdef WITH_CONTENT_SCAN
2844 int sep = -'/';
2845 #endif
2846
2847 for (; cb != NULL; cb = cb->next)
2848   {
2849   const uschar *arg;
2850   int control_type;
2851
2852   /* The message and log_message items set up messages to be used in
2853   case of rejection. They are expanded later. */
2854
2855   if (cb->type == ACLC_MESSAGE)
2856     {
2857     HDEBUG(D_acl) debug_printf_indent("  message: %s\n", cb->arg);
2858     user_message = cb->arg;
2859     continue;
2860     }
2861
2862   if (cb->type == ACLC_LOG_MESSAGE)
2863     {
2864     HDEBUG(D_acl) debug_printf_indent("l_message: %s\n", cb->arg);
2865     log_message = cb->arg;
2866     continue;
2867     }
2868
2869   /* The endpass "condition" just sets a flag to show it occurred. This is
2870   checked at compile time to be on an "accept" or "discard" item. */
2871
2872   if (cb->type == ACLC_ENDPASS)
2873     {
2874     *epp = TRUE;
2875     continue;
2876     }
2877
2878   /* For other conditions and modifiers, the argument is expanded now for some
2879   of them, but not for all, because expansion happens down in some lower level
2880   checking functions in some cases. */
2881
2882   if (!conditions[cb->type].expand_at_top)
2883     arg = cb->arg;
2884   else if (!(arg = expand_string(cb->arg)))
2885     {
2886     if (expand_string_forcedfail) continue;
2887     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
2888       cb->arg, expand_string_message);
2889     return search_find_defer ? DEFER : ERROR;
2890     }
2891
2892   /* Show condition, and expanded condition if it's different */
2893
2894   HDEBUG(D_acl)
2895     {
2896     int lhswidth = 0;
2897     debug_printf_indent("check %s%s %n",
2898       (!conditions[cb->type].is_modifier && cb->u.negated)? "!":"",
2899       conditions[cb->type].name, &lhswidth);
2900
2901     if (cb->type == ACLC_SET)
2902       {
2903       debug_printf("acl_%s ", cb->u.varname);
2904       lhswidth += 5 + Ustrlen(cb->u.varname);
2905       }
2906
2907     debug_printf("= %s\n", cb->arg);
2908
2909     if (arg != cb->arg)
2910       debug_printf("%.*s= %s\n", lhswidth,
2911       US"                             ", CS arg);
2912     }
2913
2914   /* Check that this condition makes sense at this time */
2915
2916   if ((conditions[cb->type].forbids & (1 << where)) != 0)
2917     {
2918     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
2919       conditions[cb->type].is_modifier ? "use" : "test",
2920       conditions[cb->type].name, acl_wherenames[where]);
2921     return ERROR;
2922     }
2923
2924   /* Run the appropriate test for each condition, or take the appropriate
2925   action for the remaining modifiers. */
2926
2927   switch(cb->type)
2928     {
2929     case ACLC_ADD_HEADER:
2930     setup_header(arg);
2931     break;
2932
2933     /* A nested ACL that returns "discard" makes sense only for an "accept" or
2934     "discard" verb. */
2935
2936     case ACLC_ACL:
2937       rc = acl_check_wargs(where, addr, arg, user_msgptr, log_msgptr);
2938       if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
2939         {
2940         *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
2941           "\"%s\" command (only allowed with \"accept\" or \"discard\")",
2942           verbs[verb]);
2943         return ERROR;
2944         }
2945     break;
2946
2947     case ACLC_AUTHENTICATED:
2948     rc = (sender_host_authenticated == NULL)? FAIL :
2949       match_isinlist(sender_host_authenticated, &arg, 0, NULL, NULL, MCL_STRING,
2950         TRUE, NULL);
2951     break;
2952
2953     #ifdef EXPERIMENTAL_BRIGHTMAIL
2954     case ACLC_BMI_OPTIN:
2955       {
2956       int old_pool = store_pool;
2957       store_pool = POOL_PERM;
2958       bmi_current_optin = string_copy(arg);
2959       store_pool = old_pool;
2960       }
2961     break;
2962     #endif
2963
2964     case ACLC_CONDITION:
2965     /* The true/false parsing here should be kept in sync with that used in
2966     expand.c when dealing with ECOND_BOOL so that we don't have too many
2967     different definitions of what can be a boolean. */
2968     if (*arg == '-'
2969         ? Ustrspn(arg+1, "0123456789") == Ustrlen(arg+1)    /* Negative number */
2970         : Ustrspn(arg,   "0123456789") == Ustrlen(arg))     /* Digits, or empty */
2971       rc = (Uatoi(arg) == 0)? FAIL : OK;
2972     else
2973       rc = (strcmpic(arg, US"no") == 0 ||
2974             strcmpic(arg, US"false") == 0)? FAIL :
2975            (strcmpic(arg, US"yes") == 0 ||
2976             strcmpic(arg, US"true") == 0)? OK : DEFER;
2977     if (rc == DEFER)
2978       *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
2979     break;
2980
2981     case ACLC_CONTINUE:    /* Always succeeds */
2982     break;
2983
2984     case ACLC_CONTROL:
2985       {
2986       const uschar *p = NULL;
2987       control_type = decode_control(arg, &p, where, log_msgptr);
2988
2989       /* Check if this control makes sense at this time */
2990
2991       if (controls_list[control_type].forbids & (1 << where))
2992         {
2993         *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
2994           controls_list[control_type].name, acl_wherenames[where]);
2995         return ERROR;
2996         }
2997
2998       switch(control_type)
2999         {
3000         case CONTROL_AUTH_UNADVERTISED:
3001         allow_auth_unadvertised = TRUE;
3002         break;
3003
3004         #ifdef EXPERIMENTAL_BRIGHTMAIL
3005         case CONTROL_BMI_RUN:
3006         bmi_run = 1;
3007         break;
3008         #endif
3009
3010         #ifndef DISABLE_DKIM
3011         case CONTROL_DKIM_VERIFY:
3012         dkim_disable_verify = TRUE;
3013         #ifdef EXPERIMENTAL_DMARC
3014         /* Since DKIM was blocked, skip DMARC too */
3015         dmarc_disable_verify = TRUE;
3016         dmarc_enable_forensic = FALSE;
3017         #endif
3018         break;
3019         #endif
3020
3021         #ifdef EXPERIMENTAL_DMARC
3022         case CONTROL_DMARC_VERIFY:
3023         dmarc_disable_verify = TRUE;
3024         break;
3025
3026         case CONTROL_DMARC_FORENSIC:
3027         dmarc_enable_forensic = TRUE;
3028         break;
3029         #endif
3030
3031         case CONTROL_DSCP:
3032         if (*p == '/')
3033           {
3034           int fd, af, level, optname, value;
3035           /* If we are acting on stdin, the setsockopt may fail if stdin is not
3036           a socket; we can accept that, we'll just debug-log failures anyway. */
3037           fd = fileno(smtp_in);
3038           af = ip_get_address_family(fd);
3039           if (af < 0)
3040             {
3041             HDEBUG(D_acl)
3042               debug_printf_indent("smtp input is probably not a socket [%s], not setting DSCP\n",
3043                   strerror(errno));
3044             break;
3045             }
3046           if (dscp_lookup(p+1, af, &level, &optname, &value))
3047             {
3048             if (setsockopt(fd, level, optname, &value, sizeof(value)) < 0)
3049               {
3050               HDEBUG(D_acl) debug_printf_indent("failed to set input DSCP[%s]: %s\n",
3051                   p+1, strerror(errno));
3052               }
3053             else
3054               {
3055               HDEBUG(D_acl) debug_printf_indent("set input DSCP to \"%s\"\n", p+1);
3056               }
3057             }
3058           else
3059             {
3060             *log_msgptr = string_sprintf("unrecognised DSCP value in \"control=%s\"", arg);
3061             return ERROR;
3062             }
3063           }
3064         else
3065           {
3066           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3067           return ERROR;
3068           }
3069         break;
3070
3071         case CONTROL_ERROR:
3072         return ERROR;
3073
3074         case CONTROL_CASEFUL_LOCAL_PART:
3075         deliver_localpart = addr->cc_local_part;
3076         break;
3077
3078         case CONTROL_CASELOWER_LOCAL_PART:
3079         deliver_localpart = addr->lc_local_part;
3080         break;
3081
3082         case CONTROL_ENFORCE_SYNC:
3083         smtp_enforce_sync = TRUE;
3084         break;
3085
3086         case CONTROL_NO_ENFORCE_SYNC:
3087         smtp_enforce_sync = FALSE;
3088         break;
3089
3090         #ifdef WITH_CONTENT_SCAN
3091         case CONTROL_NO_MBOX_UNSPOOL:
3092         no_mbox_unspool = TRUE;
3093         break;
3094         #endif
3095
3096         case CONTROL_NO_MULTILINE:
3097         no_multiline_responses = TRUE;
3098         break;
3099
3100         case CONTROL_NO_PIPELINING:
3101         pipelining_enable = FALSE;
3102         break;
3103
3104         case CONTROL_NO_DELAY_FLUSH:
3105         disable_delay_flush = TRUE;
3106         break;
3107
3108         case CONTROL_NO_CALLOUT_FLUSH:
3109         disable_callout_flush = TRUE;
3110         break;
3111
3112         case CONTROL_FAKEREJECT:
3113         cancel_cutthrough_connection(TRUE, US"fakereject");
3114         case CONTROL_FAKEDEFER:
3115         fake_response = (control_type == CONTROL_FAKEDEFER) ? DEFER : FAIL;
3116         if (*p == '/')
3117           {
3118           const uschar *pp = p + 1;
3119           while (*pp != 0) pp++;
3120           fake_response_text = expand_string(string_copyn(p+1, pp-p-1));
3121           p = pp;
3122           }
3123          else
3124           {
3125           /* Explicitly reset to default string */
3126           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).";
3127           }
3128         break;
3129
3130         case CONTROL_FREEZE:
3131         deliver_freeze = TRUE;
3132         deliver_frozen_at = time(NULL);
3133         freeze_tell = freeze_tell_config;       /* Reset to configured value */
3134         if (Ustrncmp(p, "/no_tell", 8) == 0)
3135           {
3136           p += 8;
3137           freeze_tell = NULL;
3138           }
3139         if (*p != 0)
3140           {
3141           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3142           return ERROR;
3143           }
3144         cancel_cutthrough_connection(TRUE, US"item frozen");
3145         break;
3146
3147         case CONTROL_QUEUE_ONLY:
3148         queue_only_policy = TRUE;
3149         cancel_cutthrough_connection(TRUE, US"queueing forced");
3150         break;
3151
3152         case CONTROL_SUBMISSION:
3153         originator_name = US"";
3154         submission_mode = TRUE;
3155         while (*p == '/')
3156           {
3157           if (Ustrncmp(p, "/sender_retain", 14) == 0)
3158             {
3159             p += 14;
3160             active_local_sender_retain = TRUE;
3161             active_local_from_check = FALSE;
3162             }
3163           else if (Ustrncmp(p, "/domain=", 8) == 0)
3164             {
3165             const uschar *pp = p + 8;
3166             while (*pp != 0 && *pp != '/') pp++;
3167             submission_domain = string_copyn(p+8, pp-p-8);
3168             p = pp;
3169             }
3170           /* The name= option must be last, because it swallows the rest of
3171           the string. */
3172           else if (Ustrncmp(p, "/name=", 6) == 0)
3173             {
3174             const uschar *pp = p + 6;
3175             while (*pp != 0) pp++;
3176             submission_name = string_copy(parse_fix_phrase(p+6, pp-p-6,
3177               big_buffer, big_buffer_size));
3178             p = pp;
3179             }
3180           else break;
3181           }
3182         if (*p != 0)
3183           {
3184           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3185           return ERROR;
3186           }
3187         break;
3188
3189         case CONTROL_DEBUG:
3190           {
3191           uschar * debug_tag = NULL;
3192           uschar * debug_opts = NULL;
3193           BOOL kill = FALSE;
3194
3195           while (*p == '/')
3196             {
3197             const uschar * pp = p+1;
3198             if (Ustrncmp(pp, "tag=", 4) == 0)
3199               {
3200               for (pp += 4; *pp && *pp != '/';) pp++;
3201               debug_tag = string_copyn(p+5, pp-p-5);
3202               }
3203             else if (Ustrncmp(pp, "opts=", 5) == 0)
3204               {
3205               for (pp += 5; *pp && *pp != '/';) pp++;
3206               debug_opts = string_copyn(p+6, pp-p-6);
3207               }
3208             else if (Ustrncmp(pp, "kill", 4) == 0)
3209               {
3210               for (pp += 4; *pp && *pp != '/';) pp++;
3211               kill = TRUE;
3212               }
3213             else
3214               while (*pp && *pp != '/') pp++;
3215             p = pp;
3216             }
3217
3218             if (kill)
3219               debug_logging_stop();
3220             else
3221               debug_logging_activate(debug_tag, debug_opts);
3222           }
3223         break;
3224
3225         case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3226         suppress_local_fixups = TRUE;
3227         break;
3228
3229         case CONTROL_CUTTHROUGH_DELIVERY:
3230 #ifndef DISABLE_PRDR
3231         if (prdr_requested)
3232 #else
3233         if (0)
3234 #endif
3235           /* Too hard to think about for now.  We might in future cutthrough
3236           the case where both sides handle prdr and this-node prdr acl
3237           is "accept" */
3238           *log_msgptr = string_sprintf("PRDR on %s reception\n", arg);
3239         else
3240           {
3241           if (deliver_freeze)
3242             *log_msgptr = US"frozen";
3243           else if (queue_only_policy)
3244             *log_msgptr = US"queue-only";
3245           else if (fake_response == FAIL)
3246             *log_msgptr = US"fakereject";
3247           else
3248             {
3249             if (rcpt_count == 1)
3250               {
3251               cutthrough.delivery = TRUE;
3252               while (*p == '/')
3253                 {
3254                 const uschar * pp = p+1;
3255                 if (Ustrncmp(pp, "defer=", 6) == 0)
3256                   {
3257                   pp += 6;
3258                   if (Ustrncmp(pp, "pass", 4) == 0) cutthrough.defer_pass = TRUE;
3259                   /* else if (Ustrncmp(pp, "spool") == 0) ;     default */
3260                   }
3261                 else
3262                   while (*pp && *pp != '/') pp++;
3263                 p = pp;
3264                 }
3265               }
3266             break;
3267             }
3268           *log_msgptr = string_sprintf("\"control=%s\" on %s item",
3269                                         arg, *log_msgptr);
3270           }
3271         return ERROR;
3272
3273 #ifdef SUPPORT_I18N
3274         case CONTROL_UTF8_DOWNCONVERT:
3275         if (*p == '/')
3276           {
3277           if (p[1] == '1')
3278             {
3279             message_utf8_downconvert = 1;
3280             addr->prop.utf8_downcvt = TRUE;
3281             addr->prop.utf8_downcvt_maybe = FALSE;
3282             p += 2;
3283             break;
3284             }
3285           if (p[1] == '0')
3286             {
3287             message_utf8_downconvert = 0;
3288             addr->prop.utf8_downcvt = FALSE;
3289             addr->prop.utf8_downcvt_maybe = FALSE;
3290             p += 2;
3291             break;
3292             }
3293           if (p[1] == '-' && p[2] == '1')
3294             {
3295             message_utf8_downconvert = -1;
3296             addr->prop.utf8_downcvt = FALSE;
3297             addr->prop.utf8_downcvt_maybe = TRUE;
3298             p += 3;
3299             break;
3300             }
3301           *log_msgptr = US"bad option value for control=utf8_downconvert";
3302           }
3303         else
3304           {
3305           message_utf8_downconvert = 1;
3306           addr->prop.utf8_downcvt = TRUE;
3307           addr->prop.utf8_downcvt_maybe = FALSE;
3308           break;
3309           }
3310         return ERROR;
3311 #endif
3312
3313         }
3314       break;
3315       }
3316
3317     #ifdef EXPERIMENTAL_DCC
3318     case ACLC_DCC:
3319       {
3320       /* Separate the regular expression and any optional parameters. */
3321       const uschar * list = arg;
3322       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3323       /* Run the dcc backend. */
3324       rc = dcc_process(&ss);
3325       /* Modify return code based upon the existence of options. */
3326       while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3327         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3328           rc = FAIL;   /* FAIL so that the message is passed to the next ACL */
3329       }
3330     break;
3331     #endif
3332
3333     #ifdef WITH_CONTENT_SCAN
3334     case ACLC_DECODE:
3335     rc = mime_decode(&arg);
3336     break;
3337     #endif
3338
3339     case ACLC_DELAY:
3340       {
3341       int delay = readconf_readtime(arg, 0, FALSE);
3342       if (delay < 0)
3343         {
3344         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3345           "modifier: \"%s\" is not a time value", arg);
3346         return ERROR;
3347         }
3348       else
3349         {
3350         HDEBUG(D_acl) debug_printf_indent("delay modifier requests %d-second delay\n",
3351           delay);
3352         if (host_checking)
3353           {
3354           HDEBUG(D_acl)
3355             debug_printf_indent("delay skipped in -bh checking mode\n");
3356           }
3357
3358         /* NOTE 1: Remember that we may be
3359         dealing with stdin/stdout here, in addition to TCP/IP connections.
3360         Also, delays may be specified for non-SMTP input, where smtp_out and
3361         smtp_in will be NULL. Whatever is done must work in all cases.
3362
3363         NOTE 2: The added feature of flushing the output before a delay must
3364         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3365         */
3366
3367         else
3368           {
3369           if (smtp_out != NULL && !disable_delay_flush)
3370             mac_smtp_fflush();
3371
3372 #if !defined(NO_POLL_H) && defined (POLLRDHUP)
3373             {
3374             struct pollfd p;
3375             nfds_t n = 0;
3376             if (smtp_out)
3377               {
3378               p.fd = fileno(smtp_out);
3379               p.events = POLLRDHUP;
3380               n = 1;
3381               }
3382             if (poll(&p, n, delay*1000) > 0)
3383               HDEBUG(D_acl) debug_printf_indent("delay cancelled by peer close\n");
3384             }
3385 #else
3386         /* It appears to be impossible to detect that a TCP/IP connection has
3387         gone away without reading from it. This means that we cannot shorten
3388         the delay below if the client goes away, because we cannot discover
3389         that the client has closed its end of the connection. (The connection
3390         is actually in a half-closed state, waiting for the server to close its
3391         end.) It would be nice to be able to detect this state, so that the
3392         Exim process is not held up unnecessarily. However, it seems that we
3393         can't. The poll() function does not do the right thing, and in any case
3394         it is not always available.
3395         */
3396
3397           while (delay > 0) delay = sleep(delay);
3398 #endif
3399           }
3400         }
3401       }
3402     break;
3403
3404     #ifndef DISABLE_DKIM
3405     case ACLC_DKIM_SIGNER:
3406     if (dkim_cur_signer != NULL)
3407       rc = match_isinlist(dkim_cur_signer,
3408                           &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3409     else
3410       rc = FAIL;
3411     break;
3412
3413     case ACLC_DKIM_STATUS:
3414     rc = match_isinlist(dkim_exim_expand_query(DKIM_VERIFY_STATUS),
3415                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3416     break;
3417     #endif
3418
3419     #ifdef EXPERIMENTAL_DMARC
3420     case ACLC_DMARC_STATUS:
3421     if (!dmarc_has_been_checked)
3422       dmarc_process();
3423     dmarc_has_been_checked = TRUE;
3424     /* used long way of dmarc_exim_expand_query() in case we need more
3425      * view into the process in the future. */
3426     rc = match_isinlist(dmarc_exim_expand_query(DMARC_VERIFY_STATUS),
3427                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3428     break;
3429     #endif
3430
3431     case ACLC_DNSLISTS:
3432     rc = verify_check_dnsbl(where, &arg, log_msgptr);
3433     break;
3434
3435     case ACLC_DOMAINS:
3436     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3437       addr->domain_cache, MCL_DOMAIN, TRUE, CUSS &deliver_domain_data);
3438     break;
3439
3440     /* The value in tls_cipher is the full cipher name, for example,
3441     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3442     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3443     what may in practice come out of the SSL library - which at the time of
3444     writing is poorly documented. */
3445
3446     case ACLC_ENCRYPTED:
3447     if (tls_in.cipher == NULL) rc = FAIL; else
3448       {
3449       uschar *endcipher = NULL;
3450       uschar *cipher = Ustrchr(tls_in.cipher, ':');
3451       if (cipher == NULL) cipher = tls_in.cipher; else
3452         {
3453         endcipher = Ustrchr(++cipher, ':');
3454         if (endcipher != NULL) *endcipher = 0;
3455         }
3456       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3457       if (endcipher != NULL) *endcipher = ':';
3458       }
3459     break;
3460
3461     /* Use verify_check_this_host() instead of verify_check_host() so that
3462     we can pass over &host_data to catch any looked up data. Once it has been
3463     set, it retains its value so that it's still there if another ACL verb
3464     comes through here and uses the cache. However, we must put it into
3465     permanent store in case it is also expected to be used in a subsequent
3466     message in the same SMTP connection. */
3467
3468     case ACLC_HOSTS:
3469     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3470       (sender_host_address == NULL)? US"" : sender_host_address,
3471       CUSS &host_data);
3472     if (rc == DEFER) *log_msgptr = search_error_message;
3473     if (host_data) host_data = string_copy_malloc(host_data);
3474     break;
3475
3476     case ACLC_LOCAL_PARTS:
3477     rc = match_isinlist(addr->cc_local_part, &arg, 0,
3478       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3479       CUSS &deliver_localpart_data);
3480     break;
3481
3482     case ACLC_LOG_REJECT_TARGET:
3483       {
3484       int logbits = 0;
3485       int sep = 0;
3486       const uschar *s = arg;
3487       uschar *ss;
3488       while ((ss = string_nextinlist(&s, &sep, big_buffer, big_buffer_size)))
3489         {
3490         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3491         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3492         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3493         else
3494           {
3495           logbits |= LOG_MAIN|LOG_REJECT;
3496           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3497             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3498           }
3499         }
3500       log_reject_target = logbits;
3501       }
3502     break;
3503
3504     case ACLC_LOGWRITE:
3505       {
3506       int logbits = 0;
3507       const uschar *s = arg;
3508       if (*s == ':')
3509         {
3510         s++;
3511         while (*s != ':')
3512           {
3513           if (Ustrncmp(s, "main", 4) == 0)
3514             { logbits |= LOG_MAIN; s += 4; }
3515           else if (Ustrncmp(s, "panic", 5) == 0)
3516             { logbits |= LOG_PANIC; s += 5; }
3517           else if (Ustrncmp(s, "reject", 6) == 0)
3518             { logbits |= LOG_REJECT; s += 6; }
3519           else
3520             {
3521             logbits = LOG_MAIN|LOG_PANIC;
3522             s = string_sprintf(":unknown log name in \"%s\" in "
3523               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3524             }
3525           if (*s == ',') s++;
3526           }
3527         s++;
3528         }
3529       while (isspace(*s)) s++;
3530
3531
3532       if (logbits == 0) logbits = LOG_MAIN;
3533       log_write(0, logbits, "%s", string_printing(s));
3534       }
3535     break;
3536
3537     #ifdef WITH_CONTENT_SCAN
3538     case ACLC_MALWARE:                  /* Run the malware backend. */
3539       {
3540       /* Separate the regular expression and any optional parameters. */
3541       const uschar * list = arg;
3542       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3543       uschar *opt;
3544       BOOL defer_ok = FALSE;
3545       int timeout = 0;
3546
3547       while ((opt = string_nextinlist(&list, &sep, NULL, 0)))
3548         if (strcmpic(opt, US"defer_ok") == 0)
3549           defer_ok = TRUE;
3550         else if (  strncmpic(opt, US"tmo=", 4) == 0
3551                 && (timeout = readconf_readtime(opt+4, '\0', FALSE)) < 0
3552                 )
3553           {
3554           *log_msgptr = string_sprintf("bad timeout value in '%s'", opt);
3555           return ERROR;
3556           }
3557
3558       rc = malware(ss, timeout);
3559       if (rc == DEFER && defer_ok)
3560         rc = FAIL;      /* FAIL so that the message is passed to the next ACL */
3561       }
3562     break;
3563
3564     case ACLC_MIME_REGEX:
3565     rc = mime_regex(&arg);
3566     break;
3567     #endif
3568
3569     case ACLC_QUEUE:
3570     queue_name = string_copy_malloc(arg);
3571     break;
3572
3573     case ACLC_RATELIMIT:
3574     rc = acl_ratelimit(arg, where, log_msgptr);
3575     break;
3576
3577     case ACLC_RECIPIENTS:
3578     rc = match_address_list(CUS addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3579       CUSS &recipient_data);
3580     break;
3581
3582     #ifdef WITH_CONTENT_SCAN
3583     case ACLC_REGEX:
3584     rc = regex(&arg);
3585     break;
3586     #endif
3587
3588     case ACLC_REMOVE_HEADER:
3589     setup_remove_header(arg);
3590     break;
3591
3592     case ACLC_SENDER_DOMAINS:
3593       {
3594       uschar *sdomain;
3595       sdomain = Ustrrchr(sender_address, '@');
3596       sdomain = sdomain ? sdomain + 1 : US"";
3597       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3598         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3599       }
3600     break;
3601
3602     case ACLC_SENDERS:
3603     rc = match_address_list(CUS sender_address, TRUE, TRUE, &arg,
3604       sender_address_cache, -1, 0, CUSS &sender_data);
3605     break;
3606
3607     /* Connection variables must persist forever */
3608
3609     case ACLC_SET:
3610       {
3611       int old_pool = store_pool;
3612       if (  cb->u.varname[0] == 'c'
3613 #ifndef DISABLE_EVENT
3614          || event_name          /* An event is being delivered */
3615 #endif
3616          )
3617         store_pool = POOL_PERM;
3618       acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
3619       store_pool = old_pool;
3620       }
3621     break;
3622
3623     #ifdef WITH_CONTENT_SCAN
3624     case ACLC_SPAM:
3625       {
3626       /* Separate the regular expression and any optional parameters. */
3627       const uschar * list = arg;
3628       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3629       /* Run the spam backend. */
3630       rc = spam(CUSS &ss);
3631       /* Modify return code based upon the existence of options. */
3632       while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
3633             != NULL) {
3634         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3635           {
3636           /* FAIL so that the message is passed to the next ACL */
3637           rc = FAIL;
3638           }
3639         }
3640       }
3641     break;
3642     #endif
3643
3644     #ifdef EXPERIMENTAL_SPF
3645     case ACLC_SPF:
3646       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
3647     break;
3648     case ACLC_SPF_GUESS:
3649       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
3650     break;
3651     #endif
3652
3653     case ACLC_UDPSEND:
3654     rc = acl_udpsend(arg, log_msgptr);
3655     break;
3656
3657     /* If the verb is WARN, discard any user message from verification, because
3658     such messages are SMTP responses, not header additions. The latter come
3659     only from explicit "message" modifiers. However, put the user message into
3660     $acl_verify_message so it can be used in subsequent conditions or modifiers
3661     (until something changes it). */
3662
3663     case ACLC_VERIFY:
3664     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
3665     if (*user_msgptr)
3666       acl_verify_message = *user_msgptr;
3667     if (verb == ACL_WARN) *user_msgptr = NULL;
3668     break;
3669
3670     default:
3671     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
3672       "condition %d", cb->type);
3673     break;
3674     }
3675
3676   /* If a condition was negated, invert OK/FAIL. */
3677
3678   if (!conditions[cb->type].is_modifier && cb->u.negated)
3679     if (rc == OK) rc = FAIL;
3680     else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
3681
3682   if (rc != OK) break;   /* Conditions loop */
3683   }
3684
3685
3686 /* If the result is the one for which "message" and/or "log_message" are used,
3687 handle the values of these modifiers. If there isn't a log message set, we make
3688 it the same as the user message.
3689
3690 "message" is a user message that will be included in an SMTP response. Unless
3691 it is empty, it overrides any previously set user message.
3692
3693 "log_message" is a non-user message, and it adds to any existing non-user
3694 message that is already set.
3695
3696 Most verbs have but a single return for which the messages are relevant, but
3697 for "discard", it's useful to have the log message both when it succeeds and
3698 when it fails. For "accept", the message is used in the OK case if there is no
3699 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
3700 present. */
3701
3702 if (*epp && rc == OK) user_message = NULL;
3703
3704 if (((1<<rc) & msgcond[verb]) != 0)
3705   {
3706   uschar *expmessage;
3707   uschar *old_user_msgptr = *user_msgptr;
3708   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
3709
3710   /* If the verb is "warn", messages generated by conditions (verification or
3711   nested ACLs) are always discarded. This also happens for acceptance verbs
3712   when they actually do accept. Only messages specified at this level are used.
3713   However, the value of an existing message is available in $acl_verify_message
3714   during expansions. */
3715
3716   if (verb == ACL_WARN ||
3717       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
3718     *log_msgptr = *user_msgptr = NULL;
3719
3720   if (user_message != NULL)
3721     {
3722     acl_verify_message = old_user_msgptr;
3723     expmessage = expand_string(user_message);
3724     if (expmessage == NULL)
3725       {
3726       if (!expand_string_forcedfail)
3727         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3728           user_message, expand_string_message);
3729       }
3730     else if (expmessage[0] != 0) *user_msgptr = expmessage;
3731     }
3732
3733   if (log_message != NULL)
3734     {
3735     acl_verify_message = old_log_msgptr;
3736     expmessage = expand_string(log_message);
3737     if (expmessage == NULL)
3738       {
3739       if (!expand_string_forcedfail)
3740         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3741           log_message, expand_string_message);
3742       }
3743     else if (expmessage[0] != 0)
3744       {
3745       *log_msgptr = (*log_msgptr == NULL)? expmessage :
3746         string_sprintf("%s: %s", expmessage, *log_msgptr);
3747       }
3748     }
3749
3750   /* If no log message, default it to the user message */
3751
3752   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
3753   }
3754
3755 acl_verify_message = NULL;
3756 return rc;
3757 }
3758
3759
3760
3761
3762
3763 /*************************************************
3764 *        Get line from a literal ACL             *
3765 *************************************************/
3766
3767 /* This function is passed to acl_read() in order to extract individual lines
3768 of a literal ACL, which we access via static pointers. We can destroy the
3769 contents because this is called only once (the compiled ACL is remembered).
3770
3771 This code is intended to treat the data in the same way as lines in the main
3772 Exim configuration file. That is:
3773
3774   . Leading spaces are ignored.
3775
3776   . A \ at the end of a line is a continuation - trailing spaces after the \
3777     are permitted (this is because I don't believe in making invisible things
3778     significant). Leading spaces on the continued part of a line are ignored.
3779
3780   . Physical lines starting (significantly) with # are totally ignored, and
3781     may appear within a sequence of backslash-continued lines.
3782
3783   . Blank lines are ignored, but will end a sequence of continuations.
3784
3785 Arguments: none
3786 Returns:   a pointer to the next line
3787 */
3788
3789
3790 static uschar *acl_text;          /* Current pointer in the text */
3791 static uschar *acl_text_end;      /* Points one past the terminating '0' */
3792
3793
3794 static uschar *
3795 acl_getline(void)
3796 {
3797 uschar *yield;
3798
3799 /* This loop handles leading blank lines and comments. */
3800
3801 for(;;)
3802   {
3803   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
3804   if (*acl_text == 0) return NULL;         /* No more data */
3805   yield = acl_text;                        /* Potential data line */
3806
3807   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3808
3809   /* If we hit the end before a newline, we have the whole logical line. If
3810   it's a comment, there's no more data to be given. Otherwise, yield it. */
3811
3812   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
3813
3814   /* After reaching a newline, end this loop if the physical line does not
3815   start with '#'. If it does, it's a comment, and the loop continues. */
3816
3817   if (*yield != '#') break;
3818   }
3819
3820 /* This loop handles continuations. We know we have some real data, ending in
3821 newline. See if there is a continuation marker at the end (ignoring trailing
3822 white space). We know that *yield is not white space, so no need to test for
3823 cont > yield in the backwards scanning loop. */
3824
3825 for(;;)
3826   {
3827   uschar *cont;
3828   for (cont = acl_text - 1; isspace(*cont); cont--);
3829
3830   /* If no continuation follows, we are done. Mark the end of the line and
3831   return it. */
3832
3833   if (*cont != '\\')
3834     {
3835     *acl_text++ = 0;
3836     return yield;
3837     }
3838
3839   /* We have encountered a continuation. Skip over whitespace at the start of
3840   the next line, and indeed the whole of the next line or lines if they are
3841   comment lines. */
3842
3843   for (;;)
3844     {
3845     while (*(++acl_text) == ' ' || *acl_text == '\t');
3846     if (*acl_text != '#') break;
3847     while (*(++acl_text) != 0 && *acl_text != '\n');
3848     }
3849
3850   /* We have the start of a continuation line. Move all the rest of the data
3851   to join onto the previous line, and then find its end. If the end is not a
3852   newline, we are done. Otherwise loop to look for another continuation. */
3853
3854   memmove(cont, acl_text, acl_text_end - acl_text);
3855   acl_text_end -= acl_text - cont;
3856   acl_text = cont;
3857   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3858   if (*acl_text == 0) return yield;
3859   }
3860
3861 /* Control does not reach here */
3862 }
3863
3864
3865
3866
3867
3868 /*************************************************
3869 *        Check access using an ACL               *
3870 *************************************************/
3871
3872 /* This function is called from address_check. It may recurse via
3873 acl_check_condition() - hence the use of a level to stop looping. The ACL is
3874 passed as a string which is expanded. A forced failure implies no access check
3875 is required. If the result is a single word, it is taken as the name of an ACL
3876 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
3877 text, complete with newlines, and parsed as such. In both cases, the ACL check
3878 is then run. This function uses an auxiliary function for acl_read() to call
3879 for reading individual lines of a literal ACL. This is acl_getline(), which
3880 appears immediately above.
3881
3882 Arguments:
3883   where        where called from
3884   addr         address item when called from RCPT; otherwise NULL
3885   s            the input string; NULL is the same as an empty ACL => DENY
3886   user_msgptr  where to put a user error (for SMTP response)
3887   log_msgptr   where to put a logging message (not for SMTP response)
3888
3889 Returns:       OK         access is granted
3890                DISCARD    access is apparently granted...
3891                FAIL       access is denied
3892                FAIL_DROP  access is denied; drop the connection
3893                DEFER      can't tell at the moment
3894                ERROR      disaster
3895 */
3896
3897 static int
3898 acl_check_internal(int where, address_item *addr, uschar *s,
3899   uschar **user_msgptr, uschar **log_msgptr)
3900 {
3901 int fd = -1;
3902 acl_block *acl = NULL;
3903 uschar *acl_name = US"inline ACL";
3904 uschar *ss;
3905
3906 /* Catch configuration loops */
3907
3908 if (acl_level > 20)
3909   {
3910   *log_msgptr = US"ACL nested too deep: possible loop";
3911   return ERROR;
3912   }
3913
3914 if (!s)
3915   {
3916   HDEBUG(D_acl) debug_printf_indent("ACL is NULL: implicit DENY\n");
3917   return FAIL;
3918   }
3919
3920 /* At top level, we expand the incoming string. At lower levels, it has already
3921 been expanded as part of condition processing. */
3922
3923 if (acl_level == 0)
3924   {
3925   if (!(ss = expand_string(s)))
3926     {
3927     if (expand_string_forcedfail) return OK;
3928     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
3929       expand_string_message);
3930     return ERROR;
3931     }
3932   }
3933 else ss = s;
3934
3935 while (isspace(*ss))ss++;
3936
3937 /* If we can't find a named ACL, the default is to parse it as an inline one.
3938 (Unless it begins with a slash; non-existent files give rise to an error.) */
3939
3940 acl_text = ss;
3941
3942 /* Handle the case of a string that does not contain any spaces. Look for a
3943 named ACL among those read from the configuration, or a previously read file.
3944 It is possible that the pointer to the ACL is NULL if the configuration
3945 contains a name with no data. If not found, and the text begins with '/',
3946 read an ACL from a file, and save it so it can be re-used. */
3947
3948 if (Ustrchr(ss, ' ') == NULL)
3949   {
3950   tree_node *t = tree_search(acl_anchor, ss);
3951   if (t != NULL)
3952     {
3953     acl = (acl_block *)(t->data.ptr);
3954     if (acl == NULL)
3955       {
3956       HDEBUG(D_acl) debug_printf_indent("ACL \"%s\" is empty: implicit DENY\n", ss);
3957       return FAIL;
3958       }
3959     acl_name = string_sprintf("ACL \"%s\"", ss);
3960     HDEBUG(D_acl) debug_printf_indent("using ACL \"%s\"\n", ss);
3961     }
3962
3963   else if (*ss == '/')
3964     {
3965     struct stat statbuf;
3966     fd = Uopen(ss, O_RDONLY, 0);
3967     if (fd < 0)
3968       {
3969       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
3970         strerror(errno));
3971       return ERROR;
3972       }
3973
3974     if (fstat(fd, &statbuf) != 0)
3975       {
3976       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
3977         strerror(errno));
3978       return ERROR;
3979       }
3980
3981     acl_text = store_get(statbuf.st_size + 1);
3982     acl_text_end = acl_text + statbuf.st_size + 1;
3983
3984     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
3985       {
3986       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
3987         ss, strerror(errno));
3988       return ERROR;
3989       }
3990     acl_text[statbuf.st_size] = 0;
3991     (void)close(fd);
3992
3993     acl_name = string_sprintf("ACL \"%s\"", ss);
3994     HDEBUG(D_acl) debug_printf_indent("read ACL from file %s\n", ss);
3995     }
3996   }
3997
3998 /* Parse an ACL that is still in text form. If it came from a file, remember it
3999 in the ACL tree, having read it into the POOL_PERM store pool so that it
4000 persists between multiple messages. */
4001
4002 if (acl == NULL)
4003   {
4004   int old_pool = store_pool;
4005   if (fd >= 0) store_pool = POOL_PERM;
4006   acl = acl_read(acl_getline, log_msgptr);
4007   store_pool = old_pool;
4008   if (acl == NULL && *log_msgptr != NULL) return ERROR;
4009   if (fd >= 0)
4010     {
4011     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
4012     Ustrcpy(t->name, ss);
4013     t->data.ptr = acl;
4014     (void)tree_insertnode(&acl_anchor, t);
4015     }
4016   }
4017
4018 /* Now we have an ACL to use. It's possible it may be NULL. */
4019
4020 while (acl != NULL)
4021   {
4022   int cond;
4023   int basic_errno = 0;
4024   BOOL endpass_seen = FALSE;
4025   BOOL acl_quit_check = acl_level == 0
4026     && (where == ACL_WHERE_QUIT || where == ACL_WHERE_NOTQUIT);
4027
4028   *log_msgptr = *user_msgptr = NULL;
4029   acl_temp_details = FALSE;
4030
4031   HDEBUG(D_acl) debug_printf_indent("processing \"%s\"\n", verbs[acl->verb]);
4032
4033   /* Clear out any search error message from a previous check before testing
4034   this condition. */
4035
4036   search_error_message = NULL;
4037   cond = acl_check_condition(acl->verb, acl->condition, where, addr, acl_level,
4038     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
4039
4040   /* Handle special returns: DEFER causes a return except on a WARN verb;
4041   ERROR always causes a return. */
4042
4043   switch (cond)
4044     {
4045     case DEFER:
4046     HDEBUG(D_acl) debug_printf_indent("%s: condition test deferred in %s\n", verbs[acl->verb], acl_name);
4047     if (basic_errno != ERRNO_CALLOUTDEFER)
4048       {
4049       if (search_error_message != NULL && *search_error_message != 0)
4050         *log_msgptr = search_error_message;
4051       if (smtp_return_error_details) acl_temp_details = TRUE;
4052       }
4053     else
4054       {
4055       acl_temp_details = TRUE;
4056       }
4057     if (acl->verb != ACL_WARN) return DEFER;
4058     break;
4059
4060     default:      /* Paranoia */
4061     case ERROR:
4062     HDEBUG(D_acl) debug_printf_indent("%s: condition test error in %s\n", verbs[acl->verb], acl_name);
4063     return ERROR;
4064
4065     case OK:
4066     HDEBUG(D_acl) debug_printf_indent("%s: condition test succeeded in %s\n",
4067       verbs[acl->verb], acl_name);
4068     break;
4069
4070     case FAIL:
4071     HDEBUG(D_acl) debug_printf_indent("%s: condition test failed in %s\n", verbs[acl->verb], acl_name);
4072     break;
4073
4074     /* DISCARD and DROP can happen only from a nested ACL condition, and
4075     DISCARD can happen only for an "accept" or "discard" verb. */
4076
4077     case DISCARD:
4078     HDEBUG(D_acl) debug_printf_indent("%s: condition test yielded \"discard\" in %s\n",
4079       verbs[acl->verb], acl_name);
4080     break;
4081
4082     case FAIL_DROP:
4083     HDEBUG(D_acl) debug_printf_indent("%s: condition test yielded \"drop\" in %s\n",
4084       verbs[acl->verb], acl_name);
4085     break;
4086     }
4087
4088   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
4089   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
4090   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
4091
4092   switch(acl->verb)
4093     {
4094     case ACL_ACCEPT:
4095     if (cond == OK || cond == DISCARD)
4096       {
4097       HDEBUG(D_acl) debug_printf_indent("end of %s: ACCEPT\n", acl_name);
4098       return cond;
4099       }
4100     if (endpass_seen)
4101       {
4102       HDEBUG(D_acl) debug_printf_indent("accept: endpass encountered - denying access\n");
4103       return cond;
4104       }
4105     break;
4106
4107     case ACL_DEFER:
4108     if (cond == OK)
4109       {
4110       HDEBUG(D_acl) debug_printf_indent("end of %s: DEFER\n", acl_name);
4111       if (acl_quit_check) goto badquit;
4112       acl_temp_details = TRUE;
4113       return DEFER;
4114       }
4115     break;
4116
4117     case ACL_DENY:
4118     if (cond == OK)
4119       {
4120       HDEBUG(D_acl) debug_printf_indent("end of %s: DENY\n", acl_name);
4121       if (acl_quit_check) goto badquit;
4122       return FAIL;
4123       }
4124     break;
4125
4126     case ACL_DISCARD:
4127     if (cond == OK || cond == DISCARD)
4128       {
4129       HDEBUG(D_acl) debug_printf_indent("end of %s: DISCARD\n", acl_name);
4130       if (acl_quit_check) goto badquit;
4131       return DISCARD;
4132       }
4133     if (endpass_seen)
4134       {
4135       HDEBUG(D_acl) debug_printf_indent("discard: endpass encountered - denying access\n");
4136       return cond;
4137       }
4138     break;
4139
4140     case ACL_DROP:
4141     if (cond == OK)
4142       {
4143       HDEBUG(D_acl) debug_printf_indent("end of %s: DROP\n", acl_name);
4144       if (acl_quit_check) goto badquit;
4145       return FAIL_DROP;
4146       }
4147     break;
4148
4149     case ACL_REQUIRE:
4150     if (cond != OK)
4151       {
4152       HDEBUG(D_acl) debug_printf_indent("end of %s: not OK\n", acl_name);
4153       if (acl_quit_check) goto badquit;
4154       return cond;
4155       }
4156     break;
4157
4158     case ACL_WARN:
4159     if (cond == OK)
4160       acl_warn(where, *user_msgptr, *log_msgptr);
4161     else if (cond == DEFER && LOGGING(acl_warn_skipped))
4162       log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
4163         "condition test deferred%s%s", host_and_ident(TRUE),
4164         (*log_msgptr == NULL)? US"" : US": ",
4165         (*log_msgptr == NULL)? US"" : *log_msgptr);
4166     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
4167     break;
4168
4169     default:
4170     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
4171       acl->verb);
4172     break;
4173     }
4174
4175   /* Pass to the next ACL item */
4176
4177   acl = acl->next;
4178   }
4179
4180 /* We have reached the end of the ACL. This is an implicit DENY. */
4181
4182 HDEBUG(D_acl) debug_printf_indent("end of %s: implicit DENY\n", acl_name);
4183 return FAIL;
4184
4185 badquit:
4186   *log_msgptr = string_sprintf("QUIT or not-QUIT toplevel ACL may not fail "
4187     "('%s' verb used incorrectly)", verbs[acl->verb]);
4188   return ERROR;
4189 }
4190
4191
4192
4193
4194 /* Same args as acl_check_internal() above, but the string s is
4195 the name of an ACL followed optionally by up to 9 space-separated arguments.
4196 The name and args are separately expanded.  Args go into $acl_arg globals. */
4197 static int
4198 acl_check_wargs(int where, address_item *addr, const uschar *s,
4199   uschar **user_msgptr, uschar **log_msgptr)
4200 {
4201 uschar * tmp;
4202 uschar * tmp_arg[9];    /* must match acl_arg[] */
4203 uschar * sav_arg[9];    /* must match acl_arg[] */
4204 int sav_narg;
4205 uschar * name;
4206 int i;
4207 int ret;
4208
4209 if (!(tmp = string_dequote(&s)) || !(name = expand_string(tmp)))
4210   goto bad;
4211
4212 for (i = 0; i < 9; i++)
4213   {
4214   while (*s && isspace(*s)) s++;
4215   if (!*s) break;
4216   if (!(tmp = string_dequote(&s)) || !(tmp_arg[i] = expand_string(tmp)))
4217     {
4218     tmp = name;
4219     goto bad;
4220     }
4221   }
4222
4223 sav_narg = acl_narg;
4224 acl_narg = i;
4225 for (i = 0; i < acl_narg; i++)
4226   {
4227   sav_arg[i] = acl_arg[i];
4228   acl_arg[i] = tmp_arg[i];
4229   }
4230 while (i < 9)
4231   {
4232   sav_arg[i] = acl_arg[i];
4233   acl_arg[i++] = NULL;
4234   }
4235
4236 acl_level++;
4237 ret = acl_check_internal(where, addr, name, user_msgptr, log_msgptr);
4238 acl_level--;
4239
4240 acl_narg = sav_narg;
4241 for (i = 0; i < 9; i++) acl_arg[i] = sav_arg[i];
4242 return ret;
4243
4244 bad:
4245 if (expand_string_forcedfail) return ERROR;
4246 *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
4247   tmp, expand_string_message);
4248 return search_find_defer?DEFER:ERROR;
4249 }
4250
4251
4252
4253 /*************************************************
4254 *        Check access using an ACL               *
4255 *************************************************/
4256
4257 /* Alternate interface for ACL, used by expansions */
4258 int
4259 acl_eval(int where, uschar *s, uschar **user_msgptr, uschar **log_msgptr)
4260 {
4261 address_item adb;
4262 address_item *addr = NULL;
4263 int rc;
4264
4265 *user_msgptr = *log_msgptr = NULL;
4266 sender_verified_failed = NULL;
4267 ratelimiters_cmd = NULL;
4268 log_reject_target = LOG_MAIN|LOG_REJECT;
4269
4270 if (where == ACL_WHERE_RCPT)
4271   {
4272   adb = address_defaults;
4273   addr = &adb;
4274   addr->address = expand_string(US"$local_part@$domain");
4275   addr->domain = deliver_domain;
4276   addr->local_part = deliver_localpart;
4277   addr->cc_local_part = deliver_localpart;
4278   addr->lc_local_part = deliver_localpart;
4279   }
4280
4281 acl_level++;
4282 rc = acl_check_internal(where, addr, s, user_msgptr, log_msgptr);
4283 acl_level--;
4284 return rc;
4285 }
4286
4287
4288
4289 /* This is the external interface for ACL checks. It sets up an address and the
4290 expansions for $domain and $local_part when called after RCPT, then calls
4291 acl_check_internal() to do the actual work.
4292
4293 Arguments:
4294   where        ACL_WHERE_xxxx indicating where called from
4295   recipient    RCPT address for RCPT check, else NULL
4296   s            the input string; NULL is the same as an empty ACL => DENY
4297   user_msgptr  where to put a user error (for SMTP response)
4298   log_msgptr   where to put a logging message (not for SMTP response)
4299
4300 Returns:       OK         access is granted by an ACCEPT verb
4301                DISCARD    access is granted by a DISCARD verb
4302                FAIL       access is denied
4303                FAIL_DROP  access is denied; drop the connection
4304                DEFER      can't tell at the moment
4305                ERROR      disaster
4306 */
4307 int acl_where = ACL_WHERE_UNKNOWN;
4308
4309 int
4310 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
4311   uschar **log_msgptr)
4312 {
4313 int rc;
4314 address_item adb;
4315 address_item *addr = NULL;
4316
4317 *user_msgptr = *log_msgptr = NULL;
4318 sender_verified_failed = NULL;
4319 ratelimiters_cmd = NULL;
4320 log_reject_target = LOG_MAIN|LOG_REJECT;
4321
4322 #ifndef DISABLE_PRDR
4323 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY || where==ACL_WHERE_PRDR)
4324 #else
4325 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY)
4326 #endif
4327   {
4328   adb = address_defaults;
4329   addr = &adb;
4330   addr->address = recipient;
4331   if (deliver_split_address(addr) == DEFER)
4332     {
4333     *log_msgptr = US"defer in percent_hack_domains check";
4334     return DEFER;
4335     }
4336 #ifdef SUPPORT_I18N
4337   if ((addr->prop.utf8_msg = message_smtputf8))
4338     {
4339     addr->prop.utf8_downcvt =       message_utf8_downconvert == 1;
4340     addr->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
4341     }
4342 #endif
4343   deliver_domain = addr->domain;
4344   deliver_localpart = addr->local_part;
4345   }
4346
4347 acl_where = where;
4348 acl_level = 0;
4349 rc = acl_check_internal(where, addr, s, user_msgptr, log_msgptr);
4350 acl_level = 0;
4351 acl_where = ACL_WHERE_UNKNOWN;
4352
4353 /* Cutthrough - if requested,
4354 and WHERE_RCPT and not yet opened conn as result of recipient-verify,
4355 and rcpt acl returned accept,
4356 and first recipient (cancel on any subsequents)
4357 open one now and run it up to RCPT acceptance.
4358 A failed verify should cancel cutthrough request,
4359 and will pass the fail to the originator.
4360 Initial implementation:  dual-write to spool.
4361 Assume the rxd datastream is now being copied byte-for-byte to an open cutthrough connection.
4362
4363 Cease cutthrough copy on rxd final dot; do not send one.
4364
4365 On a data acl, if not accept and a cutthrough conn is open, hard-close it (no SMTP niceness).
4366
4367 On data acl accept, terminate the dataphase on an open cutthrough conn.  If accepted or
4368 perm-rejected, reflect that to the original sender - and dump the spooled copy.
4369 If temp-reject, close the conn (and keep the spooled copy).
4370 If conn-failure, no action (and keep the spooled copy).
4371 */
4372 switch (where)
4373   {
4374   case ACL_WHERE_RCPT:
4375 #ifndef DISABLE_PRDR
4376   case ACL_WHERE_PRDR:
4377 #endif
4378
4379     if (host_checking_callout)  /* -bhc mode */
4380       cancel_cutthrough_connection(TRUE, US"host-checking mode");
4381
4382     else if (  rc == OK
4383             && cutthrough.delivery
4384             && rcpt_count > cutthrough.nrcpt
4385             && (rc = open_cutthrough_connection(addr)) == DEFER
4386             )
4387       if (cutthrough.defer_pass)
4388         {
4389         uschar * s = addr->message;
4390         /* Horrid kludge to recover target's SMTP message */
4391         while (*s) s++;
4392         do --s; while (!isdigit(*s));
4393         if (*--s && isdigit(*s) && *--s && isdigit(*s)) *user_msgptr = s;
4394         acl_temp_details = TRUE;
4395         }
4396       else
4397         {
4398         HDEBUG(D_acl) debug_printf_indent("cutthrough defer; will spool\n");
4399         rc = OK;
4400         }
4401     break;
4402
4403   case ACL_WHERE_PREDATA:
4404     if (rc == OK)
4405       cutthrough_predata();
4406     else
4407       cancel_cutthrough_connection(TRUE, US"predata acl not ok");
4408     break;
4409
4410   case ACL_WHERE_QUIT:
4411   case ACL_WHERE_NOTQUIT:
4412     /* Drop cutthrough conns, and drop heldopen verify conns if
4413     the previous was not DATA */
4414     {
4415     uschar prev = smtp_connection_had[smtp_ch_index-2];
4416     BOOL dropverify = !(prev == SCH_DATA || prev == SCH_BDAT);
4417
4418     cancel_cutthrough_connection(dropverify, US"quit or conndrop");
4419     break;
4420     }
4421
4422   default:
4423     break;
4424   }
4425
4426 deliver_domain = deliver_localpart = deliver_address_data =
4427   sender_address_data = NULL;
4428
4429 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
4430 ACL, which is really in the middle of an SMTP command. */
4431
4432 if (rc == DISCARD)
4433   {
4434   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
4435     {
4436     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
4437       "ACL", acl_wherenames[where]);
4438     return ERROR;
4439     }
4440   return DISCARD;
4441   }
4442
4443 /* A DROP response is not permitted from MAILAUTH */
4444
4445 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
4446   {
4447   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
4448     "ACL", acl_wherenames[where]);
4449   return ERROR;
4450   }
4451
4452 /* Before giving a response, take a look at the length of any user message, and
4453 split it up into multiple lines if possible. */
4454
4455 *user_msgptr = string_split_message(*user_msgptr);
4456 if (fake_response != OK)
4457   fake_response_text = string_split_message(fake_response_text);
4458
4459 return rc;
4460 }
4461
4462
4463 /*************************************************
4464 *             Create ACL variable                *
4465 *************************************************/
4466
4467 /* Create an ACL variable or reuse an existing one. ACL variables are in a
4468 binary tree (see tree.c) with acl_var_c and acl_var_m as root nodes.
4469
4470 Argument:
4471   name    pointer to the variable's name, starting with c or m
4472
4473 Returns   the pointer to variable's tree node
4474 */
4475
4476 tree_node *
4477 acl_var_create(uschar * name)
4478 {
4479 tree_node * node, ** root = name[0] == 'c' ? &acl_var_c : &acl_var_m;
4480 if (!(node = tree_search(*root, name)))
4481   {
4482   node = store_get(sizeof(tree_node) + Ustrlen(name));
4483   Ustrcpy(node->name, name);
4484   (void)tree_insertnode(root, node);
4485   }
4486 node->data.ptr = NULL;
4487 return node;
4488 }
4489
4490
4491
4492 /*************************************************
4493 *       Write an ACL variable in spool format    *
4494 *************************************************/
4495
4496 /* This function is used as a callback for tree_walk when writing variables to
4497 the spool file. To retain spool file compatibility, what is written is -aclc or
4498 -aclm followed by the rest of the name and the data length, space separated,
4499 then the value itself, starting on a new line, and terminated by an additional
4500 newline. When we had only numbered ACL variables, the first line might look
4501 like this: "-aclc 5 20". Now it might be "-aclc foo 20" for the variable called
4502 acl_cfoo.
4503
4504 Arguments:
4505   name    of the variable
4506   value   of the variable
4507   ctx     FILE pointer (as a void pointer)
4508
4509 Returns:  nothing
4510 */
4511
4512 void
4513 acl_var_write(uschar *name, uschar *value, void *ctx)
4514 {
4515 FILE *f = (FILE *)ctx;
4516 fprintf(f, "-acl%c %s %d\n%s\n", name[0], name+1, Ustrlen(value), value);
4517 }
4518
4519 /* vi: aw ai sw=2
4520 */
4521 /* End of acl.c */