src/src/acl.c

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