src/src/acl.c

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