src/src/acl.c

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