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