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 - 2021 */
   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) 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 = '/', 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, stop = 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 if (Ustrncmp(pp, "stop", 4) == 0)
3505               {
3506               for (pp += 4; *pp && *pp != '/';) pp++;
3507               stop = TRUE;
3508               }
3509             else
3510               while (*pp && *pp != '/') pp++;
3511             p = pp;
3512             }
3513
3514             if (kill)
3515               debug_logging_stop(TRUE);
3516             else if (stop)
3517               debug_logging_stop(FALSE);
3518             else
3519               debug_logging_activate(debug_tag, debug_opts);
3520           break;
3521           }
3522
3523         case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3524           f.suppress_local_fixups = TRUE;
3525           break;
3526
3527         case CONTROL_CUTTHROUGH_DELIVERY:
3528           {
3529           uschar * ignored = NULL;
3530 #ifndef DISABLE_PRDR
3531           if (prdr_requested)
3532 #else
3533           if (0)
3534 #endif
3535             /* Too hard to think about for now.  We might in future cutthrough
3536             the case where both sides handle prdr and this-node prdr acl
3537             is "accept" */
3538             ignored = US"PRDR active";
3539           else if (f.deliver_freeze)
3540             ignored = US"frozen";
3541           else if (f.queue_only_policy)
3542             ignored = US"queue-only";
3543           else if (fake_response == FAIL)
3544             ignored = US"fakereject";
3545           else if (rcpt_count != 1)
3546             ignored = US"nonfirst rcpt";
3547           else if (cutthrough.delivery)
3548             ignored = US"repeated";
3549           else if (cutthrough.callout_hold_only)
3550             {
3551             DEBUG(D_acl)
3552               debug_printf_indent(" cutthrough request upgrades callout hold\n");
3553             cutthrough.callout_hold_only = FALSE;
3554             cutthrough.delivery = TRUE; /* control accepted */
3555             }
3556           else
3557             {
3558             cutthrough.delivery = TRUE; /* control accepted */
3559             while (*p == '/')
3560               {
3561               const uschar * pp = p+1;
3562               if (Ustrncmp(pp, "defer=", 6) == 0)
3563                 {
3564                 pp += 6;
3565                 if (Ustrncmp(pp, "pass", 4) == 0) cutthrough.defer_pass = TRUE;
3566                 /* else if (Ustrncmp(pp, "spool") == 0) ;       default */
3567                 }
3568               else
3569                 while (*pp && *pp != '/') pp++;
3570               p = pp;
3571               }
3572             }
3573
3574           DEBUG(D_acl) if (ignored)
3575             debug_printf(" cutthrough request ignored on %s item\n", ignored);
3576           }
3577         break;
3578
3579 #ifdef SUPPORT_I18N
3580         case CONTROL_UTF8_DOWNCONVERT:
3581           if (*p == '/')
3582             {
3583             if (p[1] == '1')
3584               {
3585               message_utf8_downconvert = 1;
3586               addr->prop.utf8_downcvt = TRUE;
3587               addr->prop.utf8_downcvt_maybe = FALSE;
3588               p += 2;
3589               break;
3590               }
3591             if (p[1] == '0')
3592               {
3593               message_utf8_downconvert = 0;
3594               addr->prop.utf8_downcvt = FALSE;
3595               addr->prop.utf8_downcvt_maybe = FALSE;
3596               p += 2;
3597               break;
3598               }
3599             if (p[1] == '-' && p[2] == '1')
3600               {
3601               message_utf8_downconvert = -1;
3602               addr->prop.utf8_downcvt = FALSE;
3603               addr->prop.utf8_downcvt_maybe = TRUE;
3604               p += 3;
3605               break;
3606               }
3607             *log_msgptr = US"bad option value for control=utf8_downconvert";
3608             }
3609           else
3610             {
3611             message_utf8_downconvert = 1;
3612             addr->prop.utf8_downcvt = TRUE;
3613             addr->prop.utf8_downcvt_maybe = FALSE;
3614             break;
3615             }
3616           return ERROR;
3617 #endif
3618
3619         }
3620       break;
3621       }
3622
3623     #ifdef EXPERIMENTAL_DCC
3624     case ACLC_DCC:
3625       {
3626       /* Separate the regular expression and any optional parameters. */
3627       const uschar * list = arg;
3628       uschar *ss = string_nextinlist(&list, &sep, NULL, 0);
3629       /* Run the dcc backend. */
3630       rc = dcc_process(&ss);
3631       /* Modify return code based upon the existence of options. */
3632       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
3633         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3634           rc = FAIL;   /* FAIL so that the message is passed to the next ACL */
3635       }
3636     break;
3637     #endif
3638
3639     #ifdef WITH_CONTENT_SCAN
3640     case ACLC_DECODE:
3641     rc = mime_decode(&arg);
3642     break;
3643     #endif
3644
3645     case ACLC_DELAY:
3646       {
3647       int delay = readconf_readtime(arg, 0, FALSE);
3648       if (delay < 0)
3649         {
3650         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3651           "modifier: \"%s\" is not a time value", arg);
3652         return ERROR;
3653         }
3654       else
3655         {
3656         HDEBUG(D_acl) debug_printf_indent("delay modifier requests %d-second delay\n",
3657           delay);
3658         if (host_checking)
3659           {
3660           HDEBUG(D_acl)
3661             debug_printf_indent("delay skipped in -bh checking mode\n");
3662           }
3663
3664         /* NOTE 1: Remember that we may be
3665         dealing with stdin/stdout here, in addition to TCP/IP connections.
3666         Also, delays may be specified for non-SMTP input, where smtp_out and
3667         smtp_in will be NULL. Whatever is done must work in all cases.
3668
3669         NOTE 2: The added feature of flushing the output before a delay must
3670         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3671         */
3672
3673         else
3674           {
3675           if (smtp_out && !f.disable_delay_flush)
3676             mac_smtp_fflush();
3677
3678 #if !defined(NO_POLL_H) && defined (POLLRDHUP)
3679             {
3680             struct pollfd p;
3681             nfds_t n = 0;
3682             if (smtp_out)
3683               {
3684               p.fd = fileno(smtp_out);
3685               p.events = POLLRDHUP;
3686               n = 1;
3687               }
3688             if (poll(&p, n, delay*1000) > 0)
3689               HDEBUG(D_acl) debug_printf_indent("delay cancelled by peer close\n");
3690             }
3691 #else
3692           /* Lacking POLLRDHUP it appears to be impossible to detect that a
3693           TCP/IP connection has gone away without reading from it. This means
3694           that we cannot shorten the delay below if the client goes away,
3695           because we cannot discover that the client has closed its end of the
3696           connection. (The connection is actually in a half-closed state,
3697           waiting for the server to close its end.) It would be nice to be able
3698           to detect this state, so that the Exim process is not held up
3699           unnecessarily. However, it seems that we can't. The poll() function
3700           does not do the right thing, and in any case it is not always
3701           available.  */
3702
3703           while (delay > 0) delay = sleep(delay);
3704 #endif
3705           }
3706         }
3707       }
3708     break;
3709
3710 #ifndef DISABLE_DKIM
3711     case ACLC_DKIM_SIGNER:
3712     if (dkim_cur_signer)
3713       rc = match_isinlist(dkim_cur_signer,
3714                           &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3715     else
3716       rc = FAIL;
3717     break;
3718
3719     case ACLC_DKIM_STATUS:
3720     rc = match_isinlist(dkim_verify_status,
3721                         &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3722     break;
3723 #endif
3724
3725 #ifdef SUPPORT_DMARC
3726     case ACLC_DMARC_STATUS:
3727     if (!f.dmarc_has_been_checked)
3728       dmarc_process();
3729     f.dmarc_has_been_checked = TRUE;
3730     /* used long way of dmarc_exim_expand_query() in case we need more
3731      * view into the process in the future. */
3732     rc = match_isinlist(dmarc_exim_expand_query(DMARC_VERIFY_STATUS),
3733                         &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3734     break;
3735 #endif
3736
3737     case ACLC_DNSLISTS:
3738     rc = verify_check_dnsbl(where, &arg, log_msgptr);
3739     break;
3740
3741     case ACLC_DOMAINS:
3742     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3743       addr->domain_cache, MCL_DOMAIN, TRUE, CUSS &deliver_domain_data);
3744     break;
3745
3746     /* The value in tls_cipher is the full cipher name, for example,
3747     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3748     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3749     what may in practice come out of the SSL library - which at the time of
3750     writing is poorly documented. */
3751
3752     case ACLC_ENCRYPTED:
3753     if (tls_in.cipher == NULL) rc = FAIL; else
3754       {
3755       uschar *endcipher = NULL;
3756       uschar *cipher = Ustrchr(tls_in.cipher, ':');
3757       if (!cipher) cipher = tls_in.cipher; else
3758         {
3759         endcipher = Ustrchr(++cipher, ':');
3760         if (endcipher) *endcipher = 0;
3761         }
3762       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3763       if (endcipher) *endcipher = ':';
3764       }
3765     break;
3766
3767     /* Use verify_check_this_host() instead of verify_check_host() so that
3768     we can pass over &host_data to catch any looked up data. Once it has been
3769     set, it retains its value so that it's still there if another ACL verb
3770     comes through here and uses the cache. However, we must put it into
3771     permanent store in case it is also expected to be used in a subsequent
3772     message in the same SMTP connection. */
3773
3774     case ACLC_HOSTS:
3775     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3776       sender_host_address ? sender_host_address : US"", CUSS &host_data);
3777     if (rc == DEFER) *log_msgptr = search_error_message;
3778     if (host_data) host_data = string_copy_perm(host_data, TRUE);
3779     break;
3780
3781     case ACLC_LOCAL_PARTS:
3782     rc = match_isinlist(addr->cc_local_part, &arg, 0,
3783       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3784       CUSS &deliver_localpart_data);
3785     break;
3786
3787     case ACLC_LOG_REJECT_TARGET:
3788       {
3789       int logbits = 0;
3790       int sep = 0;
3791       const uschar *s = arg;
3792       uschar * ss;
3793       while ((ss = string_nextinlist(&s, &sep, NULL, 0)))
3794         {
3795         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3796         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3797         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3798         else
3799           {
3800           logbits |= LOG_MAIN|LOG_REJECT;
3801           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3802             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3803           }
3804         }
3805       log_reject_target = logbits;
3806       }
3807     break;
3808
3809     case ACLC_LOGWRITE:
3810       {
3811       int logbits = 0;
3812       const uschar *s = arg;
3813       if (*s == ':')
3814         {
3815         s++;
3816         while (*s != ':')
3817           {
3818           if (Ustrncmp(s, "main", 4) == 0)
3819             { logbits |= LOG_MAIN; s += 4; }
3820           else if (Ustrncmp(s, "panic", 5) == 0)
3821             { logbits |= LOG_PANIC; s += 5; }
3822           else if (Ustrncmp(s, "reject", 6) == 0)
3823             { logbits |= LOG_REJECT; s += 6; }
3824           else
3825             {
3826             logbits = LOG_MAIN|LOG_PANIC;
3827             s = string_sprintf(":unknown log name in \"%s\" in "
3828               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3829             }
3830           if (*s == ',') s++;
3831           }
3832         s++;
3833         }
3834       while (isspace(*s)) s++;
3835
3836       if (logbits == 0) logbits = LOG_MAIN;
3837       log_write(0, logbits, "%s", string_printing(s));
3838       }
3839     break;
3840
3841     #ifdef WITH_CONTENT_SCAN
3842     case ACLC_MALWARE:                  /* Run the malware backend. */
3843       {
3844       /* Separate the regular expression and any optional parameters. */
3845       const uschar * list = arg;
3846       uschar * ss = string_nextinlist(&list, &sep, NULL, 0);
3847       uschar * opt;
3848       BOOL defer_ok = FALSE;
3849       int timeout = 0;
3850
3851       while ((opt = string_nextinlist(&list, &sep, NULL, 0)))
3852         if (strcmpic(opt, US"defer_ok") == 0)
3853           defer_ok = TRUE;
3854         else if (  strncmpic(opt, US"tmo=", 4) == 0
3855                 && (timeout = readconf_readtime(opt+4, '\0', FALSE)) < 0
3856                 )
3857           {
3858           *log_msgptr = string_sprintf("bad timeout value in '%s'", opt);
3859           return ERROR;
3860           }
3861
3862       rc = malware(ss, timeout);
3863       if (rc == DEFER && defer_ok)
3864         rc = FAIL;      /* FAIL so that the message is passed to the next ACL */
3865       }
3866     break;
3867
3868     case ACLC_MIME_REGEX:
3869     rc = mime_regex(&arg);
3870     break;
3871     #endif
3872
3873     case ACLC_QUEUE:
3874       {
3875       uschar *m;
3876       if ((m = is_tainted2(arg, 0, "Tainted name '%s' for queue not permitted", arg)))
3877         {
3878         *log_msgptr = m;
3879         return ERROR;
3880         }
3881       if (Ustrchr(arg, '/'))
3882         {
3883         *log_msgptr = string_sprintf(
3884                 "Directory separator not permitted in queue name: '%s'", arg);
3885         return ERROR;
3886         }
3887       queue_name = string_copy_perm(arg, FALSE);
3888       break;
3889       }
3890
3891     case ACLC_RATELIMIT:
3892     rc = acl_ratelimit(arg, where, log_msgptr);
3893     break;
3894
3895     case ACLC_RECIPIENTS:
3896     rc = match_address_list(CUS addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3897       CUSS &recipient_data);
3898     break;
3899
3900     #ifdef WITH_CONTENT_SCAN
3901     case ACLC_REGEX:
3902     rc = regex(&arg);
3903     break;
3904     #endif
3905
3906     case ACLC_REMOVE_HEADER:
3907     setup_remove_header(arg);
3908     break;
3909
3910     case ACLC_SEEN:
3911     rc = acl_seen(arg, where, log_msgptr);
3912     break;
3913
3914     case ACLC_SENDER_DOMAINS:
3915       {
3916       uschar *sdomain;
3917       sdomain = Ustrrchr(sender_address, '@');
3918       sdomain = sdomain ? sdomain + 1 : US"";
3919       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3920         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3921       }
3922     break;
3923
3924     case ACLC_SENDERS:
3925     rc = match_address_list(CUS sender_address, TRUE, TRUE, &arg,
3926       sender_address_cache, -1, 0, CUSS &sender_data);
3927     break;
3928
3929     /* Connection variables must persist forever; message variables not */
3930
3931     case ACLC_SET:
3932       {
3933       int old_pool = store_pool;
3934       if (  cb->u.varname[0] != 'm'
3935 #ifndef DISABLE_EVENT
3936          || event_name          /* An event is being delivered */
3937 #endif
3938          )
3939         store_pool = POOL_PERM;
3940 #ifndef DISABLE_DKIM    /* Overwriteable dkim result variables */
3941       if (Ustrcmp(cb->u.varname, "dkim_verify_status") == 0)
3942         dkim_verify_status = string_copy(arg);
3943       else if (Ustrcmp(cb->u.varname, "dkim_verify_reason") == 0)
3944         dkim_verify_reason = string_copy(arg);
3945       else
3946 #endif
3947         acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
3948       store_pool = old_pool;
3949       }
3950     break;
3951
3952 #ifdef WITH_CONTENT_SCAN
3953     case ACLC_SPAM:
3954       {
3955       /* Separate the regular expression and any optional parameters. */
3956       const uschar * list = arg;
3957       uschar *ss = string_nextinlist(&list, &sep, NULL, 0);
3958
3959       rc = spam(CUSS &ss);
3960       /* Modify return code based upon the existence of options. */
3961       while ((ss = string_nextinlist(&list, &sep, NULL, 0)))
3962         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3963           rc = FAIL;    /* FAIL so that the message is passed to the next ACL */
3964       }
3965     break;
3966 #endif
3967
3968 #ifdef SUPPORT_SPF
3969     case ACLC_SPF:
3970       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
3971     break;
3972     case ACLC_SPF_GUESS:
3973       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
3974     break;
3975 #endif
3976
3977     case ACLC_UDPSEND:
3978     rc = acl_udpsend(arg, log_msgptr);
3979     break;
3980
3981     /* If the verb is WARN, discard any user message from verification, because
3982     such messages are SMTP responses, not header additions. The latter come
3983     only from explicit "message" modifiers. However, put the user message into
3984     $acl_verify_message so it can be used in subsequent conditions or modifiers
3985     (until something changes it). */
3986
3987     case ACLC_VERIFY:
3988     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
3989     if (*user_msgptr)
3990       acl_verify_message = *user_msgptr;
3991     if (verb == ACL_WARN) *user_msgptr = NULL;
3992     break;
3993
3994     default:
3995     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
3996       "condition %d", cb->type);
3997     break;
3998     }
3999
4000   /* If a condition was negated, invert OK/FAIL. */
4001
4002   if (!conditions[cb->type].is_modifier && cb->u.negated)
4003     if (rc == OK) rc = FAIL;
4004     else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
4005
4006   if (rc != OK) break;   /* Conditions loop */
4007   }
4008
4009
4010 /* If the result is the one for which "message" and/or "log_message" are used,
4011 handle the values of these modifiers. If there isn't a log message set, we make
4012 it the same as the user message.
4013
4014 "message" is a user message that will be included in an SMTP response. Unless
4015 it is empty, it overrides any previously set user message.
4016
4017 "log_message" is a non-user message, and it adds to any existing non-user
4018 message that is already set.
4019
4020 Most verbs have but a single return for which the messages are relevant, but
4021 for "discard", it's useful to have the log message both when it succeeds and
4022 when it fails. For "accept", the message is used in the OK case if there is no
4023 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
4024 present. */
4025
4026 if (*epp && rc == OK) user_message = NULL;
4027
4028 if ((BIT(rc) & msgcond[verb]) != 0)
4029   {
4030   uschar *expmessage;
4031   uschar *old_user_msgptr = *user_msgptr;
4032   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
4033
4034   /* If the verb is "warn", messages generated by conditions (verification or
4035   nested ACLs) are always discarded. This also happens for acceptance verbs
4036   when they actually do accept. Only messages specified at this level are used.
4037   However, the value of an existing message is available in $acl_verify_message
4038   during expansions. */
4039
4040   if (verb == ACL_WARN ||
4041       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
4042     *log_msgptr = *user_msgptr = NULL;
4043
4044   if (user_message)
4045     {
4046     acl_verify_message = old_user_msgptr;
4047     expmessage = expand_string(user_message);
4048     if (!expmessage)
4049       {
4050       if (!f.expand_string_forcedfail)
4051         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
4052           user_message, expand_string_message);
4053       }
4054     else if (expmessage[0] != 0) *user_msgptr = expmessage;
4055     }
4056
4057   if (log_message)
4058     {
4059     acl_verify_message = old_log_msgptr;
4060     expmessage = expand_string(log_message);
4061     if (!expmessage)
4062       {
4063       if (!f.expand_string_forcedfail)
4064         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
4065           log_message, expand_string_message);
4066       }
4067     else if (expmessage[0] != 0)
4068       {
4069       *log_msgptr = (*log_msgptr == NULL)? expmessage :
4070         string_sprintf("%s: %s", expmessage, *log_msgptr);
4071       }
4072     }
4073
4074   /* If no log message, default it to the user message */
4075
4076   if (!*log_msgptr) *log_msgptr = *user_msgptr;
4077   }
4078
4079 acl_verify_message = NULL;
4080 return rc;
4081 }
4082
4083
4084
4085
4086
4087 /*************************************************
4088 *        Get line from a literal ACL             *
4089 *************************************************/
4090
4091 /* This function is passed to acl_read() in order to extract individual lines
4092 of a literal ACL, which we access via static pointers. We can destroy the
4093 contents because this is called only once (the compiled ACL is remembered).
4094
4095 This code is intended to treat the data in the same way as lines in the main
4096 Exim configuration file. That is:
4097
4098   . Leading spaces are ignored.
4099
4100   . A \ at the end of a line is a continuation - trailing spaces after the \
4101     are permitted (this is because I don't believe in making invisible things
4102     significant). Leading spaces on the continued part of a line are ignored.
4103
4104   . Physical lines starting (significantly) with # are totally ignored, and
4105     may appear within a sequence of backslash-continued lines.
4106
4107   . Blank lines are ignored, but will end a sequence of continuations.
4108
4109 Arguments: none
4110 Returns:   a pointer to the next line
4111 */
4112
4113
4114 static uschar *acl_text;          /* Current pointer in the text */
4115 static uschar *acl_text_end;      /* Points one past the terminating '0' */
4116
4117
4118 static uschar *
4119 acl_getline(void)
4120 {
4121 uschar *yield;
4122
4123 /* This loop handles leading blank lines and comments. */
4124
4125 for(;;)
4126   {
4127   Uskip_whitespace(&acl_text);          /* Leading spaces/empty lines */
4128   if (!*acl_text) return NULL;          /* No more data */
4129   yield = acl_text;                     /* Potential data line */
4130
4131   while (*acl_text && *acl_text != '\n') acl_text++;
4132
4133   /* If we hit the end before a newline, we have the whole logical line. If
4134   it's a comment, there's no more data to be given. Otherwise, yield it. */
4135
4136   if (!*acl_text) return *yield == '#' ? NULL : yield;
4137
4138   /* After reaching a newline, end this loop if the physical line does not
4139   start with '#'. If it does, it's a comment, and the loop continues. */
4140
4141   if (*yield != '#') break;
4142   }
4143
4144 /* This loop handles continuations. We know we have some real data, ending in
4145 newline. See if there is a continuation marker at the end (ignoring trailing
4146 white space). We know that *yield is not white space, so no need to test for
4147 cont > yield in the backwards scanning loop. */
4148
4149 for(;;)
4150   {
4151   uschar *cont;
4152   for (cont = acl_text - 1; isspace(*cont); cont--);
4153
4154   /* If no continuation follows, we are done. Mark the end of the line and
4155   return it. */
4156
4157   if (*cont != '\\')
4158     {
4159     *acl_text++ = 0;
4160     return yield;
4161     }
4162
4163   /* We have encountered a continuation. Skip over whitespace at the start of
4164   the next line, and indeed the whole of the next line or lines if they are
4165   comment lines. */
4166
4167   for (;;)
4168     {
4169     while (*(++acl_text) == ' ' || *acl_text == '\t');
4170     if (*acl_text != '#') break;
4171     while (*(++acl_text) != 0 && *acl_text != '\n');
4172     }
4173
4174   /* We have the start of a continuation line. Move all the rest of the data
4175   to join onto the previous line, and then find its end. If the end is not a
4176   newline, we are done. Otherwise loop to look for another continuation. */
4177
4178   memmove(cont, acl_text, acl_text_end - acl_text);
4179   acl_text_end -= acl_text - cont;
4180   acl_text = cont;
4181   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
4182   if (*acl_text == 0) return yield;
4183   }
4184
4185 /* Control does not reach here */
4186 }
4187
4188
4189
4190
4191
4192 /*************************************************
4193 *        Check access using an ACL               *
4194 *************************************************/
4195
4196 /* This function is called from address_check. It may recurse via
4197 acl_check_condition() - hence the use of a level to stop looping. The ACL is
4198 passed as a string which is expanded. A forced failure implies no access check
4199 is required. If the result is a single word, it is taken as the name of an ACL
4200 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
4201 text, complete with newlines, and parsed as such. In both cases, the ACL check
4202 is then run. This function uses an auxiliary function for acl_read() to call
4203 for reading individual lines of a literal ACL. This is acl_getline(), which
4204 appears immediately above.
4205
4206 Arguments:
4207   where        where called from
4208   addr         address item when called from RCPT; otherwise NULL
4209   s            the input string; NULL is the same as an empty ACL => DENY
4210   user_msgptr  where to put a user error (for SMTP response)
4211   log_msgptr   where to put a logging message (not for SMTP response)
4212
4213 Returns:       OK         access is granted
4214                DISCARD    access is apparently granted...
4215                FAIL       access is denied
4216                FAIL_DROP  access is denied; drop the connection
4217                DEFER      can't tell at the moment
4218                ERROR      disaster
4219 */
4220
4221 static int
4222 acl_check_internal(int where, address_item *addr, uschar *s,
4223   uschar **user_msgptr, uschar **log_msgptr)
4224 {
4225 int fd = -1;
4226 acl_block *acl = NULL;
4227 uschar *acl_name = US"inline ACL";
4228 uschar *ss;
4229
4230 /* Catch configuration loops */
4231
4232 if (acl_level > 20)
4233   {
4234   *log_msgptr = US"ACL nested too deep: possible loop";
4235   return ERROR;
4236   }
4237
4238 if (!s)
4239   {
4240   HDEBUG(D_acl) debug_printf_indent("ACL is NULL: implicit DENY\n");
4241   return FAIL;
4242   }
4243
4244 /* At top level, we expand the incoming string. At lower levels, it has already
4245 been expanded as part of condition processing. */
4246
4247 if (acl_level == 0)
4248   {
4249   if (!(ss = expand_string(s)))
4250     {
4251     if (f.expand_string_forcedfail) return OK;
4252     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
4253       expand_string_message);
4254     return ERROR;
4255     }
4256   }
4257 else ss = s;
4258
4259 while (isspace(*ss)) ss++;
4260
4261 /* If we can't find a named ACL, the default is to parse it as an inline one.
4262 (Unless it begins with a slash; non-existent files give rise to an error.) */
4263
4264 acl_text = ss;
4265
4266 if (  !f.running_in_test_harness
4267    &&  is_tainted2(acl_text, LOG_MAIN|LOG_PANIC,
4268                           "Tainted ACL text \"%s\"", acl_text))
4269   {
4270   /* Avoid leaking info to an attacker */
4271   *log_msgptr = US"internal configuration error";
4272   return ERROR;
4273   }
4274
4275 /* Handle the case of a string that does not contain any spaces. Look for a
4276 named ACL among those read from the configuration, or a previously read file.
4277 It is possible that the pointer to the ACL is NULL if the configuration
4278 contains a name with no data. If not found, and the text begins with '/',
4279 read an ACL from a file, and save it so it can be re-used. */
4280
4281 if (Ustrchr(ss, ' ') == NULL)
4282   {
4283   tree_node * t = tree_search(acl_anchor, ss);
4284   if (t)
4285     {
4286     if (!(acl = (acl_block *)(t->data.ptr)))
4287       {
4288       HDEBUG(D_acl) debug_printf_indent("ACL \"%s\" is empty: implicit DENY\n", ss);
4289       return FAIL;
4290       }
4291     acl_name = string_sprintf("ACL \"%s\"", ss);
4292     HDEBUG(D_acl) debug_printf_indent("using ACL \"%s\"\n", ss);
4293     }
4294
4295   else if (*ss == '/')
4296     {
4297     struct stat statbuf;
4298     if (is_tainted2(ss, LOG_MAIN|LOG_PANIC, "Tainted ACL file name '%s'", ss))
4299       {
4300       /* Avoid leaking info to an attacker */
4301       *log_msgptr = US"internal configuration error";
4302       return ERROR;
4303       }
4304     if ((fd = Uopen(ss, O_RDONLY, 0)) < 0)
4305       {
4306       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
4307         strerror(errno));
4308       return ERROR;
4309       }
4310     if (fstat(fd, &statbuf) != 0)
4311       {
4312       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
4313         strerror(errno));
4314       return ERROR;
4315       }
4316
4317     /* If the string being used as a filename is tainted, so is the file content */
4318     acl_text = store_get(statbuf.st_size + 1, is_tainted(ss));
4319     acl_text_end = acl_text + statbuf.st_size + 1;
4320
4321     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
4322       {
4323       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
4324         ss, strerror(errno));
4325       return ERROR;
4326       }
4327     acl_text[statbuf.st_size] = 0;
4328     (void)close(fd);
4329
4330     acl_name = string_sprintf("ACL \"%s\"", ss);
4331     HDEBUG(D_acl) debug_printf_indent("read ACL from file %s\n", ss);
4332     }
4333   }
4334
4335 /* Parse an ACL that is still in text form. If it came from a file, remember it
4336 in the ACL tree, having read it into the POOL_PERM store pool so that it
4337 persists between multiple messages. */
4338
4339 if (!acl)
4340   {
4341   int old_pool = store_pool;
4342   if (fd >= 0) store_pool = POOL_PERM;
4343   acl = acl_read(acl_getline, log_msgptr);
4344   store_pool = old_pool;
4345   if (!acl && *log_msgptr) return ERROR;
4346   if (fd >= 0)
4347     {
4348     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss), is_tainted(ss));
4349     Ustrcpy(t->name, ss);
4350     t->data.ptr = acl;
4351     (void)tree_insertnode(&acl_anchor, t);
4352     }
4353   }
4354
4355 /* Now we have an ACL to use. It's possible it may be NULL. */
4356
4357 while (acl)
4358   {
4359   int cond;
4360   int basic_errno = 0;
4361   BOOL endpass_seen = FALSE;
4362   BOOL acl_quit_check = acl_level == 0
4363     && (where == ACL_WHERE_QUIT || where == ACL_WHERE_NOTQUIT);
4364
4365   *log_msgptr = *user_msgptr = NULL;
4366   f.acl_temp_details = FALSE;
4367
4368   HDEBUG(D_acl) debug_printf_indent("processing \"%s\" (%s %d)\n",
4369     verbs[acl->verb], acl->srcfile, acl->srcline);
4370
4371   /* Clear out any search error message from a previous check before testing
4372   this condition. */
4373
4374   search_error_message = NULL;
4375   cond = acl_check_condition(acl->verb, acl->condition, where, addr, acl_level,
4376     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
4377
4378   /* Handle special returns: DEFER causes a return except on a WARN verb;
4379   ERROR always causes a return. */
4380
4381   switch (cond)
4382     {
4383     case DEFER:
4384       HDEBUG(D_acl) debug_printf_indent("%s: condition test deferred in %s\n",
4385         verbs[acl->verb], acl_name);
4386       if (basic_errno != ERRNO_CALLOUTDEFER)
4387         {
4388         if (search_error_message != NULL && *search_error_message != 0)
4389           *log_msgptr = search_error_message;
4390         if (smtp_return_error_details) f.acl_temp_details = TRUE;
4391         }
4392       else
4393         f.acl_temp_details = TRUE;
4394       if (acl->verb != ACL_WARN) return DEFER;
4395       break;
4396
4397     default:      /* Paranoia */
4398     case ERROR:
4399       HDEBUG(D_acl) debug_printf_indent("%s: condition test error in %s\n",
4400         verbs[acl->verb], acl_name);
4401       return ERROR;
4402
4403     case OK:
4404       HDEBUG(D_acl) debug_printf_indent("%s: condition test succeeded in %s\n",
4405         verbs[acl->verb], acl_name);
4406       break;
4407
4408     case FAIL:
4409       HDEBUG(D_acl) debug_printf_indent("%s: condition test failed in %s\n",
4410         verbs[acl->verb], acl_name);
4411       break;
4412
4413     /* DISCARD and DROP can happen only from a nested ACL condition, and
4414     DISCARD can happen only for an "accept" or "discard" verb. */
4415
4416     case DISCARD:
4417       HDEBUG(D_acl) debug_printf_indent("%s: condition test yielded \"discard\" in %s\n",
4418         verbs[acl->verb], acl_name);
4419       break;
4420
4421     case FAIL_DROP:
4422       HDEBUG(D_acl) debug_printf_indent("%s: condition test yielded \"drop\" in %s\n",
4423         verbs[acl->verb], acl_name);
4424       break;
4425     }
4426
4427   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
4428   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
4429   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
4430
4431   switch(acl->verb)
4432     {
4433     case ACL_ACCEPT:
4434       if (cond == OK || cond == DISCARD)
4435         {
4436         HDEBUG(D_acl) debug_printf_indent("end of %s: ACCEPT\n", acl_name);
4437         return cond;
4438         }
4439       if (endpass_seen)
4440         {
4441         HDEBUG(D_acl) debug_printf_indent("accept: endpass encountered - denying access\n");
4442         return cond;
4443         }
4444       break;
4445
4446     case ACL_DEFER:
4447       if (cond == OK)
4448         {
4449         HDEBUG(D_acl) debug_printf_indent("end of %s: DEFER\n", acl_name);
4450         if (acl_quit_check) goto badquit;
4451         f.acl_temp_details = TRUE;
4452         return DEFER;
4453         }
4454       break;
4455
4456     case ACL_DENY:
4457       if (cond == OK)
4458         {
4459         HDEBUG(D_acl) debug_printf_indent("end of %s: DENY\n", acl_name);
4460         if (acl_quit_check) goto badquit;
4461         return FAIL;
4462         }
4463       break;
4464
4465     case ACL_DISCARD:
4466       if (cond == OK || cond == DISCARD)
4467         {
4468         HDEBUG(D_acl) debug_printf_indent("end of %s: DISCARD\n", acl_name);
4469         if (acl_quit_check) goto badquit;
4470         return DISCARD;
4471         }
4472       if (endpass_seen)
4473         {
4474         HDEBUG(D_acl)
4475           debug_printf_indent("discard: endpass encountered - denying access\n");
4476         return cond;
4477         }
4478       break;
4479
4480     case ACL_DROP:
4481       if (cond == OK)
4482         {
4483         HDEBUG(D_acl) debug_printf_indent("end of %s: DROP\n", acl_name);
4484         if (acl_quit_check) goto badquit;
4485         return FAIL_DROP;
4486         }
4487       break;
4488
4489     case ACL_REQUIRE:
4490       if (cond != OK)
4491         {
4492         HDEBUG(D_acl) debug_printf_indent("end of %s: not OK\n", acl_name);
4493         if (acl_quit_check) goto badquit;
4494         return cond;
4495         }
4496       break;
4497
4498     case ACL_WARN:
4499       if (cond == OK)
4500         acl_warn(where, *user_msgptr, *log_msgptr);
4501       else if (cond == DEFER && LOGGING(acl_warn_skipped))
4502         log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
4503           "condition test deferred%s%s", host_and_ident(TRUE),
4504           (*log_msgptr == NULL)? US"" : US": ",
4505           (*log_msgptr == NULL)? US"" : *log_msgptr);
4506       *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
4507       break;
4508
4509     default:
4510       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
4511         acl->verb);
4512       break;
4513     }
4514
4515   /* Pass to the next ACL item */
4516
4517   acl = acl->next;
4518   }
4519
4520 /* We have reached the end of the ACL. This is an implicit DENY. */
4521
4522 HDEBUG(D_acl) debug_printf_indent("end of %s: implicit DENY\n", acl_name);
4523 return FAIL;
4524
4525 badquit:
4526   *log_msgptr = string_sprintf("QUIT or not-QUIT toplevel ACL may not fail "
4527     "('%s' verb used incorrectly)", verbs[acl->verb]);
4528   return ERROR;
4529 }
4530
4531
4532
4533
4534 /* Same args as acl_check_internal() above, but the string s is
4535 the name of an ACL followed optionally by up to 9 space-separated arguments.
4536 The name and args are separately expanded.  Args go into $acl_arg globals. */
4537 static int
4538 acl_check_wargs(int where, address_item *addr, const uschar *s,
4539   uschar **user_msgptr, uschar **log_msgptr)
4540 {
4541 uschar * tmp;
4542 uschar * tmp_arg[9];    /* must match acl_arg[] */
4543 uschar * sav_arg[9];    /* must match acl_arg[] */
4544 int sav_narg;
4545 uschar * name;
4546 int i;
4547 int ret;
4548
4549 if (!(tmp = string_dequote(&s)) || !(name = expand_string(tmp)))
4550   goto bad;
4551
4552 for (i = 0; i < 9; i++)
4553   {
4554   while (*s && isspace(*s)) s++;
4555   if (!*s) break;
4556   if (!(tmp = string_dequote(&s)) || !(tmp_arg[i] = expand_string(tmp)))
4557     {
4558     tmp = name;
4559     goto bad;
4560     }
4561   }
4562
4563 sav_narg = acl_narg;
4564 acl_narg = i;
4565 for (i = 0; i < acl_narg; i++)
4566   {
4567   sav_arg[i] = acl_arg[i];
4568   acl_arg[i] = tmp_arg[i];
4569   }
4570 while (i < 9)
4571   {
4572   sav_arg[i] = acl_arg[i];
4573   acl_arg[i++] = NULL;
4574   }
4575
4576 acl_level++;
4577 ret = acl_check_internal(where, addr, name, user_msgptr, log_msgptr);
4578 acl_level--;
4579
4580 acl_narg = sav_narg;
4581 for (i = 0; i < 9; i++) acl_arg[i] = sav_arg[i];
4582 return ret;
4583
4584 bad:
4585 if (f.expand_string_forcedfail) return ERROR;
4586 *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
4587   tmp, expand_string_message);
4588 return f.search_find_defer ? DEFER : ERROR;
4589 }
4590
4591
4592
4593 /*************************************************
4594 *        Check access using an ACL               *
4595 *************************************************/
4596
4597 /* Alternate interface for ACL, used by expansions */
4598 int
4599 acl_eval(int where, uschar *s, uschar **user_msgptr, uschar **log_msgptr)
4600 {
4601 address_item adb;
4602 address_item *addr = NULL;
4603 int rc;
4604
4605 *user_msgptr = *log_msgptr = NULL;
4606 sender_verified_failed = NULL;
4607 ratelimiters_cmd = NULL;
4608 log_reject_target = LOG_MAIN|LOG_REJECT;
4609
4610 if (where == ACL_WHERE_RCPT)
4611   {
4612   adb = address_defaults;
4613   addr = &adb;
4614   addr->address = expand_string(US"$local_part@$domain");
4615   addr->domain = deliver_domain;
4616   addr->local_part = deliver_localpart;
4617   addr->cc_local_part = deliver_localpart;
4618   addr->lc_local_part = deliver_localpart;
4619   }
4620
4621 acl_level++;
4622 rc = acl_check_internal(where, addr, s, user_msgptr, log_msgptr);
4623 acl_level--;
4624 return rc;
4625 }
4626
4627
4628
4629 /* This is the external interface for ACL checks. It sets up an address and the
4630 expansions for $domain and $local_part when called after RCPT, then calls
4631 acl_check_internal() to do the actual work.
4632
4633 Arguments:
4634   where        ACL_WHERE_xxxx indicating where called from
4635   recipient    RCPT address for RCPT check, else NULL
4636   s            the input string; NULL is the same as an empty ACL => DENY
4637   user_msgptr  where to put a user error (for SMTP response)
4638   log_msgptr   where to put a logging message (not for SMTP response)
4639
4640 Returns:       OK         access is granted by an ACCEPT verb
4641                DISCARD    access is granted by a DISCARD verb
4642                FAIL       access is denied
4643                FAIL_DROP  access is denied; drop the connection
4644                DEFER      can't tell at the moment
4645                ERROR      disaster
4646 */
4647 int acl_where = ACL_WHERE_UNKNOWN;
4648
4649 int
4650 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
4651   uschar **log_msgptr)
4652 {
4653 int rc;
4654 address_item adb;
4655 address_item *addr = NULL;
4656
4657 *user_msgptr = *log_msgptr = NULL;
4658 sender_verified_failed = NULL;
4659 ratelimiters_cmd = NULL;
4660 log_reject_target = LOG_MAIN|LOG_REJECT;
4661
4662 #ifndef DISABLE_PRDR
4663 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY || where==ACL_WHERE_PRDR)
4664 #else
4665 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY)
4666 #endif
4667   {
4668   adb = address_defaults;
4669   addr = &adb;
4670   addr->address = recipient;
4671   if (deliver_split_address(addr) == DEFER)
4672     {
4673     *log_msgptr = US"defer in percent_hack_domains check";
4674     return DEFER;
4675     }
4676 #ifdef SUPPORT_I18N
4677   if ((addr->prop.utf8_msg = message_smtputf8))
4678     {
4679     addr->prop.utf8_downcvt =       message_utf8_downconvert == 1;
4680     addr->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
4681     }
4682 #endif
4683   deliver_domain = addr->domain;
4684   deliver_localpart = addr->local_part;
4685   }
4686
4687 acl_where = where;
4688 acl_level = 0;
4689 rc = acl_check_internal(where, addr, s, user_msgptr, log_msgptr);
4690 acl_level = 0;
4691 acl_where = ACL_WHERE_UNKNOWN;
4692
4693 /* Cutthrough - if requested,
4694 and WHERE_RCPT and not yet opened conn as result of recipient-verify,
4695 and rcpt acl returned accept,
4696 and first recipient (cancel on any subsequents)
4697 open one now and run it up to RCPT acceptance.
4698 A failed verify should cancel cutthrough request,
4699 and will pass the fail to the originator.
4700 Initial implementation:  dual-write to spool.
4701 Assume the rxd datastream is now being copied byte-for-byte to an open cutthrough connection.
4702
4703 Cease cutthrough copy on rxd final dot; do not send one.
4704
4705 On a data acl, if not accept and a cutthrough conn is open, hard-close it (no SMTP niceness).
4706
4707 On data acl accept, terminate the dataphase on an open cutthrough conn.  If accepted or
4708 perm-rejected, reflect that to the original sender - and dump the spooled copy.
4709 If temp-reject, close the conn (and keep the spooled copy).
4710 If conn-failure, no action (and keep the spooled copy).
4711 */
4712 switch (where)
4713   {
4714   case ACL_WHERE_RCPT:
4715 #ifndef DISABLE_PRDR
4716   case ACL_WHERE_PRDR:
4717 #endif
4718
4719     if (f.host_checking_callout)        /* -bhc mode */
4720       cancel_cutthrough_connection(TRUE, US"host-checking mode");
4721
4722     else if (  rc == OK
4723             && cutthrough.delivery
4724             && rcpt_count > cutthrough.nrcpt
4725             )
4726       {
4727       if ((rc = open_cutthrough_connection(addr)) == DEFER)
4728         if (cutthrough.defer_pass)
4729           {
4730           uschar * s = addr->message;
4731           /* Horrid kludge to recover target's SMTP message */
4732           while (*s) s++;
4733           do --s; while (!isdigit(*s));
4734           if (*--s && isdigit(*s) && *--s && isdigit(*s)) *user_msgptr = s;
4735           f.acl_temp_details = TRUE;
4736           }
4737         else
4738           {
4739           HDEBUG(D_acl) debug_printf_indent("cutthrough defer; will spool\n");
4740           rc = OK;
4741           }
4742       }
4743     else HDEBUG(D_acl) if (cutthrough.delivery)
4744       if (rcpt_count <= cutthrough.nrcpt)
4745         debug_printf_indent("ignore cutthrough request; nonfirst message\n");
4746       else if (rc != OK)
4747         debug_printf_indent("ignore cutthrough request; ACL did not accept\n");
4748     break;
4749
4750   case ACL_WHERE_PREDATA:
4751     if (rc == OK)
4752       cutthrough_predata();
4753     else
4754       cancel_cutthrough_connection(TRUE, US"predata acl not ok");
4755     break;
4756
4757   case ACL_WHERE_QUIT:
4758   case ACL_WHERE_NOTQUIT:
4759     /* Drop cutthrough conns, and drop heldopen verify conns if
4760     the previous was not DATA */
4761     {
4762     uschar prev =
4763       smtp_connection_had[SMTP_HBUFF_PREV(SMTP_HBUFF_PREV(smtp_ch_index))];
4764     BOOL dropverify = !(prev == SCH_DATA || prev == SCH_BDAT);
4765
4766     cancel_cutthrough_connection(dropverify, US"quit or conndrop");
4767     break;
4768     }
4769
4770   default:
4771     break;
4772   }
4773
4774 deliver_domain = deliver_localpart = deliver_address_data =
4775   deliver_domain_data = sender_address_data = NULL;
4776
4777 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
4778 ACL, which is really in the middle of an SMTP command. */
4779
4780 if (rc == DISCARD)
4781   {
4782   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
4783     {
4784     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
4785       "ACL", acl_wherenames[where]);
4786     return ERROR;
4787     }
4788   return DISCARD;
4789   }
4790
4791 /* A DROP response is not permitted from MAILAUTH */
4792
4793 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
4794   {
4795   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
4796     "ACL", acl_wherenames[where]);
4797   return ERROR;
4798   }
4799
4800 /* Before giving a response, take a look at the length of any user message, and
4801 split it up into multiple lines if possible. */
4802
4803 *user_msgptr = string_split_message(*user_msgptr);
4804 if (fake_response != OK)
4805   fake_response_text = string_split_message(fake_response_text);
4806
4807 return rc;
4808 }
4809
4810
4811 /*************************************************
4812 *             Create ACL variable                *
4813 *************************************************/
4814
4815 /* Create an ACL variable or reuse an existing one. ACL variables are in a
4816 binary tree (see tree.c) with acl_var_c and acl_var_m as root nodes.
4817
4818 Argument:
4819   name    pointer to the variable's name, starting with c or m
4820
4821 Returns   the pointer to variable's tree node
4822 */
4823
4824 tree_node *
4825 acl_var_create(uschar * name)
4826 {
4827 tree_node * node, ** root = name[0] == 'c' ? &acl_var_c : &acl_var_m;
4828 if (!(node = tree_search(*root, name)))
4829   {
4830   node = store_get(sizeof(tree_node) + Ustrlen(name), is_tainted(name));
4831   Ustrcpy(node->name, name);
4832   (void)tree_insertnode(root, node);
4833   }
4834 node->data.ptr = NULL;
4835 return node;
4836 }
4837
4838
4839
4840 /*************************************************
4841 *       Write an ACL variable in spool format    *
4842 *************************************************/
4843
4844 /* This function is used as a callback for tree_walk when writing variables to
4845 the spool file. To retain spool file compatibility, what is written is -aclc or
4846 -aclm followed by the rest of the name and the data length, space separated,
4847 then the value itself, starting on a new line, and terminated by an additional
4848 newline. When we had only numbered ACL variables, the first line might look
4849 like this: "-aclc 5 20". Now it might be "-aclc foo 20" for the variable called
4850 acl_cfoo.
4851
4852 Arguments:
4853   name    of the variable
4854   value   of the variable
4855   ctx     FILE pointer (as a void pointer)
4856
4857 Returns:  nothing
4858 */
4859
4860 void
4861 acl_var_write(uschar *name, uschar *value, void *ctx)
4862 {
4863 FILE *f = (FILE *)ctx;
4864 if (is_tainted(value)) putc('-', f);
4865 fprintf(f, "-acl%c %s %d\n%s\n", name[0], name+1, Ustrlen(value), value);
4866 }
4867
4868 #endif  /* !MACRO_PREDEF */
4869 /* vi: aw ai sw=2
4870 */
4871 /* End of acl.c */