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