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