src/src/acl.c

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