src/src/acl.c

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