src/src/acl.c

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