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 header_line * h = acl_added_headers;
1163 uschar * s;
1164 uschar * cp;
1165 int size = 0;
1166 int ptr = 0;
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_cat(ret, &size, &ptr, s, cp-s+1);
1179     ret = string_cat(ret, &size, &ptr, US"\n", 1);
1180     s = cp+1;
1181     }
1182   /* last bit of header */
1183
1184   ret = string_cat(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 uschar *debug_tag = NULL;
2980 uschar *debug_opts = NULL;
2981 int rc = OK;
2982 #ifdef WITH_CONTENT_SCAN
2983 int sep = -'/';
2984 #endif
2985
2986 for (; cb != NULL; cb = cb->next)
2987   {
2988   const uschar *arg;
2989   int control_type;
2990
2991   /* The message and log_message items set up messages to be used in
2992   case of rejection. They are expanded later. */
2993
2994   if (cb->type == ACLC_MESSAGE)
2995     {
2996     HDEBUG(D_acl) debug_printf("  message: %s\n", cb->arg);
2997     user_message = cb->arg;
2998     continue;
2999     }
3000
3001   if (cb->type == ACLC_LOG_MESSAGE)
3002     {
3003     HDEBUG(D_acl) debug_printf("l_message: %s\n", cb->arg);
3004     log_message = cb->arg;
3005     continue;
3006     }
3007
3008   /* The endpass "condition" just sets a flag to show it occurred. This is
3009   checked at compile time to be on an "accept" or "discard" item. */
3010
3011   if (cb->type == ACLC_ENDPASS)
3012     {
3013     *epp = TRUE;
3014     continue;
3015     }
3016
3017   /* For other conditions and modifiers, the argument is expanded now for some
3018   of them, but not for all, because expansion happens down in some lower level
3019   checking functions in some cases. */
3020
3021   if (cond_expand_at_top[cb->type])
3022     {
3023     arg = expand_string(cb->arg);
3024     if (arg == NULL)
3025       {
3026       if (expand_string_forcedfail) continue;
3027       *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
3028         cb->arg, expand_string_message);
3029       return search_find_defer? DEFER : ERROR;
3030       }
3031     }
3032   else arg = cb->arg;
3033
3034   /* Show condition, and expanded condition if it's different */
3035
3036   HDEBUG(D_acl)
3037     {
3038     int lhswidth = 0;
3039     debug_printf("check %s%s %n",
3040       (!cond_modifiers[cb->type] && cb->u.negated)? "!":"",
3041       conditions[cb->type], &lhswidth);
3042
3043     if (cb->type == ACLC_SET)
3044       {
3045       debug_printf("acl_%s ", cb->u.varname);
3046       lhswidth += 5 + Ustrlen(cb->u.varname);
3047       }
3048
3049     debug_printf("= %s\n", cb->arg);
3050
3051     if (arg != cb->arg)
3052       debug_printf("%.*s= %s\n", lhswidth,
3053       US"                             ", CS arg);
3054     }
3055
3056   /* Check that this condition makes sense at this time */
3057
3058   if ((cond_forbids[cb->type] & (1 << where)) != 0)
3059     {
3060     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
3061       cond_modifiers[cb->type]? "use" : "test",
3062       conditions[cb->type], acl_wherenames[where]);
3063     return ERROR;
3064     }
3065
3066   /* Run the appropriate test for each condition, or take the appropriate
3067   action for the remaining modifiers. */
3068
3069   switch(cb->type)
3070     {
3071     case ACLC_ADD_HEADER:
3072     setup_header(arg);
3073     break;
3074
3075     /* A nested ACL that returns "discard" makes sense only for an "accept" or
3076     "discard" verb. */
3077
3078     case ACLC_ACL:
3079       rc = acl_check_wargs(where, addr, arg, level+1, user_msgptr, log_msgptr);
3080       if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
3081         {
3082         *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
3083           "\"%s\" command (only allowed with \"accept\" or \"discard\")",
3084           verbs[verb]);
3085         return ERROR;
3086         }
3087     break;
3088
3089     case ACLC_AUTHENTICATED:
3090     rc = (sender_host_authenticated == NULL)? FAIL :
3091       match_isinlist(sender_host_authenticated, &arg, 0, NULL, NULL, MCL_STRING,
3092         TRUE, NULL);
3093     break;
3094
3095     #ifdef EXPERIMENTAL_BRIGHTMAIL
3096     case ACLC_BMI_OPTIN:
3097       {
3098       int old_pool = store_pool;
3099       store_pool = POOL_PERM;
3100       bmi_current_optin = string_copy(arg);
3101       store_pool = old_pool;
3102       }
3103     break;
3104     #endif
3105
3106     case ACLC_CONDITION:
3107     /* The true/false parsing here should be kept in sync with that used in
3108     expand.c when dealing with ECOND_BOOL so that we don't have too many
3109     different definitions of what can be a boolean. */
3110     if (*arg == '-'
3111         ? Ustrspn(arg+1, "0123456789") == Ustrlen(arg+1)    /* Negative number */
3112         : Ustrspn(arg,   "0123456789") == Ustrlen(arg))     /* Digits, or empty */
3113       rc = (Uatoi(arg) == 0)? FAIL : OK;
3114     else
3115       rc = (strcmpic(arg, US"no") == 0 ||
3116             strcmpic(arg, US"false") == 0)? FAIL :
3117            (strcmpic(arg, US"yes") == 0 ||
3118             strcmpic(arg, US"true") == 0)? OK : DEFER;
3119     if (rc == DEFER)
3120       *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
3121     break;
3122
3123     case ACLC_CONTINUE:    /* Always succeeds */
3124     break;
3125
3126     case ACLC_CONTROL:
3127       {
3128       const uschar *p = NULL;
3129       control_type = decode_control(arg, &p, where, log_msgptr);
3130
3131       /* Check if this control makes sense at this time */
3132
3133       if ((control_forbids[control_type] & (1 << where)) != 0)
3134         {
3135         *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
3136           controls[control_type], acl_wherenames[where]);
3137         return ERROR;
3138         }
3139
3140       switch(control_type)
3141         {
3142         case CONTROL_AUTH_UNADVERTISED:
3143         allow_auth_unadvertised = TRUE;
3144         break;
3145
3146         #ifdef EXPERIMENTAL_BRIGHTMAIL
3147         case CONTROL_BMI_RUN:
3148         bmi_run = 1;
3149         break;
3150         #endif
3151
3152         #ifndef DISABLE_DKIM
3153         case CONTROL_DKIM_VERIFY:
3154         dkim_disable_verify = TRUE;
3155         #ifdef EXPERIMENTAL_DMARC
3156         /* Since DKIM was blocked, skip DMARC too */
3157         dmarc_disable_verify = TRUE;
3158         dmarc_enable_forensic = FALSE;
3159         #endif
3160         break;
3161         #endif
3162
3163         #ifdef EXPERIMENTAL_DMARC
3164         case CONTROL_DMARC_VERIFY:
3165         dmarc_disable_verify = TRUE;
3166         break;
3167
3168         case CONTROL_DMARC_FORENSIC:
3169         dmarc_enable_forensic = TRUE;
3170         break;
3171         #endif
3172
3173         case CONTROL_DSCP:
3174         if (*p == '/')
3175           {
3176           int fd, af, level, optname, value;
3177           /* If we are acting on stdin, the setsockopt may fail if stdin is not
3178           a socket; we can accept that, we'll just debug-log failures anyway. */
3179           fd = fileno(smtp_in);
3180           af = ip_get_address_family(fd);
3181           if (af < 0)
3182             {
3183             HDEBUG(D_acl)
3184               debug_printf("smtp input is probably not a socket [%s], not setting DSCP\n",
3185                   strerror(errno));
3186             break;
3187             }
3188           if (dscp_lookup(p+1, af, &level, &optname, &value))
3189             {
3190             if (setsockopt(fd, level, optname, &value, sizeof(value)) < 0)
3191               {
3192               HDEBUG(D_acl) debug_printf("failed to set input DSCP[%s]: %s\n",
3193                   p+1, strerror(errno));
3194               }
3195             else
3196               {
3197               HDEBUG(D_acl) debug_printf("set input DSCP to \"%s\"\n", p+1);
3198               }
3199             }
3200           else
3201             {
3202             *log_msgptr = string_sprintf("unrecognised DSCP value in \"control=%s\"", arg);
3203             return ERROR;
3204             }
3205           }
3206         else
3207           {
3208           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3209           return ERROR;
3210           }
3211         break;
3212
3213         case CONTROL_ERROR:
3214         return ERROR;
3215
3216         case CONTROL_CASEFUL_LOCAL_PART:
3217         deliver_localpart = addr->cc_local_part;
3218         break;
3219
3220         case CONTROL_CASELOWER_LOCAL_PART:
3221         deliver_localpart = addr->lc_local_part;
3222         break;
3223
3224         case CONTROL_ENFORCE_SYNC:
3225         smtp_enforce_sync = TRUE;
3226         break;
3227
3228         case CONTROL_NO_ENFORCE_SYNC:
3229         smtp_enforce_sync = FALSE;
3230         break;
3231
3232         #ifdef WITH_CONTENT_SCAN
3233         case CONTROL_NO_MBOX_UNSPOOL:
3234         no_mbox_unspool = TRUE;
3235         break;
3236         #endif
3237
3238         case CONTROL_NO_MULTILINE:
3239         no_multiline_responses = TRUE;
3240         break;
3241
3242         case CONTROL_NO_PIPELINING:
3243         pipelining_enable = FALSE;
3244         break;
3245
3246         case CONTROL_NO_DELAY_FLUSH:
3247         disable_delay_flush = TRUE;
3248         break;
3249
3250         case CONTROL_NO_CALLOUT_FLUSH:
3251         disable_callout_flush = TRUE;
3252         break;
3253
3254         case CONTROL_FAKEREJECT:
3255         cancel_cutthrough_connection("fakereject");
3256         case CONTROL_FAKEDEFER:
3257         fake_response = (control_type == CONTROL_FAKEDEFER) ? DEFER : FAIL;
3258         if (*p == '/')
3259           {
3260           const uschar *pp = p + 1;
3261           while (*pp != 0) pp++;
3262           fake_response_text = expand_string(string_copyn(p+1, pp-p-1));
3263           p = pp;
3264           }
3265          else
3266           {
3267           /* Explicitly reset to default string */
3268           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).";
3269           }
3270         break;
3271
3272         case CONTROL_FREEZE:
3273         deliver_freeze = TRUE;
3274         deliver_frozen_at = time(NULL);
3275         freeze_tell = freeze_tell_config;       /* Reset to configured value */
3276         if (Ustrncmp(p, "/no_tell", 8) == 0)
3277           {
3278           p += 8;
3279           freeze_tell = NULL;
3280           }
3281         if (*p != 0)
3282           {
3283           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3284           return ERROR;
3285           }
3286         cancel_cutthrough_connection("item frozen");
3287         break;
3288
3289         case CONTROL_QUEUE_ONLY:
3290         queue_only_policy = TRUE;
3291         cancel_cutthrough_connection("queueing forced");
3292         break;
3293
3294         case CONTROL_SUBMISSION:
3295         originator_name = US"";
3296         submission_mode = TRUE;
3297         while (*p == '/')
3298           {
3299           if (Ustrncmp(p, "/sender_retain", 14) == 0)
3300             {
3301             p += 14;
3302             active_local_sender_retain = TRUE;
3303             active_local_from_check = FALSE;
3304             }
3305           else if (Ustrncmp(p, "/domain=", 8) == 0)
3306             {
3307             const uschar *pp = p + 8;
3308             while (*pp != 0 && *pp != '/') pp++;
3309             submission_domain = string_copyn(p+8, pp-p-8);
3310             p = pp;
3311             }
3312           /* The name= option must be last, because it swallows the rest of
3313           the string. */
3314           else if (Ustrncmp(p, "/name=", 6) == 0)
3315             {
3316             const uschar *pp = p + 6;
3317             while (*pp != 0) pp++;
3318             submission_name = string_copy(parse_fix_phrase(p+6, pp-p-6,
3319               big_buffer, big_buffer_size));
3320             p = pp;
3321             }
3322           else break;
3323           }
3324         if (*p != 0)
3325           {
3326           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3327           return ERROR;
3328           }
3329         break;
3330
3331         case CONTROL_DEBUG:
3332         while (*p == '/')
3333           {
3334           if (Ustrncmp(p, "/tag=", 5) == 0)
3335             {
3336             const uschar *pp = p + 5;
3337             while (*pp != '\0' && *pp != '/') pp++;
3338             debug_tag = string_copyn(p+5, pp-p-5);
3339             p = pp;
3340             }
3341           else if (Ustrncmp(p, "/opts=", 6) == 0)
3342             {
3343             const uschar *pp = p + 6;
3344             while (*pp != '\0' && *pp != '/') pp++;
3345             debug_opts = string_copyn(p+6, pp-p-6);
3346             p = pp;
3347             }
3348           }
3349           debug_logging_activate(debug_tag, debug_opts);
3350         break;
3351
3352         case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3353         suppress_local_fixups = TRUE;
3354         break;
3355
3356         case CONTROL_CUTTHROUGH_DELIVERY:
3357 #ifndef DISABLE_PRDR
3358         if (prdr_requested)
3359 #else
3360         if (0)
3361 #endif
3362           /* Too hard to think about for now.  We might in future cutthrough
3363           the case where both sides handle prdr and this-node prdr acl
3364           is "accept" */
3365           *log_msgptr = string_sprintf("PRDR on %s reception\n", arg);
3366         else
3367           {
3368           if (deliver_freeze)
3369             *log_msgptr = US"frozen";
3370           else if (queue_only_policy)
3371             *log_msgptr = US"queue-only";
3372           else if (fake_response == FAIL)
3373             *log_msgptr = US"fakereject";
3374           else
3375             {
3376             if (rcpt_count == 1) cutthrough.delivery = TRUE;
3377             break;
3378             }
3379           *log_msgptr = string_sprintf("\"control=%s\" on %s item",
3380                                         arg, *log_msgptr);
3381           }
3382         return ERROR;
3383
3384 #ifdef SUPPORT_I18N
3385         case CONTROL_UTF8_DOWNCONVERT:
3386         if (*p == '/')
3387           {
3388           if (p[1] == '1')
3389             {
3390             message_utf8_downconvert = 1;
3391             addr->prop.utf8_downcvt = TRUE;
3392             addr->prop.utf8_downcvt_maybe = FALSE;
3393             p += 2;
3394             break;
3395             }
3396           if (p[1] == '0')
3397             {
3398             message_utf8_downconvert = 0;
3399             addr->prop.utf8_downcvt = FALSE;
3400             addr->prop.utf8_downcvt_maybe = FALSE;
3401             p += 2;
3402             break;
3403             }
3404           if (p[1] == '-' && p[2] == '1')
3405             {
3406             message_utf8_downconvert = -1;
3407             addr->prop.utf8_downcvt = FALSE;
3408             addr->prop.utf8_downcvt_maybe = TRUE;
3409             p += 3;
3410             break;
3411             }
3412           *log_msgptr = US"bad option value for control=utf8_downconvert";
3413           }
3414         else
3415           {
3416           message_utf8_downconvert = 1;
3417           addr->prop.utf8_downcvt = TRUE;
3418           addr->prop.utf8_downcvt_maybe = FALSE;
3419           break;
3420           }
3421         return ERROR;
3422 #endif
3423
3424         }
3425       break;
3426       }
3427
3428     #ifdef EXPERIMENTAL_DCC
3429     case ACLC_DCC:
3430       {
3431       /* Seperate the regular expression and any optional parameters. */
3432       const uschar * list = arg;
3433       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3434       /* Run the dcc backend. */
3435       rc = dcc_process(&ss);
3436       /* Modify return code based upon the existance of options. */
3437       while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3438         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3439           rc = FAIL;   /* FAIL so that the message is passed to the next ACL */
3440       }
3441     break;
3442     #endif
3443
3444     #ifdef WITH_CONTENT_SCAN
3445     case ACLC_DECODE:
3446     rc = mime_decode(&arg);
3447     break;
3448     #endif
3449
3450     case ACLC_DELAY:
3451       {
3452       int delay = readconf_readtime(arg, 0, FALSE);
3453       if (delay < 0)
3454         {
3455         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3456           "modifier: \"%s\" is not a time value", arg);
3457         return ERROR;
3458         }
3459       else
3460         {
3461         HDEBUG(D_acl) debug_printf("delay modifier requests %d-second delay\n",
3462           delay);
3463         if (host_checking)
3464           {
3465           HDEBUG(D_acl)
3466             debug_printf("delay skipped in -bh checking mode\n");
3467           }
3468
3469         /* NOTE 1: Remember that we may be
3470         dealing with stdin/stdout here, in addition to TCP/IP connections.
3471         Also, delays may be specified for non-SMTP input, where smtp_out and
3472         smtp_in will be NULL. Whatever is done must work in all cases.
3473
3474         NOTE 2: The added feature of flushing the output before a delay must
3475         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3476         */
3477
3478         else
3479           {
3480           if (smtp_out != NULL && !disable_delay_flush)
3481             mac_smtp_fflush();
3482
3483 #if !defined(NO_POLL_H) && defined (POLLRDHUP)
3484             {
3485             struct pollfd p;
3486             nfds_t n = 0;
3487             if (smtp_out)
3488               {
3489               p.fd = fileno(smtp_out);
3490               p.events = POLLRDHUP;
3491               n = 1;
3492               }
3493             if (poll(&p, n, delay*1000) > 0)
3494               HDEBUG(D_acl) debug_printf("delay cancelled by peer close\n");
3495             }
3496 #else
3497         /* It appears to be impossible to detect that a TCP/IP connection has
3498         gone away without reading from it. This means that we cannot shorten
3499         the delay below if the client goes away, because we cannot discover
3500         that the client has closed its end of the connection. (The connection
3501         is actually in a half-closed state, waiting for the server to close its
3502         end.) It would be nice to be able to detect this state, so that the
3503         Exim process is not held up unnecessarily. However, it seems that we
3504         can't. The poll() function does not do the right thing, and in any case
3505         it is not always available.
3506         */
3507
3508           while (delay > 0) delay = sleep(delay);
3509 #endif
3510           }
3511         }
3512       }
3513     break;
3514
3515     #ifndef DISABLE_DKIM
3516     case ACLC_DKIM_SIGNER:
3517     if (dkim_cur_signer != NULL)
3518       rc = match_isinlist(dkim_cur_signer,
3519                           &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3520     else
3521        rc = FAIL;
3522     break;
3523
3524     case ACLC_DKIM_STATUS:
3525     rc = match_isinlist(dkim_exim_expand_query(DKIM_VERIFY_STATUS),
3526                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3527     break;
3528     #endif
3529
3530     #ifdef EXPERIMENTAL_DMARC
3531     case ACLC_DMARC_STATUS:
3532     if (!dmarc_has_been_checked)
3533       dmarc_process();
3534     dmarc_has_been_checked = TRUE;
3535     /* used long way of dmarc_exim_expand_query() in case we need more
3536      * view into the process in the future. */
3537     rc = match_isinlist(dmarc_exim_expand_query(DMARC_VERIFY_STATUS),
3538                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3539     break;
3540     #endif
3541
3542     case ACLC_DNSLISTS:
3543     rc = verify_check_dnsbl(where, &arg, log_msgptr);
3544     break;
3545
3546     case ACLC_DOMAINS:
3547     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3548       addr->domain_cache, MCL_DOMAIN, TRUE, CUSS &deliver_domain_data);
3549     break;
3550
3551     /* The value in tls_cipher is the full cipher name, for example,
3552     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3553     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3554     what may in practice come out of the SSL library - which at the time of
3555     writing is poorly documented. */
3556
3557     case ACLC_ENCRYPTED:
3558     if (tls_in.cipher == NULL) rc = FAIL; else
3559       {
3560       uschar *endcipher = NULL;
3561       uschar *cipher = Ustrchr(tls_in.cipher, ':');
3562       if (cipher == NULL) cipher = tls_in.cipher; else
3563         {
3564         endcipher = Ustrchr(++cipher, ':');
3565         if (endcipher != NULL) *endcipher = 0;
3566         }
3567       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3568       if (endcipher != NULL) *endcipher = ':';
3569       }
3570     break;
3571
3572     /* Use verify_check_this_host() instead of verify_check_host() so that
3573     we can pass over &host_data to catch any looked up data. Once it has been
3574     set, it retains its value so that it's still there if another ACL verb
3575     comes through here and uses the cache. However, we must put it into
3576     permanent store in case it is also expected to be used in a subsequent
3577     message in the same SMTP connection. */
3578
3579     case ACLC_HOSTS:
3580     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3581       (sender_host_address == NULL)? US"" : sender_host_address,
3582       CUSS &host_data);
3583     if (rc == DEFER) *log_msgptr = search_error_message;
3584     if (host_data) host_data = string_copy_malloc(host_data);
3585     break;
3586
3587     case ACLC_LOCAL_PARTS:
3588     rc = match_isinlist(addr->cc_local_part, &arg, 0,
3589       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3590       CUSS &deliver_localpart_data);
3591     break;
3592
3593     case ACLC_LOG_REJECT_TARGET:
3594       {
3595       int logbits = 0;
3596       int sep = 0;
3597       const uschar *s = arg;
3598       uschar *ss;
3599       while ((ss = string_nextinlist(&s, &sep, big_buffer, big_buffer_size)))
3600         {
3601         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3602         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3603         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3604         else
3605           {
3606           logbits |= LOG_MAIN|LOG_REJECT;
3607           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3608             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3609           }
3610         }
3611       log_reject_target = logbits;
3612       }
3613     break;
3614
3615     case ACLC_LOGWRITE:
3616       {
3617       int logbits = 0;
3618       const uschar *s = arg;
3619       if (*s == ':')
3620         {
3621         s++;
3622         while (*s != ':')
3623           {
3624           if (Ustrncmp(s, "main", 4) == 0)
3625             { logbits |= LOG_MAIN; s += 4; }
3626           else if (Ustrncmp(s, "panic", 5) == 0)
3627             { logbits |= LOG_PANIC; s += 5; }
3628           else if (Ustrncmp(s, "reject", 6) == 0)
3629             { logbits |= LOG_REJECT; s += 6; }
3630           else
3631             {
3632             logbits = LOG_MAIN|LOG_PANIC;
3633             s = string_sprintf(":unknown log name in \"%s\" in "
3634               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3635             }
3636           if (*s == ',') s++;
3637           }
3638         s++;
3639         }
3640       while (isspace(*s)) s++;
3641
3642
3643       if (logbits == 0) logbits = LOG_MAIN;
3644       log_write(0, logbits, "%s", string_printing(s));
3645       }
3646     break;
3647
3648     #ifdef WITH_CONTENT_SCAN
3649     case ACLC_MALWARE:                  /* Run the malware backend. */
3650       {
3651       /* Separate the regular expression and any optional parameters. */
3652       const uschar * list = arg;
3653       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3654       uschar *opt;
3655       BOOL defer_ok = FALSE;
3656       int timeout = 0;
3657
3658       while ((opt = string_nextinlist(&list, &sep, NULL, 0)))
3659         if (strcmpic(opt, US"defer_ok") == 0)
3660           defer_ok = TRUE;
3661         else if (  strncmpic(opt, US"tmo=", 4) == 0
3662                 && (timeout = readconf_readtime(opt+4, '\0', FALSE)) < 0
3663                 )
3664           {
3665           *log_msgptr = string_sprintf("bad timeout value in '%s'", opt);
3666           return ERROR;
3667           }
3668
3669       rc = malware(ss, timeout);
3670       if (rc == DEFER && defer_ok)
3671         rc = FAIL;      /* FAIL so that the message is passed to the next ACL */
3672       }
3673     break;
3674
3675     case ACLC_MIME_REGEX:
3676     rc = mime_regex(&arg);
3677     break;
3678     #endif
3679
3680     case ACLC_RATELIMIT:
3681     rc = acl_ratelimit(arg, where, log_msgptr);
3682     break;
3683
3684     case ACLC_RECIPIENTS:
3685     rc = match_address_list((const uschar *)addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3686       CUSS &recipient_data);
3687     break;
3688
3689     #ifdef WITH_CONTENT_SCAN
3690     case ACLC_REGEX:
3691     rc = regex(&arg);
3692     break;
3693     #endif
3694
3695     case ACLC_REMOVE_HEADER:
3696     setup_remove_header(arg);
3697     break;
3698
3699     case ACLC_SENDER_DOMAINS:
3700       {
3701       uschar *sdomain;
3702       sdomain = Ustrrchr(sender_address, '@');
3703       sdomain = (sdomain == NULL)? US"" : sdomain + 1;
3704       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3705         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3706       }
3707     break;
3708
3709     case ACLC_SENDERS:
3710     rc = match_address_list((const uschar *)sender_address, TRUE, TRUE, &arg,
3711       sender_address_cache, -1, 0, CUSS &sender_data);
3712     break;
3713
3714     /* Connection variables must persist forever */
3715
3716     case ACLC_SET:
3717       {
3718       int old_pool = store_pool;
3719       if (  cb->u.varname[0] == 'c'
3720 #ifndef DISABLE_EVENT
3721          || event_name          /* An event is being delivered */
3722 #endif
3723          )
3724         store_pool = POOL_PERM;
3725       acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
3726       store_pool = old_pool;
3727       }
3728     break;
3729
3730     #ifdef WITH_CONTENT_SCAN
3731     case ACLC_SPAM:
3732       {
3733       /* Seperate the regular expression and any optional parameters. */
3734       const uschar * list = arg;
3735       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3736       /* Run the spam backend. */
3737       rc = spam(CUSS &ss);
3738       /* Modify return code based upon the existance of options. */
3739       while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
3740             != NULL) {
3741         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3742           {
3743           /* FAIL so that the message is passed to the next ACL */
3744           rc = FAIL;
3745           }
3746         }
3747       }
3748     break;
3749     #endif
3750
3751     #ifdef EXPERIMENTAL_SPF
3752     case ACLC_SPF:
3753       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
3754     break;
3755     case ACLC_SPF_GUESS:
3756       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
3757     break;
3758     #endif
3759
3760     case ACLC_UDPSEND:
3761     rc = acl_udpsend(arg, log_msgptr);
3762     break;
3763
3764     /* If the verb is WARN, discard any user message from verification, because
3765     such messages are SMTP responses, not header additions. The latter come
3766     only from explicit "message" modifiers. However, put the user message into
3767     $acl_verify_message so it can be used in subsequent conditions or modifiers
3768     (until something changes it). */
3769
3770     case ACLC_VERIFY:
3771     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
3772     if (*user_msgptr)
3773       acl_verify_message = *user_msgptr;
3774     if (verb == ACL_WARN) *user_msgptr = NULL;
3775     break;
3776
3777     default:
3778     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
3779       "condition %d", cb->type);
3780     break;
3781     }
3782
3783   /* If a condition was negated, invert OK/FAIL. */
3784
3785   if (!cond_modifiers[cb->type] && cb->u.negated)
3786     {
3787     if (rc == OK) rc = FAIL;
3788       else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
3789     }
3790
3791   if (rc != OK) break;   /* Conditions loop */
3792   }
3793
3794
3795 /* If the result is the one for which "message" and/or "log_message" are used,
3796 handle the values of these modifiers. If there isn't a log message set, we make
3797 it the same as the user message.
3798
3799 "message" is a user message that will be included in an SMTP response. Unless
3800 it is empty, it overrides any previously set user message.
3801
3802 "log_message" is a non-user message, and it adds to any existing non-user
3803 message that is already set.
3804
3805 Most verbs have but a single return for which the messages are relevant, but
3806 for "discard", it's useful to have the log message both when it succeeds and
3807 when it fails. For "accept", the message is used in the OK case if there is no
3808 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
3809 present. */
3810
3811 if (*epp && rc == OK) user_message = NULL;
3812
3813 if (((1<<rc) & msgcond[verb]) != 0)
3814   {
3815   uschar *expmessage;
3816   uschar *old_user_msgptr = *user_msgptr;
3817   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
3818
3819   /* If the verb is "warn", messages generated by conditions (verification or
3820   nested ACLs) are always discarded. This also happens for acceptance verbs
3821   when they actually do accept. Only messages specified at this level are used.
3822   However, the value of an existing message is available in $acl_verify_message
3823   during expansions. */
3824
3825   if (verb == ACL_WARN ||
3826       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
3827     *log_msgptr = *user_msgptr = NULL;
3828
3829   if (user_message != NULL)
3830     {
3831     acl_verify_message = old_user_msgptr;
3832     expmessage = expand_string(user_message);
3833     if (expmessage == NULL)
3834       {
3835       if (!expand_string_forcedfail)
3836         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3837           user_message, expand_string_message);
3838       }
3839     else if (expmessage[0] != 0) *user_msgptr = expmessage;
3840     }
3841
3842   if (log_message != NULL)
3843     {
3844     acl_verify_message = old_log_msgptr;
3845     expmessage = expand_string(log_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           log_message, expand_string_message);
3851       }
3852     else if (expmessage[0] != 0)
3853       {
3854       *log_msgptr = (*log_msgptr == NULL)? expmessage :
3855         string_sprintf("%s: %s", expmessage, *log_msgptr);
3856       }
3857     }
3858
3859   /* If no log message, default it to the user message */
3860
3861   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
3862   }
3863
3864 acl_verify_message = NULL;
3865 return rc;
3866 }
3867
3868
3869
3870
3871
3872 /*************************************************
3873 *        Get line from a literal ACL             *
3874 *************************************************/
3875
3876 /* This function is passed to acl_read() in order to extract individual lines
3877 of a literal ACL, which we access via static pointers. We can destroy the
3878 contents because this is called only once (the compiled ACL is remembered).
3879
3880 This code is intended to treat the data in the same way as lines in the main
3881 Exim configuration file. That is:
3882
3883   . Leading spaces are ignored.
3884
3885   . A \ at the end of a line is a continuation - trailing spaces after the \
3886     are permitted (this is because I don't believe in making invisible things
3887     significant). Leading spaces on the continued part of a line are ignored.
3888
3889   . Physical lines starting (significantly) with # are totally ignored, and
3890     may appear within a sequence of backslash-continued lines.
3891
3892   . Blank lines are ignored, but will end a sequence of continuations.
3893
3894 Arguments: none
3895 Returns:   a pointer to the next line
3896 */
3897
3898
3899 static uschar *acl_text;          /* Current pointer in the text */
3900 static uschar *acl_text_end;      /* Points one past the terminating '0' */
3901
3902
3903 static uschar *
3904 acl_getline(void)
3905 {
3906 uschar *yield;
3907
3908 /* This loop handles leading blank lines and comments. */
3909
3910 for(;;)
3911   {
3912   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
3913   if (*acl_text == 0) return NULL;         /* No more data */
3914   yield = acl_text;                        /* Potential data line */
3915
3916   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3917
3918   /* If we hit the end before a newline, we have the whole logical line. If
3919   it's a comment, there's no more data to be given. Otherwise, yield it. */
3920
3921   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
3922
3923   /* After reaching a newline, end this loop if the physical line does not
3924   start with '#'. If it does, it's a comment, and the loop continues. */
3925
3926   if (*yield != '#') break;
3927   }
3928
3929 /* This loop handles continuations. We know we have some real data, ending in
3930 newline. See if there is a continuation marker at the end (ignoring trailing
3931 white space). We know that *yield is not white space, so no need to test for
3932 cont > yield in the backwards scanning loop. */
3933
3934 for(;;)
3935   {
3936   uschar *cont;
3937   for (cont = acl_text - 1; isspace(*cont); cont--);
3938
3939   /* If no continuation follows, we are done. Mark the end of the line and
3940   return it. */
3941
3942   if (*cont != '\\')
3943     {
3944     *acl_text++ = 0;
3945     return yield;
3946     }
3947
3948   /* We have encountered a continuation. Skip over whitespace at the start of
3949   the next line, and indeed the whole of the next line or lines if they are
3950   comment lines. */
3951
3952   for (;;)
3953     {
3954     while (*(++acl_text) == ' ' || *acl_text == '\t');
3955     if (*acl_text != '#') break;
3956     while (*(++acl_text) != 0 && *acl_text != '\n');
3957     }
3958
3959   /* We have the start of a continuation line. Move all the rest of the data
3960   to join onto the previous line, and then find its end. If the end is not a
3961   newline, we are done. Otherwise loop to look for another continuation. */
3962
3963   memmove(cont, acl_text, acl_text_end - acl_text);
3964   acl_text_end -= acl_text - cont;
3965   acl_text = cont;
3966   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3967   if (*acl_text == 0) return yield;
3968   }
3969
3970 /* Control does not reach here */
3971 }
3972
3973
3974
3975
3976
3977 /*************************************************
3978 *        Check access using an ACL               *
3979 *************************************************/
3980
3981 /* This function is called from address_check. It may recurse via
3982 acl_check_condition() - hence the use of a level to stop looping. The ACL is
3983 passed as a string which is expanded. A forced failure implies no access check
3984 is required. If the result is a single word, it is taken as the name of an ACL
3985 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
3986 text, complete with newlines, and parsed as such. In both cases, the ACL check
3987 is then run. This function uses an auxiliary function for acl_read() to call
3988 for reading individual lines of a literal ACL. This is acl_getline(), which
3989 appears immediately above.
3990
3991 Arguments:
3992   where        where called from
3993   addr         address item when called from RCPT; otherwise NULL
3994   s            the input string; NULL is the same as an empty ACL => DENY
3995   level        the nesting level
3996   user_msgptr  where to put a user error (for SMTP response)
3997   log_msgptr   where to put a logging message (not for SMTP response)
3998
3999 Returns:       OK         access is granted
4000                DISCARD    access is apparently granted...
4001                FAIL       access is denied
4002                FAIL_DROP  access is denied; drop the connection
4003                DEFER      can't tell at the moment
4004                ERROR      disaster
4005 */
4006
4007 static int
4008 acl_check_internal(int where, address_item *addr, uschar *s, int level,
4009   uschar **user_msgptr, uschar **log_msgptr)
4010 {
4011 int fd = -1;
4012 acl_block *acl = NULL;
4013 uschar *acl_name = US"inline ACL";
4014 uschar *ss;
4015
4016 /* Catch configuration loops */
4017
4018 if (level > 20)
4019   {
4020   *log_msgptr = US"ACL nested too deep: possible loop";
4021   return ERROR;
4022   }
4023
4024 if (s == NULL)
4025   {
4026   HDEBUG(D_acl) debug_printf("ACL is NULL: implicit DENY\n");
4027   return FAIL;
4028   }
4029
4030 /* At top level, we expand the incoming string. At lower levels, it has already
4031 been expanded as part of condition processing. */
4032
4033 if (level == 0)
4034   {
4035   ss = expand_string(s);
4036   if (ss == NULL)
4037     {
4038     if (expand_string_forcedfail) return OK;
4039     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
4040       expand_string_message);
4041     return ERROR;
4042     }
4043   }
4044 else ss = s;
4045
4046 while (isspace(*ss))ss++;
4047
4048 /* If we can't find a named ACL, the default is to parse it as an inline one.
4049 (Unless it begins with a slash; non-existent files give rise to an error.) */
4050
4051 acl_text = ss;
4052
4053 /* Handle the case of a string that does not contain any spaces. Look for a
4054 named ACL among those read from the configuration, or a previously read file.
4055 It is possible that the pointer to the ACL is NULL if the configuration
4056 contains a name with no data. If not found, and the text begins with '/',
4057 read an ACL from a file, and save it so it can be re-used. */
4058
4059 if (Ustrchr(ss, ' ') == NULL)
4060   {
4061   tree_node *t = tree_search(acl_anchor, ss);
4062   if (t != NULL)
4063     {
4064     acl = (acl_block *)(t->data.ptr);
4065     if (acl == NULL)
4066       {
4067       HDEBUG(D_acl) debug_printf("ACL \"%s\" is empty: implicit DENY\n", ss);
4068       return FAIL;
4069       }
4070     acl_name = string_sprintf("ACL \"%s\"", ss);
4071     HDEBUG(D_acl) debug_printf("using ACL \"%s\"\n", ss);
4072     }
4073
4074   else if (*ss == '/')
4075     {
4076     struct stat statbuf;
4077     fd = Uopen(ss, O_RDONLY, 0);
4078     if (fd < 0)
4079       {
4080       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
4081         strerror(errno));
4082       return ERROR;
4083       }
4084
4085     if (fstat(fd, &statbuf) != 0)
4086       {
4087       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
4088         strerror(errno));
4089       return ERROR;
4090       }
4091
4092     acl_text = store_get(statbuf.st_size + 1);
4093     acl_text_end = acl_text + statbuf.st_size + 1;
4094
4095     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
4096       {
4097       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
4098         ss, strerror(errno));
4099       return ERROR;
4100       }
4101     acl_text[statbuf.st_size] = 0;
4102     (void)close(fd);
4103
4104     acl_name = string_sprintf("ACL \"%s\"", ss);
4105     HDEBUG(D_acl) debug_printf("read ACL from file %s\n", ss);
4106     }
4107   }
4108
4109 /* Parse an ACL that is still in text form. If it came from a file, remember it
4110 in the ACL tree, having read it into the POOL_PERM store pool so that it
4111 persists between multiple messages. */
4112
4113 if (acl == NULL)
4114   {
4115   int old_pool = store_pool;
4116   if (fd >= 0) store_pool = POOL_PERM;
4117   acl = acl_read(acl_getline, log_msgptr);
4118   store_pool = old_pool;
4119   if (acl == NULL && *log_msgptr != NULL) return ERROR;
4120   if (fd >= 0)
4121     {
4122     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
4123     Ustrcpy(t->name, ss);
4124     t->data.ptr = acl;
4125     (void)tree_insertnode(&acl_anchor, t);
4126     }
4127   }
4128
4129 /* Now we have an ACL to use. It's possible it may be NULL. */
4130
4131 while (acl != NULL)
4132   {
4133   int cond;
4134   int basic_errno = 0;
4135   BOOL endpass_seen = FALSE;
4136   BOOL acl_quit_check = level == 0
4137     && (where == ACL_WHERE_QUIT || where == ACL_WHERE_NOTQUIT);
4138
4139   *log_msgptr = *user_msgptr = NULL;
4140   acl_temp_details = FALSE;
4141
4142   HDEBUG(D_acl) debug_printf("processing \"%s\"\n", verbs[acl->verb]);
4143
4144   /* Clear out any search error message from a previous check before testing
4145   this condition. */
4146
4147   search_error_message = NULL;
4148   cond = acl_check_condition(acl->verb, acl->condition, where, addr, level,
4149     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
4150
4151   /* Handle special returns: DEFER causes a return except on a WARN verb;
4152   ERROR always causes a return. */
4153
4154   switch (cond)
4155     {
4156     case DEFER:
4157     HDEBUG(D_acl) debug_printf("%s: condition test deferred in %s\n", verbs[acl->verb], acl_name);
4158     if (basic_errno != ERRNO_CALLOUTDEFER)
4159       {
4160       if (search_error_message != NULL && *search_error_message != 0)
4161         *log_msgptr = search_error_message;
4162       if (smtp_return_error_details) acl_temp_details = TRUE;
4163       }
4164     else
4165       {
4166       acl_temp_details = TRUE;
4167       }
4168     if (acl->verb != ACL_WARN) return DEFER;
4169     break;
4170
4171     default:      /* Paranoia */
4172     case ERROR:
4173     HDEBUG(D_acl) debug_printf("%s: condition test error in %s\n", verbs[acl->verb], acl_name);
4174     return ERROR;
4175
4176     case OK:
4177     HDEBUG(D_acl) debug_printf("%s: condition test succeeded in %s\n",
4178       verbs[acl->verb], acl_name);
4179     break;
4180
4181     case FAIL:
4182     HDEBUG(D_acl) debug_printf("%s: condition test failed in %s\n", verbs[acl->verb], acl_name);
4183     break;
4184
4185     /* DISCARD and DROP can happen only from a nested ACL condition, and
4186     DISCARD can happen only for an "accept" or "discard" verb. */
4187
4188     case DISCARD:
4189     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"discard\" in %s\n",
4190       verbs[acl->verb], acl_name);
4191     break;
4192
4193     case FAIL_DROP:
4194     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"drop\" in %s\n",
4195       verbs[acl->verb], acl_name);
4196     break;
4197     }
4198
4199   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
4200   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
4201   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
4202
4203   switch(acl->verb)
4204     {
4205     case ACL_ACCEPT:
4206     if (cond == OK || cond == DISCARD)
4207       {
4208       HDEBUG(D_acl) debug_printf("end of %s: ACCEPT\n", acl_name);
4209       return cond;
4210       }
4211     if (endpass_seen)
4212       {
4213       HDEBUG(D_acl) debug_printf("accept: endpass encountered - denying access\n");
4214       return cond;
4215       }
4216     break;
4217
4218     case ACL_DEFER:
4219     if (cond == OK)
4220       {
4221       HDEBUG(D_acl) debug_printf("end of %s: DEFER\n", acl_name);
4222       if (acl_quit_check) goto badquit;
4223       acl_temp_details = TRUE;
4224       return DEFER;
4225       }
4226     break;
4227
4228     case ACL_DENY:
4229     if (cond == OK)
4230       {
4231       HDEBUG(D_acl) debug_printf("end of %s: DENY\n", acl_name);
4232       if (acl_quit_check) goto badquit;
4233       return FAIL;
4234       }
4235     break;
4236
4237     case ACL_DISCARD:
4238     if (cond == OK || cond == DISCARD)
4239       {
4240       HDEBUG(D_acl) debug_printf("end of %s: DISCARD\n", acl_name);
4241       if (acl_quit_check) goto badquit;
4242       return DISCARD;
4243       }
4244     if (endpass_seen)
4245       {
4246       HDEBUG(D_acl) debug_printf("discard: endpass encountered - denying access\n");
4247       return cond;
4248       }
4249     break;
4250
4251     case ACL_DROP:
4252     if (cond == OK)
4253       {
4254       HDEBUG(D_acl) debug_printf("end of %s: DROP\n", acl_name);
4255       if (acl_quit_check) goto badquit;
4256       return FAIL_DROP;
4257       }
4258     break;
4259
4260     case ACL_REQUIRE:
4261     if (cond != OK)
4262       {
4263       HDEBUG(D_acl) debug_printf("end of %s: not OK\n", acl_name);
4264       if (acl_quit_check) goto badquit;
4265       return cond;
4266       }
4267     break;
4268
4269     case ACL_WARN:
4270     if (cond == OK)
4271       acl_warn(where, *user_msgptr, *log_msgptr);
4272     else if (cond == DEFER && LOGGING(acl_warn_skipped))
4273       log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
4274         "condition test deferred%s%s", host_and_ident(TRUE),
4275         (*log_msgptr == NULL)? US"" : US": ",
4276         (*log_msgptr == NULL)? US"" : *log_msgptr);
4277     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
4278     break;
4279
4280     default:
4281     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
4282       acl->verb);
4283     break;
4284     }
4285
4286   /* Pass to the next ACL item */
4287
4288   acl = acl->next;
4289   }
4290
4291 /* We have reached the end of the ACL. This is an implicit DENY. */
4292
4293 HDEBUG(D_acl) debug_printf("end of %s: implicit DENY\n", acl_name);
4294 return FAIL;
4295
4296 badquit:
4297   *log_msgptr = string_sprintf("QUIT or not-QUIT teplevel ACL may not fail "
4298     "('%s' verb used incorrectly)", verbs[acl->verb]);
4299   return ERROR;
4300 }
4301
4302
4303
4304
4305 /* Same args as acl_check_internal() above, but the string s is
4306 the name of an ACL followed optionally by up to 9 space-separated arguments.
4307 The name and args are separately expanded.  Args go into $acl_arg globals. */
4308 static int
4309 acl_check_wargs(int where, address_item *addr, const uschar *s, int level,
4310   uschar **user_msgptr, uschar **log_msgptr)
4311 {
4312 uschar * tmp;
4313 uschar * tmp_arg[9];    /* must match acl_arg[] */
4314 uschar * sav_arg[9];    /* must match acl_arg[] */
4315 int sav_narg;
4316 uschar * name;
4317 int i;
4318 int ret;
4319
4320 if (!(tmp = string_dequote(&s)) || !(name = expand_string(tmp)))
4321   goto bad;
4322
4323 for (i = 0; i < 9; i++)
4324   {
4325   while (*s && isspace(*s)) s++;
4326   if (!*s) break;
4327   if (!(tmp = string_dequote(&s)) || !(tmp_arg[i] = expand_string(tmp)))
4328     {
4329     tmp = name;
4330     goto bad;
4331     }
4332   }
4333
4334 sav_narg = acl_narg;
4335 acl_narg = i;
4336 for (i = 0; i < acl_narg; i++)
4337   {
4338   sav_arg[i] = acl_arg[i];
4339   acl_arg[i] = tmp_arg[i];
4340   }
4341 while (i < 9)
4342   {
4343   sav_arg[i] = acl_arg[i];
4344   acl_arg[i++] = NULL;
4345   }
4346
4347 ret = acl_check_internal(where, addr, name, level, user_msgptr, log_msgptr);
4348
4349 acl_narg = sav_narg;
4350 for (i = 0; i < 9; i++) acl_arg[i] = sav_arg[i];
4351 return ret;
4352
4353 bad:
4354 if (expand_string_forcedfail) return ERROR;
4355 *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
4356   tmp, expand_string_message);
4357 return search_find_defer?DEFER:ERROR;
4358 }
4359
4360
4361
4362 /*************************************************
4363 *        Check access using an ACL               *
4364 *************************************************/
4365
4366 /* Alternate interface for ACL, used by expansions */
4367 int
4368 acl_eval(int where, uschar *s, uschar **user_msgptr, uschar **log_msgptr)
4369 {
4370 address_item adb;
4371 address_item *addr = NULL;
4372
4373 *user_msgptr = *log_msgptr = NULL;
4374 sender_verified_failed = NULL;
4375 ratelimiters_cmd = NULL;
4376 log_reject_target = LOG_MAIN|LOG_REJECT;
4377
4378 if (where == ACL_WHERE_RCPT)
4379   {
4380   adb = address_defaults;
4381   addr = &adb;
4382   addr->address = expand_string(US"$local_part@$domain");
4383   addr->domain = deliver_domain;
4384   addr->local_part = deliver_localpart;
4385   addr->cc_local_part = deliver_localpart;
4386   addr->lc_local_part = deliver_localpart;
4387   }
4388
4389 return acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
4390 }
4391
4392
4393
4394 /* This is the external interface for ACL checks. It sets up an address and the
4395 expansions for $domain and $local_part when called after RCPT, then calls
4396 acl_check_internal() to do the actual work.
4397
4398 Arguments:
4399   where        ACL_WHERE_xxxx indicating where called from
4400   recipient    RCPT address for RCPT check, else NULL
4401   s            the input string; NULL is the same as an empty ACL => DENY
4402   user_msgptr  where to put a user error (for SMTP response)
4403   log_msgptr   where to put a logging message (not for SMTP response)
4404
4405 Returns:       OK         access is granted by an ACCEPT verb
4406                DISCARD    access is granted by a DISCARD verb
4407                FAIL       access is denied
4408                FAIL_DROP  access is denied; drop the connection
4409                DEFER      can't tell at the moment
4410                ERROR      disaster
4411 */
4412 int acl_where = ACL_WHERE_UNKNOWN;
4413
4414 int
4415 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
4416   uschar **log_msgptr)
4417 {
4418 int rc;
4419 address_item adb;
4420 address_item *addr = NULL;
4421
4422 *user_msgptr = *log_msgptr = NULL;
4423 sender_verified_failed = NULL;
4424 ratelimiters_cmd = NULL;
4425 log_reject_target = LOG_MAIN|LOG_REJECT;
4426
4427 #ifndef DISABLE_PRDR
4428 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY || where==ACL_WHERE_PRDR)
4429 #else
4430 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY)
4431 #endif
4432   {
4433   adb = address_defaults;
4434   addr = &adb;
4435   addr->address = recipient;
4436   if (deliver_split_address(addr) == DEFER)
4437     {
4438     *log_msgptr = US"defer in percent_hack_domains check";
4439     return DEFER;
4440     }
4441 #ifdef SUPPORT_I18N
4442   if ((addr->prop.utf8_msg = message_smtputf8))
4443     {
4444     addr->prop.utf8_downcvt =       message_utf8_downconvert == 1;
4445     addr->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
4446     }
4447 #endif
4448   deliver_domain = addr->domain;
4449   deliver_localpart = addr->local_part;
4450   }
4451
4452 acl_where = where;
4453 rc = acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
4454 acl_where = ACL_WHERE_UNKNOWN;
4455
4456 /* Cutthrough - if requested,
4457 and WHERE_RCPT and not yet opened conn as result of recipient-verify,
4458 and rcpt acl returned accept,
4459 and first recipient (cancel on any subsequents)
4460 open one now and run it up to RCPT acceptance.
4461 A failed verify should cancel cutthrough request,
4462 and will pass the fail to the originator.
4463 Initial implementation:  dual-write to spool.
4464 Assume the rxd datastream is now being copied byte-for-byte to an open cutthrough connection.
4465
4466 Cease cutthrough copy on rxd final dot; do not send one.
4467
4468 On a data acl, if not accept and a cutthrough conn is open, hard-close it (no SMTP niceness).
4469
4470 On data acl accept, terminate the dataphase on an open cutthrough conn.  If accepted or
4471 perm-rejected, reflect that to the original sender - and dump the spooled copy.
4472 If temp-reject, close the conn (and keep the spooled copy).
4473 If conn-failure, no action (and keep the spooled copy).
4474 */
4475 switch (where)
4476 {
4477 case ACL_WHERE_RCPT:
4478 #ifndef DISABLE_PRDR
4479 case ACL_WHERE_PRDR:
4480 #endif
4481   if (host_checking_callout)    /* -bhc mode */
4482     cancel_cutthrough_connection("host-checking mode");
4483   else if (rc == OK && cutthrough.delivery && rcpt_count > cutthrough.nrcpt)
4484     rc = open_cutthrough_connection(addr);
4485   break;
4486
4487 case ACL_WHERE_PREDATA:
4488   if (rc == OK)
4489     cutthrough_predata();
4490   else
4491     cancel_cutthrough_connection("predata acl not ok");
4492   break;
4493
4494 case ACL_WHERE_QUIT:
4495 case ACL_WHERE_NOTQUIT:
4496   cancel_cutthrough_connection("quit or notquit");
4497   break;
4498
4499 default:
4500   break;
4501 }
4502
4503 deliver_domain = deliver_localpart = deliver_address_data =
4504   sender_address_data = NULL;
4505
4506 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
4507 ACL, which is really in the middle of an SMTP command. */
4508
4509 if (rc == DISCARD)
4510   {
4511   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
4512     {
4513     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
4514       "ACL", acl_wherenames[where]);
4515     return ERROR;
4516     }
4517   return DISCARD;
4518   }
4519
4520 /* A DROP response is not permitted from MAILAUTH */
4521
4522 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
4523   {
4524   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
4525     "ACL", acl_wherenames[where]);
4526   return ERROR;
4527   }
4528
4529 /* Before giving a response, take a look at the length of any user message, and
4530 split it up into multiple lines if possible. */
4531
4532 *user_msgptr = string_split_message(*user_msgptr);
4533 if (fake_response != OK)
4534   fake_response_text = string_split_message(fake_response_text);
4535
4536 return rc;
4537 }
4538
4539
4540 /*************************************************
4541 *             Create ACL variable                *
4542 *************************************************/
4543
4544 /* Create an ACL variable or reuse an existing one. ACL variables are in a
4545 binary tree (see tree.c) with acl_var_c and acl_var_m as root nodes.
4546
4547 Argument:
4548   name    pointer to the variable's name, starting with c or m
4549
4550 Returns   the pointer to variable's tree node
4551 */
4552
4553 tree_node *
4554 acl_var_create(uschar *name)
4555 {
4556 tree_node *node, **root;
4557 root = (name[0] == 'c')? &acl_var_c : &acl_var_m;
4558 node = tree_search(*root, name);
4559 if (node == NULL)
4560   {
4561   node = store_get(sizeof(tree_node) + Ustrlen(name));
4562   Ustrcpy(node->name, name);
4563   (void)tree_insertnode(root, node);
4564   }
4565 node->data.ptr = NULL;
4566 return node;
4567 }
4568
4569
4570
4571 /*************************************************
4572 *       Write an ACL variable in spool format    *
4573 *************************************************/
4574
4575 /* This function is used as a callback for tree_walk when writing variables to
4576 the spool file. To retain spool file compatibility, what is written is -aclc or
4577 -aclm followed by the rest of the name and the data length, space separated,
4578 then the value itself, starting on a new line, and terminated by an additional
4579 newline. When we had only numbered ACL variables, the first line might look
4580 like this: "-aclc 5 20". Now it might be "-aclc foo 20" for the variable called
4581 acl_cfoo.
4582
4583 Arguments:
4584   name    of the variable
4585   value   of the variable
4586   ctx     FILE pointer (as a void pointer)
4587
4588 Returns:  nothing
4589 */
4590
4591 void
4592 acl_var_write(uschar *name, uschar *value, void *ctx)
4593 {
4594 FILE *f = (FILE *)ctx;
4595 fprintf(f, "-acl%c %s %d\n%s\n", name[0], name+1, Ustrlen(value), value);
4596 }
4597
4598 /* vi: aw ai sw=2
4599 */
4600 /* End of acl.c */