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