src/src/acl.c

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