src/src/acl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
   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, 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 = 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, 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 != NULL && 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 != NULL &&
1163       sender_verified_failed->message != NULL &&
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 != '\0') ++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   GETSHORT(priority, p);
1445   GETSHORT(weight, p);
1446   GETSHORT(port, p);
1447
1448   DEBUG(D_acl)
1449     debug_printf_indent("CSA priority=%d weight=%d port=%d\n", priority, weight, port);
1450
1451   /* Check the CSA version number */
1452
1453   if (priority != 1) continue;
1454
1455   /* If the domain does not have a CSA SRV record of its own (i.e. the domain
1456   found by dns_special_lookup() is a parent of the one we asked for), we check
1457   the subdomain assertions in the port field. At the moment there's only one
1458   assertion: legitimate SMTP clients are all explicitly authorized with CSA
1459   SRV records of their own. */
1460
1461   if (Ustrcmp(found, domain) != 0)
1462     {
1463     yield = port & 1 ? CSA_FAIL_EXPLICIT : CSA_UNKNOWN;
1464     goto out;
1465     }
1466
1467   /* This CSA SRV record refers directly to our domain, so we check the value
1468   in the weight field to work out the domain's authorization. 0 and 1 are
1469   unauthorized; 3 means the client is authorized but we can't check the IP
1470   address in order to authenticate it, so we treat it as unknown; values
1471   greater than 3 are undefined. */
1472
1473   if (weight < 2)
1474     {
1475     yield = CSA_FAIL_DOMAIN;
1476     goto out;
1477     }
1478
1479   if (weight > 2) continue;
1480
1481   /* Weight == 2, which means the domain is authorized. We must check that the
1482   client's IP address is listed as one of the SRV target addresses. Save the
1483   target hostname then break to scan the additional data for its addresses. */
1484
1485   (void)dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, p,
1486     (DN_EXPAND_ARG4_TYPE)target, TARGET_SIZE);
1487
1488   DEBUG(D_acl) debug_printf_indent("CSA target is %s\n", target);
1489
1490   break;
1491   }
1492
1493 /* If we didn't break the loop then no appropriate records were found. */
1494
1495 if (!rr)
1496   {
1497   yield = CSA_UNKNOWN;
1498   goto out;
1499   }
1500
1501 /* Do not check addresses if the target is ".", in accordance with RFC 2782.
1502 A target of "." indicates there are no valid addresses, so the client cannot
1503 be authorized. (This is an odd configuration because weight=2 target=. is
1504 equivalent to weight=1, but we check for it in order to keep load off the
1505 root name servers.) Note that dn_expand() turns "." into "". */
1506
1507 if (Ustrcmp(target, "") == 0)
1508   {
1509   yield = CSA_FAIL_NOADDR;
1510   goto out;
1511   }
1512
1513 /* Scan the additional section of the CSA SRV reply for addresses belonging
1514 to the target. If the name server didn't return any additional data (e.g.
1515 because it does not fully support SRV records), we need to do another lookup
1516 to obtain the target addresses; otherwise we have a definitive result. */
1517
1518 rc = acl_verify_csa_address(dnsa, &dnss, RESET_ADDITIONAL, target);
1519 if (rc != CSA_FAIL_NOADDR)
1520   {
1521   yield = rc;
1522   goto out;
1523   }
1524
1525 /* The DNS lookup type corresponds to the IP version used by the client. */
1526
1527 #if HAVE_IPV6
1528 if (Ustrchr(sender_host_address, ':') != NULL)
1529   type = T_AAAA;
1530 else
1531 #endif /* HAVE_IPV6 */
1532   type = T_A;
1533
1534
1535 lookup_dnssec_authenticated = NULL;
1536 switch (dns_lookup(dnsa, target, type, NULL))
1537   {
1538   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1539
1540   default:
1541     yield = CSA_DEFER_ADDR;
1542     break;
1543
1544   /* If the query succeeded, scan the addresses and return the result. */
1545
1546   case DNS_SUCCEED:
1547     rc = acl_verify_csa_address(dnsa, &dnss, RESET_ANSWERS, target);
1548     if (rc != CSA_FAIL_NOADDR)
1549       {
1550       yield = rc;
1551       break;
1552       }
1553     /* else fall through */
1554
1555   /* If the target has no IP addresses, the client cannot have an authorized
1556   IP address. However, if the target site uses A6 records (not AAAA records)
1557   we have to do yet another lookup in order to check them. */
1558
1559   case DNS_NOMATCH:
1560   case DNS_NODATA:
1561     yield = CSA_FAIL_NOADDR;
1562     break;
1563   }
1564
1565 out:
1566
1567 store_free_dns_answer(dnsa);
1568 return t->data.val = yield;
1569 }
1570
1571
1572
1573 /*************************************************
1574 *     Handle verification (address & other)      *
1575 *************************************************/
1576
1577 enum { VERIFY_REV_HOST_LKUP, VERIFY_CERT, VERIFY_HELO, VERIFY_CSA, VERIFY_HDR_SYNTAX,
1578        VERIFY_NOT_BLIND, VERIFY_HDR_SNDR, VERIFY_SNDR, VERIFY_RCPT,
1579        VERIFY_HDR_NAMES_ASCII, VERIFY_ARC
1580   };
1581 typedef struct {
1582   uschar * name;
1583   int      value;
1584   unsigned where_allowed;       /* bitmap */
1585   BOOL     no_options;          /* Never has /option(s) following */
1586   unsigned alt_opt_sep;         /* >0 Non-/ option separator (custom parser) */
1587   } verify_type_t;
1588 static verify_type_t verify_type_list[] = {
1589     /*  name                    value                   where           no-opt opt-sep */
1590     { US"reverse_host_lookup",  VERIFY_REV_HOST_LKUP,   (unsigned)~0,   FALSE, 0 },
1591     { US"certificate",          VERIFY_CERT,            (unsigned)~0,   TRUE,  0 },
1592     { US"helo",                 VERIFY_HELO,            (unsigned)~0,   TRUE,  0 },
1593     { US"csa",                  VERIFY_CSA,             (unsigned)~0,   FALSE, 0 },
1594     { US"header_syntax",        VERIFY_HDR_SYNTAX,      ACL_BITS_HAVEDATA, TRUE, 0 },
1595     { US"not_blind",            VERIFY_NOT_BLIND,       ACL_BITS_HAVEDATA, FALSE, 0 },
1596     { US"header_sender",        VERIFY_HDR_SNDR,        ACL_BITS_HAVEDATA, FALSE, 0 },
1597     { US"sender",               VERIFY_SNDR,            ACL_BIT_MAIL | ACL_BIT_RCPT
1598                         | ACL_BIT_PREDATA | ACL_BIT_DATA | ACL_BIT_NOTSMTP,
1599                                                                                 FALSE, 6 },
1600     { US"recipient",            VERIFY_RCPT,            ACL_BIT_RCPT,   FALSE, 0 },
1601     { US"header_names_ascii",   VERIFY_HDR_NAMES_ASCII, ACL_BITS_HAVEDATA, TRUE, 0 },
1602 #ifdef EXPERIMENTAL_ARC
1603     { US"arc",                  VERIFY_ARC,             ACL_BIT_DATA,   FALSE , 0 },
1604 #endif
1605   };
1606
1607
1608 enum { CALLOUT_DEFER_OK, CALLOUT_NOCACHE, CALLOUT_RANDOM, CALLOUT_USE_SENDER,
1609   CALLOUT_USE_POSTMASTER, CALLOUT_POSTMASTER, CALLOUT_FULLPOSTMASTER,
1610   CALLOUT_MAILFROM, CALLOUT_POSTMASTER_MAILFROM, CALLOUT_MAXWAIT, CALLOUT_CONNECT,
1611   CALLOUT_HOLD, CALLOUT_TIME    /* TIME must be last */
1612   };
1613 typedef struct {
1614   uschar * name;
1615   int      value;
1616   int      flag;
1617   BOOL     has_option;  /* Has =option(s) following */
1618   BOOL     timeval;     /* Has a time value */
1619   } callout_opt_t;
1620 static callout_opt_t callout_opt_list[] = {
1621     /*  name                    value                   flag            has-opt         has-time */
1622     { US"defer_ok",       CALLOUT_DEFER_OK,      0,                             FALSE, FALSE },
1623     { US"no_cache",       CALLOUT_NOCACHE,       vopt_callout_no_cache,         FALSE, FALSE },
1624     { US"random",         CALLOUT_RANDOM,        vopt_callout_random,           FALSE, FALSE },
1625     { US"use_sender",     CALLOUT_USE_SENDER,    vopt_callout_recipsender,      FALSE, FALSE },
1626     { US"use_postmaster", CALLOUT_USE_POSTMASTER,vopt_callout_recippmaster,     FALSE, FALSE },
1627     { US"postmaster_mailfrom",CALLOUT_POSTMASTER_MAILFROM,0,                    TRUE,  FALSE },
1628     { US"postmaster",     CALLOUT_POSTMASTER,    0,                             FALSE, FALSE },
1629     { US"fullpostmaster", CALLOUT_FULLPOSTMASTER,vopt_callout_fullpm,           FALSE, FALSE },
1630     { US"mailfrom",       CALLOUT_MAILFROM,      0,                             TRUE,  FALSE },
1631     { US"maxwait",        CALLOUT_MAXWAIT,       0,                             TRUE,  TRUE },
1632     { US"connect",        CALLOUT_CONNECT,       0,                             TRUE,  TRUE },
1633     { US"hold",           CALLOUT_HOLD,          vopt_callout_hold,             FALSE, FALSE },
1634     { NULL,               CALLOUT_TIME,          0,                             FALSE, TRUE }
1635   };
1636
1637
1638
1639 static int
1640 v_period(const uschar * s, const uschar * arg, uschar ** log_msgptr)
1641 {
1642 int period;
1643 if ((period = readconf_readtime(s, 0, FALSE)) < 0)
1644   {
1645   *log_msgptr = string_sprintf("bad time value in ACL condition "
1646     "\"verify %s\"", arg);
1647   }
1648 return period;
1649 }
1650
1651
1652
1653 static BOOL
1654 sender_helo_verified_internal(void)
1655 {
1656 /* We can test the result of optional HELO verification that might have
1657 occurred earlier. If not, we can attempt the verification now. */
1658
1659 if (!f.helo_verified && !f.helo_verify_failed) smtp_verify_helo();
1660 return f.helo_verified;
1661 }
1662
1663 static int
1664 sender_helo_verified_cond(void)
1665 {
1666 return sender_helo_verified_internal() ? OK : FAIL;
1667 }
1668
1669 uschar *
1670 sender_helo_verified_boolstr(void)
1671 {
1672 return sender_helo_verified_internal() ? US"yes" : US"no";
1673 }
1674
1675
1676
1677 /* This function implements the "verify" condition. It is called when
1678 encountered in any ACL, because some tests are almost always permitted. Some
1679 just don't make sense, and always fail (for example, an attempt to test a host
1680 lookup for a non-TCP/IP message). Others are restricted to certain ACLs.
1681
1682 Arguments:
1683   where        where called from
1684   addr         the recipient address that the ACL is handling, or NULL
1685   arg          the argument of "verify"
1686   user_msgptr  pointer for user message
1687   log_msgptr   pointer for log message
1688   basic_errno  where to put verify errno
1689
1690 Returns:       OK        verification condition succeeded
1691                FAIL      verification failed
1692                DEFER     there was a problem verifying
1693                ERROR     syntax error
1694 */
1695
1696 static int
1697 acl_verify(int where, address_item *addr, const uschar *arg,
1698   uschar **user_msgptr, uschar **log_msgptr, int *basic_errno)
1699 {
1700 int sep = '/';
1701 int callout = -1;
1702 int callout_overall = -1;
1703 int callout_connect = -1;
1704 int verify_options = 0;
1705 int rc;
1706 BOOL verify_header_sender = FALSE;
1707 BOOL defer_ok = FALSE;
1708 BOOL callout_defer_ok = FALSE;
1709 BOOL no_details = FALSE;
1710 BOOL success_on_redirect = FALSE;
1711 BOOL quota = FALSE;
1712 int quota_pos_cache = QUOTA_POS_DEFAULT, quota_neg_cache = QUOTA_NEG_DEFAULT;
1713 address_item *sender_vaddr = NULL;
1714 uschar *verify_sender_address = NULL;
1715 uschar *pm_mailfrom = NULL;
1716 uschar *se_mailfrom = NULL;
1717
1718 /* Some of the verify items have slash-separated options; some do not. Diagnose
1719 an error if options are given for items that don't expect them.
1720 */
1721
1722 uschar *slash = Ustrchr(arg, '/');
1723 const uschar *list = arg;
1724 uschar *ss = string_nextinlist(&list, &sep, NULL, 0);
1725 verify_type_t * vp;
1726
1727 if (!ss) goto BAD_VERIFY;
1728
1729 /* Handle name/address consistency verification in a separate function. */
1730
1731 for (vp = verify_type_list;
1732      CS vp < CS verify_type_list + sizeof(verify_type_list);
1733      vp++
1734     )
1735   if (vp->alt_opt_sep ? strncmpic(ss, vp->name, vp->alt_opt_sep) == 0
1736                       : strcmpic (ss, vp->name) == 0)
1737    break;
1738 if (CS vp >= CS verify_type_list + sizeof(verify_type_list))
1739   goto BAD_VERIFY;
1740
1741 if (vp->no_options && slash)
1742   {
1743   *log_msgptr = string_sprintf("unexpected '/' found in \"%s\" "
1744     "(this verify item has no options)", arg);
1745   return ERROR;
1746   }
1747 if (!(vp->where_allowed & BIT(where)))
1748   {
1749   *log_msgptr = string_sprintf("cannot verify %s in ACL for %s",
1750                   vp->name, acl_wherenames[where]);
1751   return ERROR;
1752   }
1753 switch(vp->value)
1754   {
1755   case VERIFY_REV_HOST_LKUP:
1756     if (!sender_host_address) return OK;
1757     if ((rc = acl_verify_reverse(user_msgptr, log_msgptr)) == DEFER)
1758       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
1759         if (strcmpic(ss, US"defer_ok") == 0)
1760           return OK;
1761     return rc;
1762
1763   case VERIFY_CERT:
1764     /* TLS certificate verification is done at STARTTLS time; here we just
1765     test whether it was successful or not. (This is for optional verification; for
1766     mandatory verification, the connection doesn't last this long.) */
1767
1768     if (tls_in.certificate_verified) return OK;
1769     *user_msgptr = US"no verified certificate";
1770     return FAIL;
1771
1772   case VERIFY_HELO:
1773     return sender_helo_verified_cond();
1774
1775   case VERIFY_CSA:
1776     /* Do Client SMTP Authorization checks in a separate function, and turn the
1777     result code into user-friendly strings. */
1778
1779     rc = acl_verify_csa(list);
1780     *log_msgptr = *user_msgptr = string_sprintf("client SMTP authorization %s",
1781                                               csa_reason_string[rc]);
1782     csa_status = csa_status_string[rc];
1783     DEBUG(D_acl) debug_printf_indent("CSA result %s\n", csa_status);
1784     return csa_return_code[rc];
1785
1786 #ifdef EXPERIMENTAL_ARC
1787   case VERIFY_ARC:
1788     {   /* Do Authenticated Received Chain checks in a separate function. */
1789     const uschar * condlist = CUS string_nextinlist(&list, &sep, NULL, 0);
1790     int csep = 0;
1791     uschar * cond;
1792
1793     if (!(arc_state = acl_verify_arc())) return DEFER;
1794     DEBUG(D_acl) debug_printf_indent("ARC verify result %s %s%s%s\n", arc_state,
1795       arc_state_reason ? "(":"", arc_state_reason, arc_state_reason ? ")":"");
1796
1797     if (!condlist) condlist = US"none:pass";
1798     while ((cond = string_nextinlist(&condlist, &csep, NULL, 0)))
1799       if (Ustrcmp(arc_state, cond) == 0) return OK;
1800     return FAIL;
1801     }
1802 #endif
1803
1804   case VERIFY_HDR_SYNTAX:
1805     /* Check that all relevant header lines have the correct 5322-syntax. If there is
1806     a syntax error, we return details of the error to the sender if configured to
1807     send out full details. (But a "message" setting on the ACL can override, as
1808     always). */
1809
1810     rc = verify_check_headers(log_msgptr);
1811     if (rc != OK && *log_msgptr)
1812       if (smtp_return_error_details)
1813         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1814       else
1815         acl_verify_message = *log_msgptr;
1816     return rc;
1817
1818   case VERIFY_HDR_NAMES_ASCII:
1819     /* Check that all header names are true 7 bit strings
1820     See RFC 5322, 2.2. and RFC 6532, 3. */
1821
1822     rc = verify_check_header_names_ascii(log_msgptr);
1823     if (rc != OK && smtp_return_error_details && *log_msgptr)
1824       *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1825     return rc;
1826
1827   case VERIFY_NOT_BLIND:
1828     /* Check that no recipient of this message is "blind", that is, every envelope
1829     recipient must be mentioned in either To: or Cc:. */
1830     {
1831     BOOL case_sensitive = TRUE;
1832
1833     while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
1834       if (strcmpic(ss, US"case_insensitive") == 0)
1835         case_sensitive = FALSE;
1836       else
1837         {
1838         *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
1839            "condition \"verify %s\"", ss, arg);
1840         return ERROR;
1841         }
1842
1843     if ((rc = verify_check_notblind(case_sensitive)) != OK)
1844       {
1845       *log_msgptr = US"bcc recipient detected";
1846       if (smtp_return_error_details)
1847         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1848       }
1849     return rc;
1850     }
1851
1852   /* The remaining verification tests check recipient and sender addresses,
1853   either from the envelope or from the header. There are a number of
1854   slash-separated options that are common to all of them. */
1855
1856   case VERIFY_HDR_SNDR:
1857     verify_header_sender = TRUE;
1858     break;
1859
1860   case VERIFY_SNDR:
1861     /* In the case of a sender, this can optionally be followed by an address to use
1862     in place of the actual sender (rare special-case requirement). */
1863     {
1864     uschar *s = ss + 6;
1865     if (!*s)
1866       verify_sender_address = sender_address;
1867     else
1868       {
1869       while (isspace(*s)) s++;
1870       if (*s++ != '=') goto BAD_VERIFY;
1871       while (isspace(*s)) s++;
1872       verify_sender_address = string_copy(s);
1873       }
1874     }
1875     break;
1876
1877   case VERIFY_RCPT:
1878     break;
1879   }
1880
1881
1882
1883 /* Remaining items are optional; they apply to sender and recipient
1884 verification, including "header sender" verification. */
1885
1886 while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
1887   {
1888   if (strcmpic(ss, US"defer_ok") == 0) defer_ok = TRUE;
1889   else if (strcmpic(ss, US"no_details") == 0) no_details = TRUE;
1890   else if (strcmpic(ss, US"success_on_redirect") == 0) success_on_redirect = TRUE;
1891
1892   /* These two old options are left for backwards compatibility */
1893
1894   else if (strcmpic(ss, US"callout_defer_ok") == 0)
1895     {
1896     callout_defer_ok = TRUE;
1897     if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1898     }
1899
1900   else if (strcmpic(ss, US"check_postmaster") == 0)
1901      {
1902      pm_mailfrom = US"";
1903      if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1904      }
1905
1906   /* The callout option has a number of sub-options, comma separated */
1907
1908   else if (strncmpic(ss, US"callout", 7) == 0)
1909     {
1910     callout = CALLOUT_TIMEOUT_DEFAULT;
1911     if (*(ss += 7))
1912       {
1913       while (isspace(*ss)) ss++;
1914       if (*ss++ == '=')
1915         {
1916         const uschar * sublist = ss;
1917         int optsep = ',';
1918
1919         while (isspace(*sublist)) sublist++;
1920         for (uschar * opt; opt = string_nextinlist(&sublist, &optsep, NULL, 0); )
1921           {
1922           callout_opt_t * op;
1923           double period = 1.0F;
1924
1925           for (op= callout_opt_list; op->name; op++)
1926             if (strncmpic(opt, op->name, Ustrlen(op->name)) == 0)
1927               break;
1928
1929           verify_options |= op->flag;
1930           if (op->has_option)
1931             {
1932             opt += Ustrlen(op->name);
1933             while (isspace(*opt)) opt++;
1934             if (*opt++ != '=')
1935               {
1936               *log_msgptr = string_sprintf("'=' expected after "
1937                 "\"%s\" in ACL verify condition \"%s\"", op->name, arg);
1938               return ERROR;
1939               }
1940             while (isspace(*opt)) opt++;
1941             }
1942           if (op->timeval && (period = v_period(opt, arg, log_msgptr)) < 0)
1943             return ERROR;
1944
1945           switch(op->value)
1946             {
1947             case CALLOUT_DEFER_OK:              callout_defer_ok = TRUE; break;
1948             case CALLOUT_POSTMASTER:            pm_mailfrom = US"";     break;
1949             case CALLOUT_FULLPOSTMASTER:        pm_mailfrom = US"";     break;
1950             case CALLOUT_MAILFROM:
1951               if (!verify_header_sender)
1952                 {
1953                 *log_msgptr = string_sprintf("\"mailfrom\" is allowed as a "
1954                   "callout option only for verify=header_sender (detected in ACL "
1955                   "condition \"%s\")", arg);
1956                 return ERROR;
1957                 }
1958               se_mailfrom = string_copy(opt);
1959               break;
1960             case CALLOUT_POSTMASTER_MAILFROM:   pm_mailfrom = string_copy(opt); break;
1961             case CALLOUT_MAXWAIT:               callout_overall = period;       break;
1962             case CALLOUT_CONNECT:               callout_connect = period;       break;
1963             case CALLOUT_TIME:                  callout = period;               break;
1964             }
1965           }
1966         }
1967       else
1968         {
1969         *log_msgptr = string_sprintf("'=' expected after \"callout\" in "
1970           "ACL condition \"%s\"", arg);
1971         return ERROR;
1972         }
1973       }
1974     }
1975
1976   /* The quota option has sub-options, comma-separated */
1977
1978   else if (strncmpic(ss, US"quota", 5) == 0)
1979     {
1980     quota = TRUE;
1981     if (*(ss += 5))
1982       {
1983       while (isspace(*ss)) ss++;
1984       if (*ss++ == '=')
1985         {
1986         const uschar * sublist = ss;
1987         int optsep = ',';
1988         int period;
1989
1990         while (isspace(*sublist)) sublist++;
1991         for (uschar * opt; opt = string_nextinlist(&sublist, &optsep, NULL, 0); )
1992           if (Ustrncmp(opt, "cachepos=", 9) == 0)
1993             if ((period = v_period(opt += 9, arg, log_msgptr)) < 0)
1994               return ERROR;
1995             else
1996               quota_pos_cache = period;
1997           else if (Ustrncmp(opt, "cacheneg=", 9) == 0)
1998             if ((period = v_period(opt += 9, arg, log_msgptr)) < 0)
1999               return ERROR;
2000             else
2001               quota_neg_cache = period;
2002           else if (Ustrcmp(opt, "no_cache") == 0)
2003             quota_pos_cache = quota_neg_cache = 0;
2004         }
2005       }
2006     }
2007
2008   /* Option not recognized */
2009
2010   else
2011     {
2012     *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
2013       "condition \"verify %s\"", ss, arg);
2014     return ERROR;
2015     }
2016   }
2017
2018 if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)) ==
2019       (vopt_callout_recipsender|vopt_callout_recippmaster))
2020   {
2021   *log_msgptr = US"only one of use_sender and use_postmaster can be set "
2022     "for a recipient callout";
2023   return ERROR;
2024   }
2025
2026 /* Handle quota verification */
2027 if (quota)
2028   {
2029   if (vp->value != VERIFY_RCPT)
2030     {
2031     *log_msgptr = US"can only verify quota of recipient";
2032     return ERROR;
2033     }
2034
2035   if ((rc = verify_quota_call(addr->address,
2036               quota_pos_cache, quota_neg_cache, log_msgptr)) != OK)
2037     {
2038     *basic_errno = errno;
2039     if (smtp_return_error_details)
2040       {
2041       if (!*user_msgptr && *log_msgptr)
2042         *user_msgptr = string_sprintf("Rejected after %s: %s",
2043             smtp_names[smtp_connection_had[SMTP_HBUFF_PREV(smtp_ch_index)]],
2044             *log_msgptr);
2045       if (rc == DEFER) f.acl_temp_details = TRUE;
2046       }
2047     }
2048
2049   return rc;
2050   }
2051
2052 /* Handle sender-in-header verification. Default the user message to the log
2053 message if giving out verification details. */
2054
2055 if (verify_header_sender)
2056   {
2057   int verrno;
2058
2059   if ((rc = verify_check_header_address(user_msgptr, log_msgptr, callout,
2060     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, verify_options,
2061     &verrno)) != OK)
2062     {
2063     *basic_errno = verrno;
2064     if (smtp_return_error_details)
2065       {
2066       if (!*user_msgptr && *log_msgptr)
2067         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
2068       if (rc == DEFER) f.acl_temp_details = TRUE;
2069       }
2070     }
2071   }
2072
2073 /* Handle a sender address. The default is to verify *the* sender address, but
2074 optionally a different address can be given, for special requirements. If the
2075 address is empty, we are dealing with a bounce message that has no sender, so
2076 we cannot do any checking. If the real sender address gets rewritten during
2077 verification (e.g. DNS widening), set the flag to stop it being rewritten again
2078 during message reception.
2079
2080 A list of verified "sender" addresses is kept to try to avoid doing to much
2081 work repetitively when there are multiple recipients in a message and they all
2082 require sender verification. However, when callouts are involved, it gets too
2083 complicated because different recipients may require different callout options.
2084 Therefore, we always do a full sender verify when any kind of callout is
2085 specified. Caching elsewhere, for instance in the DNS resolver and in the
2086 callout handling, should ensure that this is not terribly inefficient. */
2087
2088 else if (verify_sender_address)
2089   {
2090   if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)))
2091     {
2092     *log_msgptr = US"use_sender or use_postmaster cannot be used for a "
2093       "sender verify callout";
2094     return ERROR;
2095     }
2096
2097   sender_vaddr = verify_checked_sender(verify_sender_address);
2098   if (   sender_vaddr                           /* Previously checked */
2099       && callout <= 0)                          /* No callout needed this time */
2100     {
2101     /* If the "routed" flag is set, it means that routing worked before, so
2102     this check can give OK (the saved return code value, if set, belongs to a
2103     callout that was done previously). If the "routed" flag is not set, routing
2104     must have failed, so we use the saved return code. */
2105
2106     if (testflag(sender_vaddr, af_verify_routed))
2107       rc = OK;
2108     else
2109       {
2110       rc = sender_vaddr->special_action;
2111       *basic_errno = sender_vaddr->basic_errno;
2112       }
2113     HDEBUG(D_acl) debug_printf_indent("using cached sender verify result\n");
2114     }
2115
2116   /* Do a new verification, and cache the result. The cache is used to avoid
2117   verifying the sender multiple times for multiple RCPTs when callouts are not
2118   specified (see comments above).
2119
2120   The cache is also used on failure to give details in response to the first
2121   RCPT that gets bounced for this reason. However, this can be suppressed by
2122   the no_details option, which sets the flag that says "this detail has already
2123   been sent". The cache normally contains just one address, but there may be
2124   more in esoteric circumstances. */
2125
2126   else
2127     {
2128     BOOL routed = TRUE;
2129     uschar *save_address_data = deliver_address_data;
2130
2131     sender_vaddr = deliver_make_addr(verify_sender_address, TRUE);
2132 #ifdef SUPPORT_I18N
2133     if ((sender_vaddr->prop.utf8_msg = message_smtputf8))
2134       {
2135       sender_vaddr->prop.utf8_downcvt =       message_utf8_downconvert == 1;
2136       sender_vaddr->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
2137       }
2138 #endif
2139     if (no_details) setflag(sender_vaddr, af_sverify_told);
2140     if (verify_sender_address[0] != 0)
2141       {
2142       /* If this is the real sender address, save the unrewritten version
2143       for use later in receive. Otherwise, set a flag so that rewriting the
2144       sender in verify_address() does not update sender_address. */
2145
2146       if (verify_sender_address == sender_address)
2147         sender_address_unrewritten = sender_address;
2148       else
2149         verify_options |= vopt_fake_sender;
2150
2151       if (success_on_redirect)
2152         verify_options |= vopt_success_on_redirect;
2153
2154       /* The recipient, qualify, and expn options are never set in
2155       verify_options. */
2156
2157       rc = verify_address(sender_vaddr, NULL, verify_options, callout,
2158         callout_overall, callout_connect, se_mailfrom, pm_mailfrom, &routed);
2159
2160       HDEBUG(D_acl) debug_printf_indent("----------- end verify ------------\n");
2161
2162       if (rc != OK)
2163         *basic_errno = sender_vaddr->basic_errno;
2164       else
2165         DEBUG(D_acl)
2166           if (Ustrcmp(sender_vaddr->address, verify_sender_address) != 0)
2167             debug_printf_indent("sender %s verified ok as %s\n",
2168               verify_sender_address, sender_vaddr->address);
2169           else
2170             debug_printf_indent("sender %s verified ok\n",
2171               verify_sender_address);
2172       }
2173     else
2174       rc = OK;  /* Null sender */
2175
2176     /* Cache the result code */
2177
2178     if (routed) setflag(sender_vaddr, af_verify_routed);
2179     if (callout > 0) setflag(sender_vaddr, af_verify_callout);
2180     sender_vaddr->special_action = rc;
2181     sender_vaddr->next = sender_verified_list;
2182     sender_verified_list = sender_vaddr;
2183
2184     /* Restore the recipient address data, which might have been clobbered by
2185     the sender verification. */
2186
2187     deliver_address_data = save_address_data;
2188     }
2189
2190   /* Put the sender address_data value into $sender_address_data */
2191
2192   sender_address_data = sender_vaddr->prop.address_data;
2193   }
2194
2195 /* A recipient address just gets a straightforward verify; again we must handle
2196 the DEFER overrides. */
2197
2198 else
2199   {
2200   address_item addr2;
2201
2202   if (success_on_redirect)
2203     verify_options |= vopt_success_on_redirect;
2204
2205   /* We must use a copy of the address for verification, because it might
2206   get rewritten. */
2207
2208   addr2 = *addr;
2209   rc = verify_address(&addr2, NULL, verify_options|vopt_is_recipient, callout,
2210     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, NULL);
2211   HDEBUG(D_acl) debug_printf_indent("----------- end verify ------------\n");
2212
2213   *basic_errno = addr2.basic_errno;
2214   *log_msgptr = addr2.message;
2215   *user_msgptr = addr2.user_message ? addr2.user_message : addr2.message;
2216
2217   /* Allow details for temporary error if the address is so flagged. */
2218   if (testflag((&addr2), af_pass_message)) f.acl_temp_details = TRUE;
2219
2220   /* Make $address_data visible */
2221   deliver_address_data = addr2.prop.address_data;
2222   }
2223
2224 /* We have a result from the relevant test. Handle defer overrides first. */
2225
2226 if (  rc == DEFER
2227    && (  defer_ok
2228       || callout_defer_ok && *basic_errno == ERRNO_CALLOUTDEFER
2229    )  )
2230   {
2231   HDEBUG(D_acl) debug_printf_indent("verify defer overridden by %s\n",
2232     defer_ok? "defer_ok" : "callout_defer_ok");
2233   rc = OK;
2234   }
2235
2236 /* If we've failed a sender, set up a recipient message, and point
2237 sender_verified_failed to the address item that actually failed. */
2238
2239 if (rc != OK && verify_sender_address)
2240   {
2241   if (rc != DEFER)
2242     *log_msgptr = *user_msgptr = US"Sender verify failed";
2243   else if (*basic_errno != ERRNO_CALLOUTDEFER)
2244     *log_msgptr = *user_msgptr = US"Could not complete sender verify";
2245   else
2246     {
2247     *log_msgptr = US"Could not complete sender verify callout";
2248     *user_msgptr = smtp_return_error_details? sender_vaddr->user_message :
2249       *log_msgptr;
2250     }
2251
2252   sender_verified_failed = sender_vaddr;
2253   }
2254
2255 /* Verifying an address messes up the values of $domain and $local_part,
2256 so reset them before returning if this is a RCPT ACL. */
2257
2258 if (addr)
2259   {
2260   deliver_domain = addr->domain;
2261   deliver_localpart = addr->local_part;
2262   }
2263 return rc;
2264
2265 /* Syntax errors in the verify argument come here. */
2266
2267 BAD_VERIFY:
2268 *log_msgptr = string_sprintf("expected \"sender[=address]\", \"recipient\", "
2269   "\"helo\", \"header_syntax\", \"header_sender\", \"header_names_ascii\" "
2270   "or \"reverse_host_lookup\" at start of ACL condition "
2271   "\"verify %s\"", arg);
2272 return ERROR;
2273 }
2274
2275
2276
2277
2278 /*************************************************
2279 *        Check argument for control= modifier    *
2280 *************************************************/
2281
2282 /* Called from acl_check_condition() below.
2283 To handle the case "queue_only" we accept an _ in the
2284 initial / option-switch position.
2285
2286 Arguments:
2287   arg         the argument string for control=
2288   pptr        set to point to the terminating character
2289   where       which ACL we are in
2290   log_msgptr  for error messages
2291
2292 Returns:      CONTROL_xxx value
2293 */
2294
2295 static int
2296 decode_control(const uschar *arg, const uschar **pptr, int where, uschar **log_msgptr)
2297 {
2298 int idx, len;
2299 control_def * d;
2300 uschar c;
2301
2302 if (  (idx = find_control(arg, controls_list, nelem(controls_list))) < 0
2303    || (  (c = arg[len = Ustrlen((d = controls_list+idx)->name)]) != 0
2304       && (!d->has_option || c != '/' && c != '_')
2305    )  )
2306   {
2307   *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
2308   return CONTROL_ERROR;
2309   }
2310
2311 *pptr = arg + len;
2312 return idx;
2313 }
2314
2315
2316
2317
2318 /*************************************************
2319 *        Return a ratelimit error                *
2320 *************************************************/
2321
2322 /* Called from acl_ratelimit() below
2323
2324 Arguments:
2325   log_msgptr  for error messages
2326   format      format string
2327   ...         supplementary arguments
2328
2329 Returns:      ERROR
2330 */
2331
2332 static int
2333 ratelimit_error(uschar **log_msgptr, const char *format, ...)
2334 {
2335 va_list ap;
2336 gstring * g =
2337   string_cat(NULL, US"error in arguments to \"ratelimit\" condition: ");
2338
2339 va_start(ap, format);
2340 g = string_vformat(g, SVFMT_EXTEND|SVFMT_REBUFFER, format, ap);
2341 va_end(ap);
2342
2343 gstring_release_unused(g);
2344 *log_msgptr = string_from_gstring(g);
2345 return ERROR;
2346 }
2347
2348
2349
2350
2351 /*************************************************
2352 *            Handle rate limiting                *
2353 *************************************************/
2354
2355 /* Called by acl_check_condition() below to calculate the result
2356 of the ACL ratelimit condition.
2357
2358 Note that the return value might be slightly unexpected: if the
2359 sender's rate is above the limit then the result is OK. This is
2360 similar to the dnslists condition, and is so that you can write
2361 ACL clauses like: defer ratelimit = 15 / 1h
2362
2363 Arguments:
2364   arg         the option string for ratelimit=
2365   where       ACL_WHERE_xxxx indicating which ACL this is
2366   log_msgptr  for error messages
2367
2368 Returns:       OK        - Sender's rate is above limit
2369                FAIL      - Sender's rate is below limit
2370                DEFER     - Problem opening ratelimit database
2371                ERROR     - Syntax error in options.
2372 */
2373
2374 static int
2375 acl_ratelimit(const uschar *arg, int where, uschar **log_msgptr)
2376 {
2377 double limit, period, count;
2378 uschar *ss;
2379 uschar *key = NULL;
2380 uschar *unique = NULL;
2381 int sep = '/';
2382 BOOL leaky = FALSE, strict = FALSE, readonly = FALSE;
2383 BOOL noupdate = FALSE, badacl = FALSE;
2384 int mode = RATE_PER_WHAT;
2385 int old_pool, rc;
2386 tree_node **anchor, *t;
2387 open_db dbblock, *dbm;
2388 int dbdb_size;
2389 dbdata_ratelimit *dbd;
2390 dbdata_ratelimit_unique *dbdb;
2391 struct timeval tv;
2392
2393 /* Parse the first two options and record their values in expansion
2394 variables. These variables allow the configuration to have informative
2395 error messages based on rate limits obtained from a table lookup. */
2396
2397 /* First is the maximum number of messages per period / maximum burst
2398 size, which must be greater than or equal to zero. Zero is useful for
2399 rate measurement as opposed to rate limiting. */
2400
2401 if (!(sender_rate_limit = string_nextinlist(&arg, &sep, NULL, 0)))
2402   return ratelimit_error(log_msgptr, "sender rate limit not set");
2403
2404 limit = Ustrtod(sender_rate_limit, &ss);
2405 if      (tolower(*ss) == 'k') { limit *= 1024.0; ss++; }
2406 else if (tolower(*ss) == 'm') { limit *= 1024.0*1024.0; ss++; }
2407 else if (tolower(*ss) == 'g') { limit *= 1024.0*1024.0*1024.0; ss++; }
2408
2409 if (limit < 0.0 || *ss != '\0')
2410   return ratelimit_error(log_msgptr,
2411     "\"%s\" is not a positive number", sender_rate_limit);
2412
2413 /* Second is the rate measurement period / exponential smoothing time
2414 constant. This must be strictly greater than zero, because zero leads to
2415 run-time division errors. */
2416
2417 period = !(sender_rate_period = string_nextinlist(&arg, &sep, NULL, 0))
2418   ? -1.0 : readconf_readtime(sender_rate_period, 0, FALSE);
2419 if (period <= 0.0)
2420   return ratelimit_error(log_msgptr,
2421     "\"%s\" is not a time value", sender_rate_period);
2422
2423 /* By default we are counting one of something, but the per_rcpt,
2424 per_byte, and count options can change this. */
2425
2426 count = 1.0;
2427
2428 /* Parse the other options. */
2429
2430 while ((ss = string_nextinlist(&arg, &sep, NULL, 0)))
2431   {
2432   if (strcmpic(ss, US"leaky") == 0) leaky = TRUE;
2433   else if (strcmpic(ss, US"strict") == 0) strict = TRUE;
2434   else if (strcmpic(ss, US"noupdate") == 0) noupdate = TRUE;
2435   else if (strcmpic(ss, US"readonly") == 0) readonly = TRUE;
2436   else if (strcmpic(ss, US"per_cmd") == 0) RATE_SET(mode, PER_CMD);
2437   else if (strcmpic(ss, US"per_conn") == 0)
2438     {
2439     RATE_SET(mode, PER_CONN);
2440     if (where == ACL_WHERE_NOTSMTP || where == ACL_WHERE_NOTSMTP_START)
2441       badacl = TRUE;
2442     }
2443   else if (strcmpic(ss, US"per_mail") == 0)
2444     {
2445     RATE_SET(mode, PER_MAIL);
2446     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2447     }
2448   else if (strcmpic(ss, US"per_rcpt") == 0)
2449     {
2450     /* If we are running in the RCPT ACL, then we'll count the recipients
2451     one by one, but if we are running when we have accumulated the whole
2452     list then we'll add them all in one batch. */
2453     if (where == ACL_WHERE_RCPT)
2454       RATE_SET(mode, PER_RCPT);
2455     else if (where >= ACL_WHERE_PREDATA && where <= ACL_WHERE_NOTSMTP)
2456       RATE_SET(mode, PER_ALLRCPTS), count = (double)recipients_count;
2457     else if (where == ACL_WHERE_MAIL || where > ACL_WHERE_NOTSMTP)
2458       RATE_SET(mode, PER_RCPT), badacl = TRUE;
2459     }
2460   else if (strcmpic(ss, US"per_byte") == 0)
2461     {
2462     /* If we have not yet received the message data and there was no SIZE
2463     declaration on the MAIL command, then it's safe to just use a value of
2464     zero and let the recorded rate decay as if nothing happened. */
2465     RATE_SET(mode, PER_MAIL);
2466     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2467     else count = message_size < 0 ? 0.0 : (double)message_size;
2468     }
2469   else if (strcmpic(ss, US"per_addr") == 0)
2470     {
2471     RATE_SET(mode, PER_RCPT);
2472     if (where != ACL_WHERE_RCPT) badacl = TRUE, unique = US"*";
2473     else unique = string_sprintf("%s@%s", deliver_localpart, deliver_domain);
2474     }
2475   else if (strncmpic(ss, US"count=", 6) == 0)
2476     {
2477     uschar *e;
2478     count = Ustrtod(ss+6, &e);
2479     if (count < 0.0 || *e != '\0')
2480       return ratelimit_error(log_msgptr, "\"%s\" is not a positive number", ss);
2481     }
2482   else if (strncmpic(ss, US"unique=", 7) == 0)
2483     unique = string_copy(ss + 7);
2484   else if (!key)
2485     key = string_copy(ss);
2486   else
2487     key = string_sprintf("%s/%s", key, ss);
2488   }
2489
2490 /* Sanity check. When the badacl flag is set the update mode must either
2491 be readonly (which is the default if it is omitted) or, for backwards
2492 compatibility, a combination of noupdate and strict or leaky. */
2493
2494 if (mode == RATE_PER_CLASH)
2495   return ratelimit_error(log_msgptr, "conflicting per_* options");
2496 if (leaky + strict + readonly > 1)
2497   return ratelimit_error(log_msgptr, "conflicting update modes");
2498 if (badacl && (leaky || strict) && !noupdate)
2499   return ratelimit_error(log_msgptr,
2500     "\"%s\" must not have /leaky or /strict option, or cannot be used in %s ACL",
2501     ratelimit_option_string[mode], acl_wherenames[where]);
2502
2503 /* Set the default values of any unset options. In readonly mode we
2504 perform the rate computation without any increment so that its value
2505 decays to eventually allow over-limit senders through. */
2506
2507 if (noupdate) readonly = TRUE, leaky = strict = FALSE;
2508 if (badacl) readonly = TRUE;
2509 if (readonly) count = 0.0;
2510 if (!strict && !readonly) leaky = TRUE;
2511 if (mode == RATE_PER_WHAT) mode = RATE_PER_MAIL;
2512
2513 /* Create the lookup key. If there is no explicit key, use sender_host_address.
2514 If there is no sender_host_address (e.g. -bs or acl_not_smtp) then we simply
2515 omit it. The smoothing constant (sender_rate_period) and the per_xxx options
2516 are added to the key because they alter the meaning of the stored data. */
2517
2518 if (!key)
2519   key = !sender_host_address ? US"" : sender_host_address;
2520
2521 key = string_sprintf("%s/%s/%s%s",
2522   sender_rate_period,
2523   ratelimit_option_string[mode],
2524   unique == NULL ? "" : "unique/",
2525   key);
2526
2527 HDEBUG(D_acl)
2528   debug_printf_indent("ratelimit condition count=%.0f %.1f/%s\n", count, limit, key);
2529
2530 /* See if we have already computed the rate by looking in the relevant tree.
2531 For per-connection rate limiting, store tree nodes and dbdata in the permanent
2532 pool so that they survive across resets. In readonly mode we only remember the
2533 result for the rest of this command in case a later command changes it. After
2534 this bit of logic the code is independent of the per_* mode. */
2535
2536 old_pool = store_pool;
2537
2538 if (readonly)
2539   anchor = &ratelimiters_cmd;
2540 else switch(mode)
2541   {
2542   case RATE_PER_CONN:
2543     anchor = &ratelimiters_conn;
2544     store_pool = POOL_PERM;
2545     break;
2546   case RATE_PER_BYTE:
2547   case RATE_PER_MAIL:
2548   case RATE_PER_ALLRCPTS:
2549     anchor = &ratelimiters_mail;
2550     break;
2551   case RATE_PER_ADDR:
2552   case RATE_PER_CMD:
2553   case RATE_PER_RCPT:
2554     anchor = &ratelimiters_cmd;
2555     break;
2556   default:
2557     anchor = NULL; /* silence an "unused" complaint */
2558     log_write(0, LOG_MAIN|LOG_PANIC_DIE,
2559       "internal ACL error: unknown ratelimit mode %d", mode);
2560     /*NOTREACHED*/
2561     break;
2562   }
2563
2564 if ((t = tree_search(*anchor, key)))
2565   {
2566   dbd = t->data.ptr;
2567   /* The following few lines duplicate some of the code below. */
2568   rc = (dbd->rate < limit)? FAIL : OK;
2569   store_pool = old_pool;
2570   sender_rate = string_sprintf("%.1f", dbd->rate);
2571   HDEBUG(D_acl)
2572     debug_printf_indent("ratelimit found pre-computed rate %s\n", sender_rate);
2573   return rc;
2574   }
2575
2576 /* We aren't using a pre-computed rate, so get a previously recorded rate
2577 from the database, which will be updated and written back if required. */
2578
2579 if (!(dbm = dbfn_open(US"ratelimit", O_RDWR, &dbblock, TRUE, TRUE)))
2580   {
2581   store_pool = old_pool;
2582   sender_rate = NULL;
2583   HDEBUG(D_acl) debug_printf_indent("ratelimit database not available\n");
2584   *log_msgptr = US"ratelimit database not available";
2585   return DEFER;
2586   }
2587 dbdb = dbfn_read_with_length(dbm, key, &dbdb_size);
2588 dbd = NULL;
2589
2590 gettimeofday(&tv, NULL);
2591
2592 if (dbdb)
2593   {
2594   /* Locate the basic ratelimit block inside the DB data. */
2595   HDEBUG(D_acl) debug_printf_indent("ratelimit found key in database\n");
2596   dbd = &dbdb->dbd;
2597
2598   /* Forget the old Bloom filter if it is too old, so that we count each
2599   repeating event once per period. We don't simply clear and re-use the old
2600   filter because we want its size to change if the limit changes. Note that
2601   we keep the dbd pointer for copying the rate into the new data block. */
2602
2603   if(unique && tv.tv_sec > dbdb->bloom_epoch + period)
2604     {
2605     HDEBUG(D_acl) debug_printf_indent("ratelimit discarding old Bloom filter\n");
2606     dbdb = NULL;
2607     }
2608
2609   /* Sanity check. */
2610
2611   if(unique && dbdb_size < sizeof(*dbdb))
2612     {
2613     HDEBUG(D_acl) debug_printf_indent("ratelimit discarding undersize Bloom filter\n");
2614     dbdb = NULL;
2615     }
2616   }
2617
2618 /* Allocate a new data block if the database lookup failed
2619 or the Bloom filter passed its age limit. */
2620
2621 if (!dbdb)
2622   {
2623   if (!unique)
2624     {
2625     /* No Bloom filter. This basic ratelimit block is initialized below. */
2626     HDEBUG(D_acl) debug_printf_indent("ratelimit creating new rate data block\n");
2627     dbdb_size = sizeof(*dbd);
2628     dbdb = store_get(dbdb_size, GET_UNTAINTED);
2629     }
2630   else
2631     {
2632     int extra;
2633     HDEBUG(D_acl) debug_printf_indent("ratelimit creating new Bloom filter\n");
2634
2635     /* See the long comment below for an explanation of the magic number 2.
2636     The filter has a minimum size in case the rate limit is very small;
2637     this is determined by the definition of dbdata_ratelimit_unique. */
2638
2639     extra = (int)limit * 2 - sizeof(dbdb->bloom);
2640     if (extra < 0) extra = 0;
2641     dbdb_size = sizeof(*dbdb) + extra;
2642     dbdb = store_get(dbdb_size, GET_UNTAINTED);
2643     dbdb->bloom_epoch = tv.tv_sec;
2644     dbdb->bloom_size = sizeof(dbdb->bloom) + extra;
2645     memset(dbdb->bloom, 0, dbdb->bloom_size);
2646
2647     /* Preserve any basic ratelimit data (which is our longer-term memory)
2648     by copying it from the discarded block. */
2649
2650     if (dbd)
2651       {
2652       dbdb->dbd = *dbd;
2653       dbd = &dbdb->dbd;
2654       }
2655     }
2656   }
2657
2658 /* If we are counting unique events, find out if this event is new or not.
2659 If the client repeats the event during the current period then it should be
2660 counted. We skip this code in readonly mode for efficiency, because any
2661 changes to the filter will be discarded and because count is already set to
2662 zero. */
2663
2664 if (unique && !readonly)
2665   {
2666   /* We identify unique events using a Bloom filter. (You can find my
2667   notes on Bloom filters at http://fanf.livejournal.com/81696.html)
2668   With the per_addr option, an "event" is a recipient address, though the
2669   user can use the unique option to define their own events. We only count
2670   an event if we have not seen it before.
2671
2672   We size the filter according to the rate limit, which (in leaky mode)
2673   is the limit on the population of the filter. We allow 16 bits of space
2674   per entry (see the construction code above) and we set (up to) 8 of them
2675   when inserting an element (see the loop below). The probability of a false
2676   positive (an event we have not seen before but which we fail to count) is
2677
2678     size    = limit * 16
2679     numhash = 8
2680     allzero = exp(-numhash * pop / size)
2681             = exp(-0.5 * pop / limit)
2682     fpr     = pow(1 - allzero, numhash)
2683
2684   For senders at the limit the fpr is      0.06%    or  1 in 1700
2685   and for senders at half the limit it is  0.0006%  or  1 in 170000
2686
2687   In strict mode the Bloom filter can fill up beyond the normal limit, in
2688   which case the false positive rate will rise. This means that the
2689   measured rate for very fast senders can bogusly drop off after a while.
2690
2691   At twice the limit, the fpr is  2.5%  or  1 in 40
2692   At four times the limit, it is  31%   or  1 in 3.2
2693
2694   It takes ln(pop/limit) periods for an over-limit burst of pop events to
2695   decay below the limit, and if this is more than one then the Bloom filter
2696   will be discarded before the decay gets that far. The false positive rate
2697   at this threshold is 9.3% or 1 in 10.7. */
2698
2699   BOOL seen;
2700   unsigned n, hash, hinc;
2701   uschar md5sum[16];
2702   md5 md5info;
2703
2704   /* Instead of using eight independent hash values, we combine two values
2705   using the formula h1 + n * h2. This does not harm the Bloom filter's
2706   performance, and means the amount of hash we need is independent of the
2707   number of bits we set in the filter. */
2708
2709   md5_start(&md5info);
2710   md5_end(&md5info, unique, Ustrlen(unique), md5sum);
2711   hash = md5sum[0] | md5sum[1] << 8 | md5sum[2] << 16 | md5sum[3] << 24;
2712   hinc = md5sum[4] | md5sum[5] << 8 | md5sum[6] << 16 | md5sum[7] << 24;
2713
2714   /* Scan the bits corresponding to this event. A zero bit means we have
2715   not seen it before. Ensure all bits are set to record this event. */
2716
2717   HDEBUG(D_acl) debug_printf_indent("ratelimit checking uniqueness of %s\n", unique);
2718
2719   seen = TRUE;
2720   for (n = 0; n < 8; n++, hash += hinc)
2721     {
2722     int bit = 1 << (hash % 8);
2723     int byte = (hash / 8) % dbdb->bloom_size;
2724     if ((dbdb->bloom[byte] & bit) == 0)
2725       {
2726       dbdb->bloom[byte] |= bit;
2727       seen = FALSE;
2728       }
2729     }
2730
2731   /* If this event has occurred before, do not count it. */
2732
2733   if (seen)
2734     {
2735     HDEBUG(D_acl) debug_printf_indent("ratelimit event found in Bloom filter\n");
2736     count = 0.0;
2737     }
2738   else
2739     HDEBUG(D_acl) debug_printf_indent("ratelimit event added to Bloom filter\n");
2740   }
2741
2742 /* If there was no previous ratelimit data block for this key, initialize
2743 the new one, otherwise update the block from the database. The initial rate
2744 is what would be computed by the code below for an infinite interval. */
2745
2746 if (!dbd)
2747   {
2748   HDEBUG(D_acl) debug_printf_indent("ratelimit initializing new key's rate data\n");
2749   dbd = &dbdb->dbd;
2750   dbd->time_stamp = tv.tv_sec;
2751   dbd->time_usec = tv.tv_usec;
2752   dbd->rate = count;
2753   }
2754 else
2755   {
2756   /* The smoothed rate is computed using an exponentially weighted moving
2757   average adjusted for variable sampling intervals. The standard EWMA for
2758   a fixed sampling interval is:  f'(t) = (1 - a) * f(t) + a * f'(t - 1)
2759   where f() is the measured value and f'() is the smoothed value.
2760
2761   Old data decays out of the smoothed value exponentially, such that data n
2762   samples old is multiplied by a^n. The exponential decay time constant p
2763   is defined such that data p samples old is multiplied by 1/e, which means
2764   that a = exp(-1/p). We can maintain the same time constant for a variable
2765   sampling interval i by using a = exp(-i/p).
2766
2767   The rate we are measuring is messages per period, suitable for directly
2768   comparing with the limit. The average rate between now and the previous
2769   message is period / interval, which we feed into the EWMA as the sample.
2770
2771   It turns out that the number of messages required for the smoothed rate
2772   to reach the limit when they are sent in a burst is equal to the limit.
2773   This can be seen by analysing the value of the smoothed rate after N
2774   messages sent at even intervals. Let k = (1 - a) * p/i
2775
2776     rate_1 = (1 - a) * p/i + a * rate_0
2777            = k + a * rate_0
2778     rate_2 = k + a * rate_1
2779            = k + a * k + a^2 * rate_0
2780     rate_3 = k + a * k + a^2 * k + a^3 * rate_0
2781     rate_N = rate_0 * a^N + k * SUM(x=0..N-1)(a^x)
2782            = rate_0 * a^N + k * (1 - a^N) / (1 - a)
2783            = rate_0 * a^N + p/i * (1 - a^N)
2784
2785   When N is large, a^N -> 0 so rate_N -> p/i as desired.
2786
2787     rate_N = p/i + (rate_0 - p/i) * a^N
2788     a^N = (rate_N - p/i) / (rate_0 - p/i)
2789     N * -i/p = log((rate_N - p/i) / (rate_0 - p/i))
2790     N = p/i * log((rate_0 - p/i) / (rate_N - p/i))
2791
2792   Numerical analysis of the above equation, setting the computed rate to
2793   increase from rate_0 = 0 to rate_N = limit, shows that for large sending
2794   rates, p/i, the number of messages N = limit. So limit serves as both the
2795   maximum rate measured in messages per period, and the maximum number of
2796   messages that can be sent in a fast burst. */
2797
2798   double this_time = (double)tv.tv_sec
2799                    + (double)tv.tv_usec / 1000000.0;
2800   double prev_time = (double)dbd->time_stamp
2801                    + (double)dbd->time_usec / 1000000.0;
2802
2803   /* We must avoid division by zero, and deal gracefully with the clock going
2804   backwards. If we blunder ahead when time is in reverse then the computed
2805   rate will be bogus. To be safe we clamp interval to a very small number. */
2806
2807   double interval = this_time - prev_time <= 0.0 ? 1e-9
2808                   : this_time - prev_time;
2809
2810   double i_over_p = interval / period;
2811   double a = exp(-i_over_p);
2812
2813   /* Combine the instantaneous rate (period / interval) with the previous rate
2814   using the smoothing factor a. In order to measure sized events, multiply the
2815   instantaneous rate by the count of bytes or recipients etc. */
2816
2817   dbd->time_stamp = tv.tv_sec;
2818   dbd->time_usec = tv.tv_usec;
2819   dbd->rate = (1 - a) * count / i_over_p + a * dbd->rate;
2820
2821   /* When events are very widely spaced the computed rate tends towards zero.
2822   Although this is accurate it turns out not to be useful for our purposes,
2823   especially when the first event after a long silence is the start of a spam
2824   run. A more useful model is that the rate for an isolated event should be the
2825   size of the event per the period size, ignoring the lack of events outside
2826   the current period and regardless of where the event falls in the period. So,
2827   if the interval was so long that the calculated rate is unhelpfully small, we
2828   re-initialize the rate. In the absence of higher-rate bursts, the condition
2829   below is true if the interval is greater than the period. */
2830
2831   if (dbd->rate < count) dbd->rate = count;
2832   }
2833
2834 /* Clients sending at the limit are considered to be over the limit.
2835 This matters for edge cases such as a limit of zero, when the client
2836 should be completely blocked. */
2837
2838 rc = dbd->rate < limit ? FAIL : OK;
2839
2840 /* Update the state if the rate is low or if we are being strict. If we
2841 are in leaky mode and the sender's rate is too high, we do not update
2842 the recorded rate in order to avoid an over-aggressive sender's retry
2843 rate preventing them from getting any email through. If readonly is set,
2844 neither leaky nor strict are set, so we do not do any updates. */
2845
2846 if ((rc == FAIL && leaky) || strict)
2847   {
2848   dbfn_write(dbm, key, dbdb, dbdb_size);
2849   HDEBUG(D_acl) debug_printf_indent("ratelimit db updated\n");
2850   }
2851 else
2852   {
2853   HDEBUG(D_acl) debug_printf_indent("ratelimit db not updated: %s\n",
2854     readonly? "readonly mode" : "over the limit, but leaky");
2855   }
2856
2857 dbfn_close(dbm);
2858
2859 /* Store the result in the tree for future reference.  Take the taint status
2860 from the key for consistency even though it's unlikely we'll ever expand this. */
2861
2862 t = store_get(sizeof(tree_node) + Ustrlen(key), key);
2863 t->data.ptr = dbd;
2864 Ustrcpy(t->name, key);
2865 (void)tree_insertnode(anchor, t);
2866
2867 /* We create the formatted version of the sender's rate very late in
2868 order to ensure that it is done using the correct storage pool. */
2869
2870 store_pool = old_pool;
2871 sender_rate = string_sprintf("%.1f", dbd->rate);
2872
2873 HDEBUG(D_acl)
2874   debug_printf_indent("ratelimit computed rate %s\n", sender_rate);
2875
2876 return rc;
2877 }
2878
2879
2880
2881 /*************************************************
2882 *      Handle a check for previously-seen        *
2883 *************************************************/
2884
2885 /*
2886 ACL clauses like:   seen = -5m / key=$foo / readonly
2887
2888 Return is true for condition-true - but the semantics
2889 depend heavily on the actual use-case.
2890
2891 Negative times test for seen-before, positive for seen-more-recently-than
2892 (the given interval before current time).
2893
2894 All are subject to history not having been cleaned from the DB.
2895
2896 Default for seen-before is to create if not present, and to
2897 update if older than 10d (with the seen-test time).
2898 Default for seen-since is to always create or update.
2899
2900 Options:
2901   key=value.  Default key is $sender_host_address
2902   readonly
2903   write
2904   refresh=<interval>:  update an existing DB entry older than given
2905                         amount.  Default refresh lacking this option is 10d.
2906                         The update sets the record timestamp to the seen-test time.
2907
2908 XXX do we need separate nocreate, noupdate controls?
2909
2910 Arguments:
2911   arg         the option string for seen=
2912   where       ACL_WHERE_xxxx indicating which ACL this is
2913   log_msgptr  for error messages
2914
2915 Returns:       OK        - Condition is true
2916                FAIL      - Condition is false
2917                DEFER     - Problem opening history database
2918                ERROR     - Syntax error in options
2919 */
2920
2921 static int
2922 acl_seen(const uschar * arg, int where, uschar ** log_msgptr)
2923 {
2924 enum { SEEN_DEFAULT, SEEN_READONLY, SEEN_WRITE };
2925
2926 const uschar * list = arg;
2927 int slash = '/', interval, mode = SEEN_DEFAULT, yield = FAIL;
2928 BOOL before;
2929 int refresh = 10 * 24 * 60 * 60;        /* 10 days */
2930 const uschar * ele, * key = sender_host_address;
2931 open_db dbblock, * dbm;
2932 dbdata_seen * dbd;
2933 time_t now;
2934
2935 /* Parse the first element, the time-relation. */
2936
2937 if (!(ele = string_nextinlist(&list, &slash, NULL, 0)))
2938   goto badparse;
2939 if ((before = *ele == '-'))
2940   ele++;
2941 if ((interval = readconf_readtime(ele, 0, FALSE)) < 0)
2942   goto badparse;
2943
2944 /* Remaining elements are options */
2945
2946 while ((ele = string_nextinlist(&list, &slash, NULL, 0)))
2947   if (Ustrncmp(ele, "key=", 4) == 0)
2948     key = ele + 4;
2949   else if (Ustrcmp(ele, "readonly") == 0)
2950     mode = SEEN_READONLY;
2951   else if (Ustrcmp(ele, "write") == 0)
2952     mode = SEEN_WRITE;
2953   else if (Ustrncmp(ele, "refresh=", 8) == 0)
2954     {
2955     if ((refresh = readconf_readtime(ele + 8, 0, FALSE)) < 0)
2956       goto badparse;
2957     }
2958   else
2959     goto badopt;
2960
2961 if (!(dbm = dbfn_open(US"seen", O_RDWR, &dbblock, TRUE, TRUE)))
2962   {
2963   HDEBUG(D_acl) debug_printf_indent("database for 'seen' not available\n");
2964   *log_msgptr = US"database for 'seen' not available";
2965   return DEFER;
2966   }
2967
2968 dbd = dbfn_read_with_length(dbm, key, NULL);
2969 now = time(NULL);
2970 if (dbd)                /* an existing record */
2971   {
2972   time_t diff = now - dbd->time_stamp;  /* time since the record was written */
2973
2974   if (before ? diff >= interval : diff < interval)
2975     yield = OK;
2976
2977   if (mode == SEEN_READONLY)
2978     { HDEBUG(D_acl) debug_printf_indent("seen db not written (readonly)\n"); }
2979   else if (mode == SEEN_WRITE || !before)
2980     {
2981     dbd->time_stamp = now;
2982     dbfn_write(dbm, key, dbd, sizeof(*dbd));
2983     HDEBUG(D_acl) debug_printf_indent("seen db written (update)\n");
2984     }
2985   else if (diff >= refresh)
2986     {
2987     dbd->time_stamp = now - interval;
2988     dbfn_write(dbm, key, dbd, sizeof(*dbd));
2989     HDEBUG(D_acl) debug_printf_indent("seen db written (refresh)\n");
2990     }
2991   }
2992 else
2993   {                     /* No record found, yield always FAIL */
2994   if (mode != SEEN_READONLY)
2995     {
2996     dbdata_seen d = {.time_stamp = now};
2997     dbfn_write(dbm, key, &d, sizeof(*dbd));
2998     HDEBUG(D_acl) debug_printf_indent("seen db written (create)\n");
2999     }
3000   else
3001     HDEBUG(D_acl) debug_printf_indent("seen db not written (readonly)\n");
3002   }
3003
3004 dbfn_close(dbm);
3005 return yield;
3006
3007
3008 badparse:
3009   *log_msgptr = string_sprintf("failed to parse '%s'", arg);
3010   return ERROR;
3011 badopt:
3012   *log_msgptr = string_sprintf("unrecognised option '%s' in '%s'", ele, arg);
3013   return ERROR;
3014 }
3015
3016
3017
3018 /*************************************************
3019 *            The udpsend ACL modifier            *
3020 *************************************************/
3021
3022 /* Called by acl_check_condition() below.
3023
3024 Arguments:
3025   arg          the option string for udpsend=
3026   log_msgptr   for error messages
3027
3028 Returns:       OK        - Completed.
3029                DEFER     - Problem with DNS lookup.
3030                ERROR     - Syntax error in options.
3031 */
3032
3033 static int
3034 acl_udpsend(const uschar *arg, uschar **log_msgptr)
3035 {
3036 int sep = 0;
3037 uschar *hostname;
3038 uschar *portstr;
3039 uschar *portend;
3040 host_item *h;
3041 int portnum;
3042 int len;
3043 int r, s;
3044 uschar * errstr;
3045
3046 hostname = string_nextinlist(&arg, &sep, NULL, 0);
3047 portstr = string_nextinlist(&arg, &sep, NULL, 0);
3048
3049 if (!hostname)
3050   {
3051   *log_msgptr = US"missing destination host in \"udpsend\" modifier";
3052   return ERROR;
3053   }
3054 if (!portstr)
3055   {
3056   *log_msgptr = US"missing destination port in \"udpsend\" modifier";
3057   return ERROR;
3058   }
3059 if (!arg)
3060   {
3061   *log_msgptr = US"missing datagram payload in \"udpsend\" modifier";
3062   return ERROR;
3063   }
3064 portnum = Ustrtol(portstr, &portend, 10);
3065 if (*portend != '\0')
3066   {
3067   *log_msgptr = US"bad destination port in \"udpsend\" modifier";
3068   return ERROR;
3069   }
3070
3071 /* Make a single-item host list. */
3072 h = store_get(sizeof(host_item), GET_UNTAINTED);
3073 memset(h, 0, sizeof(host_item));
3074 h->name = hostname;
3075 h->port = portnum;
3076 h->mx = MX_NONE;
3077
3078 if (string_is_ip_address(hostname, NULL))
3079   h->address = hostname, r = HOST_FOUND;
3080 else
3081   r = host_find_byname(h, NULL, 0, NULL, FALSE);
3082 if (r == HOST_FIND_FAILED || r == HOST_FIND_AGAIN)
3083   {
3084   *log_msgptr = US"DNS lookup failed in \"udpsend\" modifier";
3085   return DEFER;
3086   }
3087
3088 HDEBUG(D_acl)
3089   debug_printf_indent("udpsend [%s]:%d %s\n", h->address, portnum, arg);
3090
3091 /*XXX this could better use sendto */
3092 r = s = ip_connectedsocket(SOCK_DGRAM, h->address, portnum, portnum,
3093                 1, NULL, &errstr, NULL);
3094 if (r < 0) goto defer;
3095 len = Ustrlen(arg);
3096 r = send(s, arg, len, 0);
3097 if (r < 0)
3098   {
3099   errstr = US strerror(errno);
3100   close(s);
3101   goto defer;
3102   }
3103 close(s);
3104 if (r < len)
3105   {
3106   *log_msgptr =
3107     string_sprintf("\"udpsend\" truncated from %d to %d octets", len, r);
3108   return DEFER;
3109   }
3110
3111 HDEBUG(D_acl)
3112   debug_printf_indent("udpsend %d bytes\n", r);
3113
3114 return OK;
3115
3116 defer:
3117 *log_msgptr = string_sprintf("\"udpsend\" failed: %s", errstr);
3118 return DEFER;
3119 }
3120
3121
3122
3123 /*************************************************
3124 *   Handle conditions/modifiers on an ACL item   *
3125 *************************************************/
3126
3127 /* Called from acl_check() below.
3128
3129 Arguments:
3130   verb         ACL verb
3131   cb           ACL condition block - if NULL, result is OK
3132   where        where called from
3133   addr         the address being checked for RCPT, or NULL
3134   level        the nesting level
3135   epp          pointer to pass back TRUE if "endpass" encountered
3136                  (applies only to "accept" and "discard")
3137   user_msgptr  user message pointer
3138   log_msgptr   log message pointer
3139   basic_errno  pointer to where to put verify error
3140
3141 Returns:       OK        - all conditions are met
3142                DISCARD   - an "acl" condition returned DISCARD - only allowed
3143                              for "accept" or "discard" verbs
3144                FAIL      - at least one condition fails
3145                FAIL_DROP - an "acl" condition returned FAIL_DROP
3146                DEFER     - can't tell at the moment (typically, lookup defer,
3147                              but can be temporary callout problem)
3148                ERROR     - ERROR from nested ACL or expansion failure or other
3149                              error
3150 */
3151
3152 static int
3153 acl_check_condition(int verb, acl_condition_block *cb, int where,
3154   address_item *addr, int level, BOOL *epp, uschar **user_msgptr,
3155   uschar **log_msgptr, int *basic_errno)
3156 {
3157 uschar * user_message = NULL;
3158 uschar * log_message = NULL;
3159 int rc = OK;
3160
3161 for (; cb; cb = cb->next)
3162   {
3163   const uschar * arg;
3164   int control_type;
3165   BOOL textonly = FALSE;
3166
3167   /* The message and log_message items set up messages to be used in
3168   case of rejection. They are expanded later. */
3169
3170   if (cb->type == ACLC_MESSAGE)
3171     {
3172     HDEBUG(D_acl) debug_printf_indent("  message: %s\n", cb->arg);
3173     user_message = cb->arg;
3174     continue;
3175     }
3176
3177   if (cb->type == ACLC_LOG_MESSAGE)
3178     {
3179     HDEBUG(D_acl) debug_printf_indent("l_message: %s\n", cb->arg);
3180     log_message = cb->arg;
3181     continue;
3182     }
3183
3184   /* The endpass "condition" just sets a flag to show it occurred. This is
3185   checked at compile time to be on an "accept" or "discard" item. */
3186
3187   if (cb->type == ACLC_ENDPASS)
3188     {
3189     *epp = TRUE;
3190     continue;
3191     }
3192
3193   /* For other conditions and modifiers, the argument is expanded now for some
3194   of them, but not for all, because expansion happens down in some lower level
3195   checking functions in some cases. */
3196
3197   if (!conditions[cb->type].expand_at_top)
3198     arg = cb->arg;
3199
3200   else if (!(arg = expand_string_2(cb->arg, &textonly)))
3201     {
3202     if (f.expand_string_forcedfail) continue;
3203     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
3204       cb->arg, expand_string_message);
3205     return f.search_find_defer ? DEFER : ERROR;
3206     }
3207
3208   /* Show condition, and expanded condition if it's different */
3209
3210   HDEBUG(D_acl)
3211     {
3212     int lhswidth = 0;
3213     debug_printf_indent("check %s%s %n",
3214       (!conditions[cb->type].is_modifier && cb->u.negated)? "!":"",
3215       conditions[cb->type].name, &lhswidth);
3216
3217     if (cb->type == ACLC_SET)
3218       {
3219 #ifndef DISABLE_DKIM
3220       if (  Ustrcmp(cb->u.varname, "dkim_verify_status") == 0
3221          || Ustrcmp(cb->u.varname, "dkim_verify_reason") == 0)
3222         {
3223         debug_printf("%s ", cb->u.varname);
3224         lhswidth += 19;
3225         }
3226       else
3227 #endif
3228         {
3229         debug_printf("acl_%s ", cb->u.varname);
3230         lhswidth += 5 + Ustrlen(cb->u.varname);
3231         }
3232       }
3233
3234     debug_printf("= %s\n", cb->arg);
3235
3236     if (arg != cb->arg)
3237       debug_printf("%.*s= %s\n", lhswidth,
3238       US"                             ", CS arg);
3239     }
3240
3241   /* Check that this condition makes sense at this time */
3242
3243   if ((conditions[cb->type].forbids & (1 << where)) != 0)
3244     {
3245     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
3246       conditions[cb->type].is_modifier ? "use" : "test",
3247       conditions[cb->type].name, acl_wherenames[where]);
3248     return ERROR;
3249     }
3250
3251   /* Run the appropriate test for each condition, or take the appropriate
3252   action for the remaining modifiers. */
3253
3254   switch(cb->type)
3255     {
3256     case ACLC_ADD_HEADER:
3257       setup_header(arg);
3258       break;
3259
3260     /* A nested ACL that returns "discard" makes sense only for an "accept" or
3261     "discard" verb. */
3262
3263     case ACLC_ACL:
3264       rc = acl_check_wargs(where, addr, arg, user_msgptr, log_msgptr);
3265       if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
3266         {
3267         *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
3268           "\"%s\" command (only allowed with \"accept\" or \"discard\")",
3269           verbs[verb]);
3270         return ERROR;
3271         }
3272       break;
3273
3274     case ACLC_AUTHENTICATED:
3275       rc = sender_host_authenticated ? match_isinlist(sender_host_authenticated,
3276               &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL) : FAIL;
3277       break;
3278
3279     #ifdef EXPERIMENTAL_BRIGHTMAIL
3280     case ACLC_BMI_OPTIN:
3281       {
3282       int old_pool = store_pool;
3283       store_pool = POOL_PERM;
3284       bmi_current_optin = string_copy(arg);
3285       store_pool = old_pool;
3286       }
3287     break;
3288     #endif
3289
3290     case ACLC_CONDITION:
3291     /* The true/false parsing here should be kept in sync with that used in
3292     expand.c when dealing with ECOND_BOOL so that we don't have too many
3293     different definitions of what can be a boolean. */
3294       if (*arg == '-'
3295           ? Ustrspn(arg+1, "0123456789") == Ustrlen(arg+1)    /* Negative number */
3296           : Ustrspn(arg,   "0123456789") == Ustrlen(arg))     /* Digits, or empty */
3297         rc = (Uatoi(arg) == 0)? FAIL : OK;
3298       else
3299         rc = (strcmpic(arg, US"no") == 0 ||
3300               strcmpic(arg, US"false") == 0)? FAIL :
3301              (strcmpic(arg, US"yes") == 0 ||
3302               strcmpic(arg, US"true") == 0)? OK : DEFER;
3303       if (rc == DEFER)
3304         *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
3305       break;
3306
3307     case ACLC_CONTINUE:    /* Always succeeds */
3308       break;
3309
3310     case ACLC_CONTROL:
3311       {
3312       const uschar *p = NULL;
3313       control_type = decode_control(arg, &p, where, log_msgptr);
3314
3315       /* Check if this control makes sense at this time */
3316
3317       if (controls_list[control_type].forbids & (1 << where))
3318         {
3319         *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
3320           controls_list[control_type].name, acl_wherenames[where]);
3321         return ERROR;
3322         }
3323
3324       switch(control_type)
3325         {
3326         case CONTROL_AUTH_UNADVERTISED:
3327           f.allow_auth_unadvertised = TRUE;
3328           break;
3329
3330 #ifdef EXPERIMENTAL_BRIGHTMAIL
3331         case CONTROL_BMI_RUN:
3332           bmi_run = 1;
3333           break;
3334 #endif
3335
3336 #ifndef DISABLE_DKIM
3337         case CONTROL_DKIM_VERIFY:
3338           f.dkim_disable_verify = TRUE;
3339 # ifdef SUPPORT_DMARC
3340           /* Since DKIM was blocked, skip DMARC too */
3341           f.dmarc_disable_verify = TRUE;
3342           f.dmarc_enable_forensic = FALSE;
3343 # endif
3344         break;
3345 #endif
3346
3347 #ifdef SUPPORT_DMARC
3348         case CONTROL_DMARC_VERIFY:
3349           f.dmarc_disable_verify = TRUE;
3350           break;
3351
3352         case CONTROL_DMARC_FORENSIC:
3353           f.dmarc_enable_forensic = TRUE;
3354           break;
3355 #endif
3356
3357         case CONTROL_DSCP:
3358           if (*p == '/')
3359             {
3360             int fd, af, level, optname, value;
3361             /* If we are acting on stdin, the setsockopt may fail if stdin is not
3362             a socket; we can accept that, we'll just debug-log failures anyway. */
3363             fd = fileno(smtp_in);
3364             if ((af = ip_get_address_family(fd)) < 0)
3365               {
3366               HDEBUG(D_acl)
3367                 debug_printf_indent("smtp input is probably not a socket [%s], not setting DSCP\n",
3368                     strerror(errno));
3369               break;
3370               }
3371             if (dscp_lookup(p+1, af, &level, &optname, &value))
3372               if (setsockopt(fd, level, optname, &value, sizeof(value)) < 0)
3373                 {
3374                 HDEBUG(D_acl) debug_printf_indent("failed to set input DSCP[%s]: %s\n",
3375                     p+1, strerror(errno));
3376                 }
3377               else
3378                 {
3379                 HDEBUG(D_acl) debug_printf_indent("set input DSCP to \"%s\"\n", p+1);
3380                 }
3381             else
3382               {
3383               *log_msgptr = string_sprintf("unrecognised DSCP value in \"control=%s\"", arg);
3384               return ERROR;
3385               }
3386             }
3387           else
3388             {
3389             *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3390             return ERROR;
3391             }
3392           break;
3393
3394         case CONTROL_ERROR:
3395           return ERROR;
3396
3397         case CONTROL_CASEFUL_LOCAL_PART:
3398           deliver_localpart = addr->cc_local_part;
3399           break;
3400
3401         case CONTROL_CASELOWER_LOCAL_PART:
3402           deliver_localpart = addr->lc_local_part;
3403           break;
3404
3405         case CONTROL_ENFORCE_SYNC:
3406           smtp_enforce_sync = TRUE;
3407           break;
3408
3409         case CONTROL_NO_ENFORCE_SYNC:
3410           smtp_enforce_sync = FALSE;
3411           break;
3412
3413 #ifdef WITH_CONTENT_SCAN
3414         case CONTROL_NO_MBOX_UNSPOOL:
3415           f.no_mbox_unspool = TRUE;
3416           break;
3417 #endif
3418
3419         case CONTROL_NO_MULTILINE:
3420           f.no_multiline_responses = TRUE;
3421           break;
3422
3423         case CONTROL_NO_PIPELINING:
3424           f.pipelining_enable = FALSE;
3425           break;
3426
3427         case CONTROL_NO_DELAY_FLUSH:
3428           f.disable_delay_flush = TRUE;
3429           break;
3430
3431         case CONTROL_NO_CALLOUT_FLUSH:
3432           f.disable_callout_flush = TRUE;
3433           break;
3434
3435         case CONTROL_FAKEREJECT:
3436           cancel_cutthrough_connection(TRUE, US"fakereject");
3437         case CONTROL_FAKEDEFER:
3438           fake_response = control_type == CONTROL_FAKEDEFER ? DEFER : FAIL;
3439           if (*p == '/')
3440             {
3441             const uschar *pp = p + 1;
3442             while (*pp) pp++;
3443             /* The entire control= line was expanded at top so no need to expand
3444             the part after the / */
3445             fake_response_text = string_copyn(p+1, pp-p-1);
3446             p = pp;
3447             }
3448            else /* Explicitly reset to default string */
3449             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).";
3450           break;
3451
3452         case CONTROL_FREEZE:
3453           f.deliver_freeze = TRUE;
3454           deliver_frozen_at = time(NULL);
3455           freeze_tell = freeze_tell_config;       /* Reset to configured value */
3456           if (Ustrncmp(p, "/no_tell", 8) == 0)
3457             {
3458             p += 8;
3459             freeze_tell = NULL;
3460             }
3461           if (*p)
3462             {
3463             *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3464             return ERROR;
3465             }
3466           cancel_cutthrough_connection(TRUE, US"item frozen");
3467           break;
3468
3469         case CONTROL_QUEUE:
3470           f.queue_only_policy = TRUE;
3471           if (Ustrcmp(p, "_only") == 0)
3472             p += 5;
3473           else while (*p == '/')
3474             if (Ustrncmp(p, "/only", 5) == 0)
3475               { p += 5; f.queue_smtp = FALSE; }
3476             else if (Ustrncmp(p, "/first_pass_route", 17) == 0)
3477               { p += 17; f.queue_smtp = TRUE; }
3478             else
3479               break;
3480           cancel_cutthrough_connection(TRUE, US"queueing forced");
3481           break;
3482
3483         case CONTROL_SUBMISSION:
3484           originator_name = US"";
3485           f.submission_mode = TRUE;
3486           while (*p == '/')
3487             {
3488             if (Ustrncmp(p, "/sender_retain", 14) == 0)
3489               {
3490               p += 14;
3491               f.active_local_sender_retain = TRUE;
3492               f.active_local_from_check = FALSE;
3493               }
3494             else if (Ustrncmp(p, "/domain=", 8) == 0)
3495               {
3496               const uschar *pp = p + 8;
3497               while (*pp && *pp != '/') pp++;
3498               submission_domain = string_copyn(p+8, pp-p-8);
3499               p = pp;
3500               }
3501             /* The name= option must be last, because it swallows the rest of
3502             the string. */
3503             else if (Ustrncmp(p, "/name=", 6) == 0)
3504               {
3505               const uschar *pp = p + 6;
3506               while (*pp) pp++;
3507               submission_name = parse_fix_phrase(p+6, pp-p-6);
3508               p = pp;
3509               }
3510             else break;
3511             }
3512           if (*p)
3513             {
3514             *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3515             return ERROR;
3516             }
3517           break;
3518
3519         case CONTROL_DEBUG:
3520           {
3521           uschar * debug_tag = NULL, * debug_opts = NULL;
3522           BOOL kill = FALSE, stop = FALSE;
3523
3524           while (*p == '/')
3525             {
3526             const uschar * pp = p+1;
3527             if (Ustrncmp(pp, "tag=", 4) == 0)
3528               {
3529               for (pp += 4; *pp && *pp != '/';) pp++;
3530               debug_tag = string_copyn(p+5, pp-p-5);
3531               }
3532             else if (Ustrncmp(pp, "opts=", 5) == 0)
3533               {
3534               for (pp += 5; *pp && *pp != '/';) pp++;
3535               debug_opts = string_copyn(p+6, pp-p-6);
3536               }
3537             else if (Ustrncmp(pp, "kill", 4) == 0)
3538               {
3539               pp += 4;
3540               kill = TRUE;
3541               }
3542             else if (Ustrncmp(pp, "stop", 4) == 0)
3543               {
3544               pp += 4;
3545               stop = TRUE;
3546               }
3547             else if (Ustrncmp(pp, "pretrigger=", 11) == 0)
3548                 debug_pretrigger_setup(pp+11);
3549             else if (Ustrncmp(pp, "trigger=", 8) == 0)
3550               {
3551               if (Ustrncmp(pp += 8, "now", 3) == 0)
3552                 {
3553                 pp += 3;
3554                 debug_trigger_fire();
3555                 }
3556               else if (Ustrncmp(pp, "paniclog", 8) == 0)
3557                 {
3558                 pp += 8;
3559                 dtrigger_selector |= BIT(DTi_panictrigger);
3560                 }
3561               }
3562             while (*pp && *pp != '/') pp++;
3563             p = pp;
3564             }
3565
3566           if (kill)
3567             debug_logging_stop(TRUE);
3568           else if (stop)
3569             debug_logging_stop(FALSE);
3570           else if (debug_tag || debug_opts)
3571             debug_logging_activate(debug_tag, debug_opts);
3572           break;
3573           }
3574
3575         case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3576           f.suppress_local_fixups = TRUE;
3577           break;
3578
3579         case CONTROL_CUTTHROUGH_DELIVERY:
3580           {
3581           uschar * ignored = NULL;
3582 #ifndef DISABLE_PRDR
3583           if (prdr_requested)
3584 #else
3585           if (0)
3586 #endif
3587             /* Too hard to think about for now.  We might in future cutthrough
3588             the case where both sides handle prdr and this-node prdr acl
3589             is "accept" */
3590             ignored = US"PRDR active";
3591           else if (f.deliver_freeze)
3592             ignored = US"frozen";
3593           else if (f.queue_only_policy)
3594             ignored = US"queue-only";
3595           else if (fake_response == FAIL)
3596             ignored = US"fakereject";
3597           else if (rcpt_count != 1)
3598             ignored = US"nonfirst rcpt";
3599           else if (cutthrough.delivery)
3600             ignored = US"repeated";
3601           else if (cutthrough.callout_hold_only)
3602             {
3603             DEBUG(D_acl)
3604               debug_printf_indent(" cutthrough request upgrades callout hold\n");
3605             cutthrough.callout_hold_only = FALSE;
3606             cutthrough.delivery = TRUE; /* control accepted */
3607             }
3608           else
3609             {
3610             cutthrough.delivery = TRUE; /* control accepted */
3611             while (*p == '/')
3612               {
3613               const uschar * pp = p+1;
3614               if (Ustrncmp(pp, "defer=", 6) == 0)
3615                 {
3616                 pp += 6;
3617                 if (Ustrncmp(pp, "pass", 4) == 0) cutthrough.defer_pass = TRUE;
3618                 /* else if (Ustrncmp(pp, "spool") == 0) ;       default */
3619                 }
3620               else
3621                 while (*pp && *pp != '/') pp++;
3622               p = pp;
3623               }
3624             }
3625
3626           DEBUG(D_acl) if (ignored)
3627             debug_printf(" cutthrough request ignored on %s item\n", ignored);
3628           }
3629         break;
3630
3631 #ifdef SUPPORT_I18N
3632         case CONTROL_UTF8_DOWNCONVERT:
3633           if (*p == '/')
3634             {
3635             if (p[1] == '1')
3636               {
3637               message_utf8_downconvert = 1;
3638               addr->prop.utf8_downcvt = TRUE;
3639               addr->prop.utf8_downcvt_maybe = FALSE;
3640               p += 2;
3641               break;
3642               }
3643             if (p[1] == '0')
3644               {
3645               message_utf8_downconvert = 0;
3646               addr->prop.utf8_downcvt = FALSE;
3647               addr->prop.utf8_downcvt_maybe = FALSE;
3648               p += 2;
3649               break;
3650               }
3651             if (p[1] == '-' && p[2] == '1')
3652               {
3653               message_utf8_downconvert = -1;
3654               addr->prop.utf8_downcvt = FALSE;
3655               addr->prop.utf8_downcvt_maybe = TRUE;
3656               p += 3;
3657               break;
3658               }
3659             *log_msgptr = US"bad option value for control=utf8_downconvert";
3660             }
3661           else
3662             {
3663             message_utf8_downconvert = 1;
3664             addr->prop.utf8_downcvt = TRUE;
3665             addr->prop.utf8_downcvt_maybe = FALSE;
3666             break;
3667             }
3668           return ERROR;
3669 #endif
3670
3671         }
3672       break;
3673       }
3674
3675 #ifdef EXPERIMENTAL_DCC
3676     case ACLC_DCC:
3677       {
3678       /* Separate the regular expression and any optional parameters. */
3679       const uschar * list = arg;
3680       int sep = -'/';
3681       uschar * ss = string_nextinlist(&list, &sep, NULL, 0);
3682       /* Run the dcc backend. */
3683       rc = dcc_process(&ss);
3684       /* Modify return code based upon the existence of options. */
3685       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
3686         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3687           rc = FAIL;   /* FAIL so that the message is passed to the next ACL */
3688       break;
3689       }
3690 #endif
3691
3692 #ifdef WITH_CONTENT_SCAN
3693     case ACLC_DECODE:
3694       rc = mime_decode(&arg);
3695       break;
3696 #endif
3697
3698     case ACLC_DELAY:
3699       {
3700       int delay = readconf_readtime(arg, 0, FALSE);
3701       if (delay < 0)
3702         {
3703         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3704           "modifier: \"%s\" is not a time value", arg);
3705         return ERROR;
3706         }
3707       else
3708         {
3709         HDEBUG(D_acl) debug_printf_indent("delay modifier requests %d-second delay\n",
3710           delay);
3711         if (host_checking)
3712           {
3713           HDEBUG(D_acl)
3714             debug_printf_indent("delay skipped in -bh checking mode\n");
3715           }
3716
3717         /* NOTE 1: Remember that we may be
3718         dealing with stdin/stdout here, in addition to TCP/IP connections.
3719         Also, delays may be specified for non-SMTP input, where smtp_out and
3720         smtp_in will be NULL. Whatever is done must work in all cases.
3721
3722         NOTE 2: The added feature of flushing the output before a delay must
3723         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3724         */
3725
3726         else
3727           {
3728           if (smtp_out && !f.disable_delay_flush)
3729             mac_smtp_fflush();
3730
3731 #if !defined(NO_POLL_H) && defined (POLLRDHUP)
3732             {
3733             struct pollfd p;
3734             nfds_t n = 0;
3735             if (smtp_out)
3736               {
3737               p.fd = fileno(smtp_out);
3738               p.events = POLLRDHUP;
3739               n = 1;
3740               }
3741             if (poll(&p, n, delay*1000) > 0)
3742               HDEBUG(D_acl) debug_printf_indent("delay cancelled by peer close\n");
3743             }
3744 #else
3745           /* Lacking POLLRDHUP it appears to be impossible to detect that a
3746           TCP/IP connection has gone away without reading from it. This means
3747           that we cannot shorten the delay below if the client goes away,
3748           because we cannot discover that the client has closed its end of the
3749           connection. (The connection is actually in a half-closed state,
3750           waiting for the server to close its end.) It would be nice to be able
3751           to detect this state, so that the Exim process is not held up
3752           unnecessarily. However, it seems that we can't. The poll() function
3753           does not do the right thing, and in any case it is not always
3754           available.  */
3755
3756           while (delay > 0) delay = sleep(delay);
3757 #endif
3758           }
3759         }
3760       break;
3761       }
3762
3763 #ifndef DISABLE_DKIM
3764     case ACLC_DKIM_SIGNER:
3765       if (dkim_cur_signer)
3766         rc = match_isinlist(dkim_cur_signer,
3767                           &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3768       else
3769         rc = FAIL;
3770       break;
3771
3772     case ACLC_DKIM_STATUS:
3773       {         /* return good for any match */
3774       const uschar * s = dkim_verify_status ? dkim_verify_status : US"none";
3775       int sep = 0;
3776       for (uschar * ss; ss = string_nextinlist(&s, &sep, NULL, 0); )
3777         if (   (rc = match_isinlist(ss, &arg,
3778                                     0, NULL, NULL, MCL_STRING, TRUE, NULL))
3779             == OK) break;
3780       }
3781       break;
3782 #endif
3783
3784 #ifdef SUPPORT_DMARC
3785     case ACLC_DMARC_STATUS:
3786       if (!f.dmarc_has_been_checked)
3787         dmarc_process();
3788       f.dmarc_has_been_checked = TRUE;
3789
3790       /* used long way of dmarc_exim_expand_query() in case we need more
3791       view into the process in the future. */
3792       rc = match_isinlist(dmarc_exim_expand_query(DMARC_VERIFY_STATUS),
3793                           &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3794       break;
3795 #endif
3796
3797     case ACLC_DNSLISTS:
3798       rc = verify_check_dnsbl(where, &arg, log_msgptr);
3799       break;
3800
3801     case ACLC_DOMAINS:
3802       rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3803         addr->domain_cache, MCL_DOMAIN, TRUE, CUSS &deliver_domain_data);
3804       break;
3805
3806     /* The value in tls_cipher is the full cipher name, for example,
3807     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3808     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3809     what may in practice come out of the SSL library - which at the time of
3810     writing is poorly documented. */
3811
3812     case ACLC_ENCRYPTED:
3813       if (!tls_in.cipher) rc = FAIL;
3814       else
3815         {
3816         uschar *endcipher = NULL;
3817         uschar *cipher = Ustrchr(tls_in.cipher, ':');
3818         if (!cipher) cipher = tls_in.cipher; else
3819           {
3820           endcipher = Ustrchr(++cipher, ':');
3821           if (endcipher) *endcipher = 0;
3822           }
3823         rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3824         if (endcipher) *endcipher = ':';
3825         }
3826       break;
3827
3828     /* Use verify_check_this_host() instead of verify_check_host() so that
3829     we can pass over &host_data to catch any looked up data. Once it has been
3830     set, it retains its value so that it's still there if another ACL verb
3831     comes through here and uses the cache. However, we must put it into
3832     permanent store in case it is also expected to be used in a subsequent
3833     message in the same SMTP connection. */
3834
3835     case ACLC_HOSTS:
3836       rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3837         sender_host_address ? sender_host_address : US"", CUSS &host_data);
3838       if (rc == DEFER) *log_msgptr = search_error_message;
3839       if (host_data) host_data = string_copy_perm(host_data, TRUE);
3840       break;
3841
3842     case ACLC_LOCAL_PARTS:
3843       rc = match_isinlist(addr->cc_local_part, &arg, 0,
3844         &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3845         CUSS &deliver_localpart_data);
3846       break;
3847
3848     case ACLC_LOG_REJECT_TARGET:
3849       {
3850       int logbits = 0, sep = 0;
3851       const uschar * s = arg;
3852
3853       for (uschar * ss; ss = string_nextinlist(&s, &sep, NULL, 0); )
3854         {
3855         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3856         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3857         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3858         else
3859           {
3860           logbits |= LOG_MAIN|LOG_REJECT;
3861           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3862             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3863           }
3864         }
3865       log_reject_target = logbits;
3866       break;
3867       }
3868
3869     case ACLC_LOGWRITE:
3870       {
3871       int logbits = 0;
3872       const uschar *s = arg;
3873       if (*s == ':')
3874         {
3875         s++;
3876         while (*s != ':')
3877           {
3878           if (Ustrncmp(s, "main", 4) == 0)
3879             { logbits |= LOG_MAIN; s += 4; }
3880           else if (Ustrncmp(s, "panic", 5) == 0)
3881             { logbits |= LOG_PANIC; s += 5; }
3882           else if (Ustrncmp(s, "reject", 6) == 0)
3883             { logbits |= LOG_REJECT; s += 6; }
3884           else
3885             {
3886             logbits = LOG_MAIN|LOG_PANIC;
3887             s = string_sprintf(":unknown log name in \"%s\" in "
3888               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3889             }
3890           if (*s == ',') s++;
3891           }
3892         s++;
3893         }
3894       while (isspace(*s)) s++;
3895
3896       if (logbits == 0) logbits = LOG_MAIN;
3897       log_write(0, logbits, "%s", string_printing(s));
3898       break;
3899       }
3900
3901 #ifdef WITH_CONTENT_SCAN
3902     case ACLC_MALWARE:                  /* Run the malware backend. */
3903       {
3904       /* Separate the regular expression and any optional parameters. */
3905       const uschar * list = arg;
3906       BOOL defer_ok = FALSE;
3907       int timeout = 0, sep = -'/';
3908       uschar * ss = string_nextinlist(&list, &sep, NULL, 0);
3909
3910       for (uschar * opt; opt = string_nextinlist(&list, &sep, NULL, 0); )
3911         if (strcmpic(opt, US"defer_ok") == 0)
3912           defer_ok = TRUE;
3913         else if (  strncmpic(opt, US"tmo=", 4) == 0
3914                 && (timeout = readconf_readtime(opt+4, '\0', FALSE)) < 0
3915                 )
3916           {
3917           *log_msgptr = string_sprintf("bad timeout value in '%s'", opt);
3918           return ERROR;
3919           }
3920
3921       rc = malware(ss, textonly, timeout);
3922       if (rc == DEFER && defer_ok)
3923         rc = FAIL;      /* FAIL so that the message is passed to the next ACL */
3924       break;
3925       }
3926
3927     case ACLC_MIME_REGEX:
3928       rc = mime_regex(&arg, textonly);
3929       break;
3930 #endif
3931
3932     case ACLC_QUEUE:
3933       if (is_tainted(arg))
3934         {
3935         *log_msgptr = string_sprintf("Tainted name '%s' for queue not permitted",
3936                                       arg);
3937         return ERROR;
3938         }
3939       if (Ustrchr(arg, '/'))
3940         {
3941         *log_msgptr = string_sprintf(
3942                 "Directory separator not permitted in queue name: '%s'", arg);
3943         return ERROR;
3944         }
3945       queue_name = string_copy_perm(arg, FALSE);
3946       break;
3947
3948     case ACLC_RATELIMIT:
3949       rc = acl_ratelimit(arg, where, log_msgptr);
3950       break;
3951
3952     case ACLC_RECIPIENTS:
3953       rc = match_address_list(CUS addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3954         CUSS &recipient_data);
3955       break;
3956
3957     #ifdef WITH_CONTENT_SCAN
3958     case ACLC_REGEX:
3959       rc = regex(&arg, textonly);
3960       break;
3961     #endif
3962
3963     case ACLC_REMOVE_HEADER:
3964       setup_remove_header(arg);
3965       break;
3966
3967     case ACLC_SEEN:
3968       rc = acl_seen(arg, where, log_msgptr);
3969       break;
3970
3971     case ACLC_SENDER_DOMAINS:
3972       {
3973       uschar *sdomain;
3974       sdomain = Ustrrchr(sender_address, '@');
3975       sdomain = sdomain ? sdomain + 1 : US"";
3976       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3977         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3978       break;
3979       }
3980
3981     case ACLC_SENDERS:
3982       rc = match_address_list(CUS sender_address, TRUE, TRUE, &arg,
3983         sender_address_cache, -1, 0, CUSS &sender_data);
3984       break;
3985
3986     /* Connection variables must persist forever; message variables not */
3987
3988     case ACLC_SET:
3989       {
3990       int old_pool = store_pool;
3991       if (  cb->u.varname[0] != 'm'
3992 #ifndef DISABLE_EVENT
3993          || event_name          /* An event is being delivered */
3994 #endif
3995          )
3996         store_pool = POOL_PERM;
3997 #ifndef DISABLE_DKIM    /* Overwriteable dkim result variables */
3998       if (Ustrcmp(cb->u.varname, "dkim_verify_status") == 0)
3999         dkim_verify_status = string_copy(arg);
4000       else if (Ustrcmp(cb->u.varname, "dkim_verify_reason") == 0)
4001         dkim_verify_reason = string_copy(arg);
4002       else
4003 #endif
4004         acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
4005       store_pool = old_pool;
4006       break;
4007       }
4008
4009 #ifdef WITH_CONTENT_SCAN
4010     case ACLC_SPAM:
4011       {
4012       /* Separate the regular expression and any optional parameters. */
4013       const uschar * list = arg;
4014       int sep = -'/';
4015       uschar * ss = string_nextinlist(&list, &sep, NULL, 0);
4016
4017       rc = spam(CUSS &ss);
4018       /* Modify return code based upon the existence of options. */
4019       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
4020         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
4021           rc = FAIL;    /* FAIL so that the message is passed to the next ACL */
4022       break;
4023       }
4024 #endif
4025
4026 #ifdef SUPPORT_SPF
4027     case ACLC_SPF:
4028       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
4029       break;
4030
4031     case ACLC_SPF_GUESS:
4032       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
4033       break;
4034 #endif
4035
4036     case ACLC_UDPSEND:
4037       rc = acl_udpsend(arg, log_msgptr);
4038       break;
4039
4040     /* If the verb is WARN, discard any user message from verification, because
4041     such messages are SMTP responses, not header additions. The latter come
4042     only from explicit "message" modifiers. However, put the user message into
4043     $acl_verify_message so it can be used in subsequent conditions or modifiers
4044     (until something changes it). */
4045
4046     case ACLC_VERIFY:
4047       rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
4048       if (*user_msgptr)
4049         acl_verify_message = *user_msgptr;
4050       if (verb == ACL_WARN) *user_msgptr = NULL;
4051       break;
4052
4053     default:
4054       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
4055         "condition %d", cb->type);
4056       break;
4057     }
4058
4059   /* If a condition was negated, invert OK/FAIL. */
4060
4061   if (!conditions[cb->type].is_modifier && cb->u.negated)
4062     if (rc == OK) rc = FAIL;
4063     else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
4064
4065   if (rc != OK) break;   /* Conditions loop */
4066   }
4067
4068
4069 /* If the result is the one for which "message" and/or "log_message" are used,
4070 handle the values of these modifiers. If there isn't a log message set, we make
4071 it the same as the user message.
4072
4073 "message" is a user message that will be included in an SMTP response. Unless
4074 it is empty, it overrides any previously set user message.
4075
4076 "log_message" is a non-user message, and it adds to any existing non-user
4077 message that is already set.
4078
4079 Most verbs have but a single return for which the messages are relevant, but
4080 for "discard", it's useful to have the log message both when it succeeds and
4081 when it fails. For "accept", the message is used in the OK case if there is no
4082 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
4083 present. */
4084
4085 if (*epp && rc == OK) user_message = NULL;
4086
4087 if ((BIT(rc) & msgcond[verb]) != 0)
4088   {
4089   uschar *expmessage;
4090   uschar *old_user_msgptr = *user_msgptr;
4091   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
4092
4093   /* If the verb is "warn", messages generated by conditions (verification or
4094   nested ACLs) are always discarded. This also happens for acceptance verbs
4095   when they actually do accept. Only messages specified at this level are used.
4096   However, the value of an existing message is available in $acl_verify_message
4097   during expansions. */
4098
4099   if (verb == ACL_WARN ||
4100       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
4101     *log_msgptr = *user_msgptr = NULL;
4102
4103   if (user_message)
4104     {
4105     acl_verify_message = old_user_msgptr;
4106     expmessage = expand_string(user_message);
4107     if (!expmessage)
4108       {
4109       if (!f.expand_string_forcedfail)
4110         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
4111           user_message, expand_string_message);
4112       }
4113     else if (expmessage[0] != 0) *user_msgptr = expmessage;
4114     }
4115
4116   if (log_message)
4117     {
4118     acl_verify_message = old_log_msgptr;
4119     expmessage = expand_string(log_message);
4120     if (!expmessage)
4121       {
4122       if (!f.expand_string_forcedfail)
4123         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
4124           log_message, expand_string_message);
4125       }
4126     else if (expmessage[0] != 0)
4127       {
4128       *log_msgptr = (*log_msgptr == NULL)? expmessage :
4129         string_sprintf("%s: %s", expmessage, *log_msgptr);
4130       }
4131     }
4132
4133   /* If no log message, default it to the user message */
4134
4135   if (!*log_msgptr) *log_msgptr = *user_msgptr;
4136   }
4137
4138 acl_verify_message = NULL;
4139 return rc;
4140 }
4141
4142
4143
4144
4145
4146 /*************************************************
4147 *        Get line from a literal ACL             *
4148 *************************************************/
4149
4150 /* This function is passed to acl_read() in order to extract individual lines
4151 of a literal ACL, which we access via static pointers. We can destroy the
4152 contents because this is called only once (the compiled ACL is remembered).
4153
4154 This code is intended to treat the data in the same way as lines in the main
4155 Exim configuration file. That is:
4156
4157   . Leading spaces are ignored.
4158
4159   . A \ at the end of a line is a continuation - trailing spaces after the \
4160     are permitted (this is because I don't believe in making invisible things
4161     significant). Leading spaces on the continued part of a line are ignored.
4162
4163   . Physical lines starting (significantly) with # are totally ignored, and
4164     may appear within a sequence of backslash-continued lines.
4165
4166   . Blank lines are ignored, but will end a sequence of continuations.
4167
4168 Arguments: none
4169 Returns:   a pointer to the next line
4170 */
4171
4172
4173 static uschar *acl_text;          /* Current pointer in the text */
4174 static uschar *acl_text_end;      /* Points one past the terminating '0' */
4175
4176
4177 static uschar *
4178 acl_getline(void)
4179 {
4180 uschar *yield;
4181
4182 /* This loop handles leading blank lines and comments. */
4183
4184 for(;;)
4185   {
4186   Uskip_whitespace(&acl_text);          /* Leading spaces/empty lines */
4187   if (!*acl_text) return NULL;          /* No more data */
4188   yield = acl_text;                     /* Potential data line */
4189
4190   while (*acl_text && *acl_text != '\n') acl_text++;
4191
4192   /* If we hit the end before a newline, we have the whole logical line. If
4193   it's a comment, there's no more data to be given. Otherwise, yield it. */
4194
4195   if (!*acl_text) return *yield == '#' ? NULL : yield;
4196
4197   /* After reaching a newline, end this loop if the physical line does not
4198   start with '#'. If it does, it's a comment, and the loop continues. */
4199
4200   if (*yield != '#') break;
4201   }
4202
4203 /* This loop handles continuations. We know we have some real data, ending in
4204 newline. See if there is a continuation marker at the end (ignoring trailing
4205 white space). We know that *yield is not white space, so no need to test for
4206 cont > yield in the backwards scanning loop. */
4207
4208 for(;;)
4209   {
4210   uschar *cont;
4211   for (cont = acl_text - 1; isspace(*cont); cont--);
4212
4213   /* If no continuation follows, we are done. Mark the end of the line and
4214   return it. */
4215
4216   if (*cont != '\\')
4217     {
4218     *acl_text++ = 0;
4219     return yield;
4220     }
4221
4222   /* We have encountered a continuation. Skip over whitespace at the start of
4223   the next line, and indeed the whole of the next line or lines if they are
4224   comment lines. */
4225
4226   for (;;)
4227     {
4228     while (*(++acl_text) == ' ' || *acl_text == '\t');
4229     if (*acl_text != '#') break;
4230     while (*(++acl_text) != 0 && *acl_text != '\n');
4231     }
4232
4233   /* We have the start of a continuation line. Move all the rest of the data
4234   to join onto the previous line, and then find its end. If the end is not a
4235   newline, we are done. Otherwise loop to look for another continuation. */
4236
4237   memmove(cont, acl_text, acl_text_end - acl_text);
4238   acl_text_end -= acl_text - cont;
4239   acl_text = cont;
4240   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
4241   if (*acl_text == 0) return yield;
4242   }
4243
4244 /* Control does not reach here */
4245 }
4246
4247
4248
4249
4250
4251 /************************************************/
4252 /* For error messages, a string describing the config location
4253 associated with current processing. NULL if not in an ACL. */
4254
4255 uschar *
4256 acl_current_verb(void)
4257 {
4258 if (acl_current) return string_sprintf(" (ACL %s, %s %d)",
4259     verbs[acl_current->verb], acl_current->srcfile, acl_current->srcline);
4260 return NULL;
4261 }
4262
4263 /*************************************************
4264 *        Check access using an ACL               *
4265 *************************************************/
4266
4267 /* This function is called from address_check. It may recurse via
4268 acl_check_condition() - hence the use of a level to stop looping. The ACL is
4269 passed as a string which is expanded. A forced failure implies no access check
4270 is required. If the result is a single word, it is taken as the name of an ACL
4271 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
4272 text, complete with newlines, and parsed as such. In both cases, the ACL check
4273 is then run. This function uses an auxiliary function for acl_read() to call
4274 for reading individual lines of a literal ACL. This is acl_getline(), which
4275 appears immediately above.
4276
4277 Arguments:
4278   where        where called from
4279   addr         address item when called from RCPT; otherwise NULL
4280   s            the input string; NULL is the same as an empty ACL => DENY
4281   user_msgptr  where to put a user error (for SMTP response)
4282   log_msgptr   where to put a logging message (not for SMTP response)
4283
4284 Returns:       OK         access is granted
4285                DISCARD    access is apparently granted...
4286                FAIL       access is denied
4287                FAIL_DROP  access is denied; drop the connection
4288                DEFER      can't tell at the moment
4289                ERROR      disaster
4290 */
4291
4292 static int
4293 acl_check_internal(int where, address_item *addr, uschar *s,
4294   uschar **user_msgptr, uschar **log_msgptr)
4295 {
4296 int fd = -1;
4297 acl_block *acl = NULL;
4298 uschar *acl_name = US"inline ACL";
4299 uschar *ss;
4300
4301 /* Catch configuration loops */
4302
4303 if (acl_level > 20)
4304   {
4305   *log_msgptr = US"ACL nested too deep: possible loop";
4306   return ERROR;
4307   }
4308
4309 if (!s)
4310   {
4311   HDEBUG(D_acl) debug_printf_indent("ACL is NULL: implicit DENY\n");
4312   return FAIL;
4313   }
4314
4315 /* At top level, we expand the incoming string. At lower levels, it has already
4316 been expanded as part of condition processing. */
4317
4318 if (acl_level == 0)
4319   {
4320   if (!(ss = expand_string(s)))
4321     {
4322     if (f.expand_string_forcedfail) return OK;
4323     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
4324       expand_string_message);
4325     return ERROR;
4326     }
4327   }
4328 else ss = s;
4329
4330 while (isspace(*ss)) 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 != NULL && *search_error_message != 0)
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   while (*s && isspace(*s)) s++;
4620   if (!*s) 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, uschar *recipient, uschar *s, uschar **user_msgptr,
4716   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)
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'", &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 */