src/src/acl.c

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