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 *        List the added header lines             *
1055 *************************************************/
1056 uschar *
1057 fn_hdrs_added(void)
1058 {
1059 uschar * ret = NULL;
1060 header_line * h = acl_added_headers;
1061 uschar * s;
1062 uschar * cp;
1063 int size = 0;
1064 int ptr = 0;
1065
1066 if (!h) return NULL;
1067
1068 do
1069   {
1070   s = h->text;
1071   while ((cp = Ustrchr(s, '\n')) != NULL)
1072     {
1073     if (cp[1] == '\0') break;
1074
1075     /* contains embedded newline; needs doubling */
1076     ret = string_cat(ret, &size, &ptr, s, cp-s+1);
1077     ret = string_cat(ret, &size, &ptr, "\n", 1);
1078     s = cp+1;
1079     }
1080   /* last bit of header */
1081
1082   ret = string_cat(ret, &size, &ptr, s, cp-s+1);        /* newline-sep list */
1083   }
1084 while(h = h->next);
1085
1086 ret[ptr-1] = '\0';      /* overwrite last newline */
1087 return ret;
1088 }
1089
1090
1091 /*************************************************
1092 *        Set up removed header line(s)           *
1093 *************************************************/
1094
1095 /* This function is called by the remove_header modifier.  The argument is
1096 treated as a sequence of header names which are added to a colon separated
1097 list, provided there isn't an identical one already there.
1098
1099 Argument:   string of header names
1100 Returns:    nothing
1101 */
1102
1103 static void
1104 setup_remove_header(uschar *hnames)
1105 {
1106 if (*hnames != 0)
1107   {
1108   if (acl_removed_headers == NULL)
1109     acl_removed_headers = hnames;
1110   else
1111     acl_removed_headers = string_sprintf("%s : %s", acl_removed_headers, hnames);
1112   }
1113 }
1114
1115
1116
1117 /*************************************************
1118 *               Handle warnings                  *
1119 *************************************************/
1120
1121 /* This function is called when a WARN verb's conditions are true. It adds to
1122 the message's headers, and/or writes information to the log. In each case, this
1123 only happens once (per message for headers, per connection for log).
1124
1125 ** NOTE: The header adding action using the "message" setting is historic, and
1126 its use is now deprecated. The new add_header modifier should be used instead.
1127
1128 Arguments:
1129   where          ACL_WHERE_xxxx indicating which ACL this is
1130   user_message   message for adding to headers
1131   log_message    message for logging, if different
1132
1133 Returns:         nothing
1134 */
1135
1136 static void
1137 acl_warn(int where, uschar *user_message, uschar *log_message)
1138 {
1139 if (log_message != NULL && log_message != user_message)
1140   {
1141   uschar *text;
1142   string_item *logged;
1143
1144   text = string_sprintf("%s Warning: %s",  host_and_ident(TRUE),
1145     string_printing(log_message));
1146
1147   /* If a sender verification has failed, and the log message is "sender verify
1148   failed", add the failure message. */
1149
1150   if (sender_verified_failed != NULL &&
1151       sender_verified_failed->message != NULL &&
1152       strcmpic(log_message, US"sender verify failed") == 0)
1153     text = string_sprintf("%s: %s", text, sender_verified_failed->message);
1154
1155   /* Search previously logged warnings. They are kept in malloc
1156   store so they can be freed at the start of a new message. */
1157
1158   for (logged = acl_warn_logged; logged != NULL; logged = logged->next)
1159     if (Ustrcmp(logged->text, text) == 0) break;
1160
1161   if (logged == NULL)
1162     {
1163     int length = Ustrlen(text) + 1;
1164     log_write(0, LOG_MAIN, "%s", text);
1165     logged = store_malloc(sizeof(string_item) + length);
1166     logged->text = (uschar *)logged + sizeof(string_item);
1167     memcpy(logged->text, text, length);
1168     logged->next = acl_warn_logged;
1169     acl_warn_logged = logged;
1170     }
1171   }
1172
1173 /* If there's no user message, we are done. */
1174
1175 if (user_message == NULL) return;
1176
1177 /* If this isn't a message ACL, we can't do anything with a user message.
1178 Log an error. */
1179
1180 if (where > ACL_WHERE_NOTSMTP)
1181   {
1182   log_write(0, LOG_MAIN|LOG_PANIC, "ACL \"warn\" with \"message\" setting "
1183     "found in a non-message (%s) ACL: cannot specify header lines here: "
1184     "message ignored", acl_wherenames[where]);
1185   return;
1186   }
1187
1188 /* The code for setting up header lines is now abstracted into a separate
1189 function so that it can be used for the add_header modifier as well. */
1190
1191 setup_header(user_message);
1192 }
1193
1194
1195
1196 /*************************************************
1197 *         Verify and check reverse DNS           *
1198 *************************************************/
1199
1200 /* Called from acl_verify() below. We look up the host name(s) of the client IP
1201 address if this has not yet been done. The host_name_lookup() function checks
1202 that one of these names resolves to an address list that contains the client IP
1203 address, so we don't actually have to do the check here.
1204
1205 Arguments:
1206   user_msgptr  pointer for user message
1207   log_msgptr   pointer for log message
1208
1209 Returns:       OK        verification condition succeeded
1210                FAIL      verification failed
1211                DEFER     there was a problem verifying
1212 */
1213
1214 static int
1215 acl_verify_reverse(uschar **user_msgptr, uschar **log_msgptr)
1216 {
1217 int rc;
1218
1219 user_msgptr = user_msgptr;  /* stop compiler warning */
1220
1221 /* Previous success */
1222
1223 if (sender_host_name != NULL) return OK;
1224
1225 /* Previous failure */
1226
1227 if (host_lookup_failed)
1228   {
1229   *log_msgptr = string_sprintf("host lookup failed%s", host_lookup_msg);
1230   return FAIL;
1231   }
1232
1233 /* Need to do a lookup */
1234
1235 HDEBUG(D_acl)
1236   debug_printf("looking up host name to force name/address consistency check\n");
1237
1238 if ((rc = host_name_lookup()) != OK)
1239   {
1240   *log_msgptr = (rc == DEFER)?
1241     US"host lookup deferred for reverse lookup check"
1242     :
1243     string_sprintf("host lookup failed for reverse lookup check%s",
1244       host_lookup_msg);
1245   return rc;    /* DEFER or FAIL */
1246   }
1247
1248 host_build_sender_fullhost();
1249 return OK;
1250 }
1251
1252
1253
1254 /*************************************************
1255 *   Check client IP address matches CSA target   *
1256 *************************************************/
1257
1258 /* Called from acl_verify_csa() below. This routine scans a section of a DNS
1259 response for address records belonging to the CSA target hostname. The section
1260 is specified by the reset argument, either RESET_ADDITIONAL or RESET_ANSWERS.
1261 If one of the addresses matches the client's IP address, then the client is
1262 authorized by CSA. If there are target IP addresses but none of them match
1263 then the client is using an unauthorized IP address. If there are no target IP
1264 addresses then the client cannot be using an authorized IP address. (This is
1265 an odd configuration - why didn't the SRV record have a weight of 1 instead?)
1266
1267 Arguments:
1268   dnsa       the DNS answer block
1269   dnss       a DNS scan block for us to use
1270   reset      option specifing what portion to scan, as described above
1271   target     the target hostname to use for matching RR names
1272
1273 Returns:     CSA_OK             successfully authorized
1274              CSA_FAIL_MISMATCH  addresses found but none matched
1275              CSA_FAIL_NOADDR    no target addresses found
1276 */
1277
1278 static int
1279 acl_verify_csa_address(dns_answer *dnsa, dns_scan *dnss, int reset,
1280                        uschar *target)
1281 {
1282 dns_record *rr;
1283 dns_address *da;
1284
1285 BOOL target_found = FALSE;
1286
1287 for (rr = dns_next_rr(dnsa, dnss, reset);
1288      rr != NULL;
1289      rr = dns_next_rr(dnsa, dnss, RESET_NEXT))
1290   {
1291   /* Check this is an address RR for the target hostname. */
1292
1293   if (rr->type != T_A
1294     #if HAVE_IPV6
1295       && rr->type != T_AAAA
1296       #ifdef SUPPORT_A6
1297         && rr->type != T_A6
1298       #endif
1299     #endif
1300   ) continue;
1301
1302   if (strcmpic(target, rr->name) != 0) continue;
1303
1304   target_found = TRUE;
1305
1306   /* Turn the target address RR into a list of textual IP addresses and scan
1307   the list. There may be more than one if it is an A6 RR. */
1308
1309   for (da = dns_address_from_rr(dnsa, rr); da != NULL; da = da->next)
1310     {
1311     /* If the client IP address matches the target IP address, it's good! */
1312
1313     DEBUG(D_acl) debug_printf("CSA target address is %s\n", da->address);
1314
1315     if (strcmpic(sender_host_address, da->address) == 0) return CSA_OK;
1316     }
1317   }
1318
1319 /* If we found some target addresses but none of them matched, the client is
1320 using an unauthorized IP address, otherwise the target has no authorized IP
1321 addresses. */
1322
1323 if (target_found) return CSA_FAIL_MISMATCH;
1324 else return CSA_FAIL_NOADDR;
1325 }
1326
1327
1328
1329 /*************************************************
1330 *       Verify Client SMTP Authorization         *
1331 *************************************************/
1332
1333 /* Called from acl_verify() below. This routine calls dns_lookup_special()
1334 to find the CSA SRV record corresponding to the domain argument, or
1335 $sender_helo_name if no argument is provided. It then checks that the
1336 client is authorized, and that its IP address corresponds to the SRV
1337 target's address by calling acl_verify_csa_address() above. The address
1338 should have been returned in the DNS response's ADDITIONAL section, but if
1339 not we perform another DNS lookup to get it.
1340
1341 Arguments:
1342   domain    pointer to optional parameter following verify = csa
1343
1344 Returns:    CSA_UNKNOWN    no valid CSA record found
1345             CSA_OK         successfully authorized
1346             CSA_FAIL_*     client is definitely not authorized
1347             CSA_DEFER_*    there was a DNS problem
1348 */
1349
1350 static int
1351 acl_verify_csa(uschar *domain)
1352 {
1353 tree_node *t;
1354 uschar *found, *p;
1355 int priority, weight, port;
1356 dns_answer dnsa;
1357 dns_scan dnss;
1358 dns_record *rr;
1359 int rc, type;
1360 uschar target[256];
1361
1362 /* Work out the domain we are using for the CSA lookup. The default is the
1363 client's HELO domain. If the client has not said HELO, use its IP address
1364 instead. If it's a local client (exim -bs), CSA isn't applicable. */
1365
1366 while (isspace(*domain) && *domain != '\0') ++domain;
1367 if (*domain == '\0') domain = sender_helo_name;
1368 if (domain == NULL) domain = sender_host_address;
1369 if (sender_host_address == NULL) return CSA_UNKNOWN;
1370
1371 /* If we have an address literal, strip off the framing ready for turning it
1372 into a domain. The framing consists of matched square brackets possibly
1373 containing a keyword and a colon before the actual IP address. */
1374
1375 if (domain[0] == '[')
1376   {
1377   uschar *start = Ustrchr(domain, ':');
1378   if (start == NULL) start = domain;
1379   domain = string_copyn(start + 1, Ustrlen(start) - 2);
1380   }
1381
1382 /* Turn domains that look like bare IP addresses into domains in the reverse
1383 DNS. This code also deals with address literals and $sender_host_address. It's
1384 not quite kosher to treat bare domains such as EHLO 192.0.2.57 the same as
1385 address literals, but it's probably the most friendly thing to do. This is an
1386 extension to CSA, so we allow it to be turned off for proper conformance. */
1387
1388 if (string_is_ip_address(domain, NULL) != 0)
1389   {
1390   if (!dns_csa_use_reverse) return CSA_UNKNOWN;
1391   dns_build_reverse(domain, target);
1392   domain = target;
1393   }
1394
1395 /* Find out if we've already done the CSA check for this domain. If we have,
1396 return the same result again. Otherwise build a new cached result structure
1397 for this domain. The name is filled in now, and the value is filled in when
1398 we return from this function. */
1399
1400 t = tree_search(csa_cache, domain);
1401 if (t != NULL) return t->data.val;
1402
1403 t = store_get_perm(sizeof(tree_node) + Ustrlen(domain));
1404 Ustrcpy(t->name, domain);
1405 (void)tree_insertnode(&csa_cache, t);
1406
1407 /* Now we are ready to do the actual DNS lookup(s). */
1408
1409 found = domain;
1410 switch (dns_special_lookup(&dnsa, domain, T_CSA, &found))
1411   {
1412   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1413
1414   default:
1415   return t->data.val = CSA_DEFER_SRV;
1416
1417   /* If we found nothing, the client's authorization is unknown. */
1418
1419   case DNS_NOMATCH:
1420   case DNS_NODATA:
1421   return t->data.val = CSA_UNKNOWN;
1422
1423   /* We got something! Go on to look at the reply in more detail. */
1424
1425   case DNS_SUCCEED:
1426   break;
1427   }
1428
1429 /* Scan the reply for well-formed CSA SRV records. */
1430
1431 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1432      rr != NULL;
1433      rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1434   {
1435   if (rr->type != T_SRV) continue;
1436
1437   /* Extract the numerical SRV fields (p is incremented) */
1438
1439   p = rr->data;
1440   GETSHORT(priority, p);
1441   GETSHORT(weight, p);
1442   GETSHORT(port, p);
1443
1444   DEBUG(D_acl)
1445     debug_printf("CSA priority=%d weight=%d port=%d\n", priority, weight, port);
1446
1447   /* Check the CSA version number */
1448
1449   if (priority != 1) continue;
1450
1451   /* If the domain does not have a CSA SRV record of its own (i.e. the domain
1452   found by dns_special_lookup() is a parent of the one we asked for), we check
1453   the subdomain assertions in the port field. At the moment there's only one
1454   assertion: legitimate SMTP clients are all explicitly authorized with CSA
1455   SRV records of their own. */
1456
1457   if (found != domain)
1458     {
1459     if (port & 1)
1460       return t->data.val = CSA_FAIL_EXPLICIT;
1461     else
1462       return t->data.val = CSA_UNKNOWN;
1463     }
1464
1465   /* This CSA SRV record refers directly to our domain, so we check the value
1466   in the weight field to work out the domain's authorization. 0 and 1 are
1467   unauthorized; 3 means the client is authorized but we can't check the IP
1468   address in order to authenticate it, so we treat it as unknown; values
1469   greater than 3 are undefined. */
1470
1471   if (weight < 2) return t->data.val = CSA_FAIL_DOMAIN;
1472
1473   if (weight > 2) continue;
1474
1475   /* Weight == 2, which means the domain is authorized. We must check that the
1476   client's IP address is listed as one of the SRV target addresses. Save the
1477   target hostname then break to scan the additional data for its addresses. */
1478
1479   (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, p,
1480     (DN_EXPAND_ARG4_TYPE)target, sizeof(target));
1481
1482   DEBUG(D_acl) debug_printf("CSA target is %s\n", target);
1483
1484   break;
1485   }
1486
1487 /* If we didn't break the loop then no appropriate records were found. */
1488
1489 if (rr == NULL) return t->data.val = CSA_UNKNOWN;
1490
1491 /* Do not check addresses if the target is ".", in accordance with RFC 2782.
1492 A target of "." indicates there are no valid addresses, so the client cannot
1493 be authorized. (This is an odd configuration because weight=2 target=. is
1494 equivalent to weight=1, but we check for it in order to keep load off the
1495 root name servers.) Note that dn_expand() turns "." into "". */
1496
1497 if (Ustrcmp(target, "") == 0) return t->data.val = CSA_FAIL_NOADDR;
1498
1499 /* Scan the additional section of the CSA SRV reply for addresses belonging
1500 to the target. If the name server didn't return any additional data (e.g.
1501 because it does not fully support SRV records), we need to do another lookup
1502 to obtain the target addresses; otherwise we have a definitive result. */
1503
1504 rc = acl_verify_csa_address(&dnsa, &dnss, RESET_ADDITIONAL, target);
1505 if (rc != CSA_FAIL_NOADDR) return t->data.val = rc;
1506
1507 /* The DNS lookup type corresponds to the IP version used by the client. */
1508
1509 #if HAVE_IPV6
1510 if (Ustrchr(sender_host_address, ':') != NULL)
1511   type = T_AAAA;
1512 else
1513 #endif /* HAVE_IPV6 */
1514   type = T_A;
1515
1516
1517 #if HAVE_IPV6 && defined(SUPPORT_A6)
1518 DNS_LOOKUP_AGAIN:
1519 #endif
1520
1521 switch (dns_lookup(&dnsa, target, type, NULL))
1522   {
1523   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1524
1525   default:
1526   return t->data.val = CSA_DEFER_ADDR;
1527
1528   /* If the query succeeded, scan the addresses and return the result. */
1529
1530   case DNS_SUCCEED:
1531   rc = acl_verify_csa_address(&dnsa, &dnss, RESET_ANSWERS, target);
1532   if (rc != CSA_FAIL_NOADDR) return t->data.val = rc;
1533   /* else fall through */
1534
1535   /* If the target has no IP addresses, the client cannot have an authorized
1536   IP address. However, if the target site uses A6 records (not AAAA records)
1537   we have to do yet another lookup in order to check them. */
1538
1539   case DNS_NOMATCH:
1540   case DNS_NODATA:
1541
1542   #if HAVE_IPV6 && defined(SUPPORT_A6)
1543   if (type == T_AAAA) { type = T_A6; goto DNS_LOOKUP_AGAIN; }
1544   #endif
1545
1546   return t->data.val = CSA_FAIL_NOADDR;
1547   }
1548 }
1549
1550
1551
1552 /*************************************************
1553 *     Handle verification (address & other)      *
1554 *************************************************/
1555
1556 enum { VERIFY_REV_HOST_LKUP, VERIFY_CERT, VERIFY_HELO, VERIFY_CSA, VERIFY_HDR_SYNTAX,
1557   VERIFY_NOT_BLIND, VERIFY_HDR_SNDR, VERIFY_SNDR, VERIFY_RCPT
1558   };
1559 typedef struct {
1560   uschar * name;
1561   int      value;
1562   unsigned where_allowed;       /* bitmap */
1563   BOOL     no_options;          /* Never has /option(s) following */
1564   unsigned alt_opt_sep;         /* >0 Non-/ option separator (custom parser) */
1565   } verify_type_t;
1566 static verify_type_t verify_type_list[] = {
1567     { US"reverse_host_lookup",  VERIFY_REV_HOST_LKUP,   ~0,     TRUE, 0 },
1568     { US"certificate",          VERIFY_CERT,            ~0,     TRUE, 0 },
1569     { US"helo",                 VERIFY_HELO,            ~0,     TRUE, 0 },
1570     { US"csa",                  VERIFY_CSA,             ~0,     FALSE, 0 },
1571     { US"header_syntax",        VERIFY_HDR_SYNTAX,      (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP), TRUE, 0 },
1572     { US"not_blind",            VERIFY_NOT_BLIND,       (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP), TRUE, 0 },
1573     { US"header_sender",        VERIFY_HDR_SNDR,        (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP), FALSE, 0 },
1574     { US"sender",               VERIFY_SNDR,            (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)
1575                         |(1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP),
1576                                                                                 FALSE, 6 },
1577     { US"recipient",            VERIFY_RCPT,            (1<<ACL_WHERE_RCPT),    FALSE, 0 }
1578   };
1579
1580
1581 enum { CALLOUT_DEFER_OK, CALLOUT_NOCACHE, CALLOUT_RANDOM, CALLOUT_USE_SENDER,
1582   CALLOUT_USE_POSTMASTER, CALLOUT_POSTMASTER, CALLOUT_FULLPOSTMASTER,
1583   CALLOUT_MAILFROM, CALLOUT_POSTMASTER_MAILFROM, CALLOUT_MAXWAIT, CALLOUT_CONNECT,
1584   CALLOUT_TIME
1585   };
1586 typedef struct {
1587   uschar * name;
1588   int      value;
1589   int      flag;
1590   BOOL     has_option;  /* Has =option(s) following */
1591   BOOL     timeval;     /* Has a time value */
1592   } callout_opt_t;
1593 static callout_opt_t callout_opt_list[] = {
1594     { US"defer_ok",       CALLOUT_DEFER_OK,      0,                             FALSE, FALSE },
1595     { US"no_cache",       CALLOUT_NOCACHE,       vopt_callout_no_cache,         FALSE, FALSE },
1596     { US"random",         CALLOUT_RANDOM,        vopt_callout_random,           FALSE, FALSE },
1597     { US"use_sender",     CALLOUT_USE_SENDER,    vopt_callout_recipsender,      FALSE, FALSE },
1598     { US"use_postmaster", CALLOUT_USE_POSTMASTER,vopt_callout_recippmaster,     FALSE, FALSE },
1599     { US"postmaster_mailfrom",CALLOUT_POSTMASTER_MAILFROM,0,                    TRUE,  FALSE },
1600     { US"postmaster",     CALLOUT_POSTMASTER,    0,                             FALSE, FALSE },
1601     { US"fullpostmaster", CALLOUT_FULLPOSTMASTER,vopt_callout_fullpm,           FALSE, FALSE },
1602     { US"mailfrom",       CALLOUT_MAILFROM,      0,                             TRUE,  FALSE },
1603     { US"maxwait",        CALLOUT_MAXWAIT,       0,                             TRUE,  TRUE },
1604     { US"connect",        CALLOUT_CONNECT,       0,                             TRUE,  TRUE },
1605     { NULL,               CALLOUT_TIME,          0,                             FALSE, TRUE }
1606   };
1607
1608
1609
1610 /* This function implements the "verify" condition. It is called when
1611 encountered in any ACL, because some tests are almost always permitted. Some
1612 just don't make sense, and always fail (for example, an attempt to test a host
1613 lookup for a non-TCP/IP message). Others are restricted to certain ACLs.
1614
1615 Arguments:
1616   where        where called from
1617   addr         the recipient address that the ACL is handling, or NULL
1618   arg          the argument of "verify"
1619   user_msgptr  pointer for user message
1620   log_msgptr   pointer for log message
1621   basic_errno  where to put verify errno
1622
1623 Returns:       OK        verification condition succeeded
1624                FAIL      verification failed
1625                DEFER     there was a problem verifying
1626                ERROR     syntax error
1627 */
1628
1629 static int
1630 acl_verify(int where, address_item *addr, uschar *arg,
1631   uschar **user_msgptr, uschar **log_msgptr, int *basic_errno)
1632 {
1633 int sep = '/';
1634 int callout = -1;
1635 int callout_overall = -1;
1636 int callout_connect = -1;
1637 int verify_options = 0;
1638 int rc;
1639 BOOL verify_header_sender = FALSE;
1640 BOOL defer_ok = FALSE;
1641 BOOL callout_defer_ok = FALSE;
1642 BOOL no_details = FALSE;
1643 BOOL success_on_redirect = FALSE;
1644 address_item *sender_vaddr = NULL;
1645 uschar *verify_sender_address = NULL;
1646 uschar *pm_mailfrom = NULL;
1647 uschar *se_mailfrom = NULL;
1648
1649 /* Some of the verify items have slash-separated options; some do not. Diagnose
1650 an error if options are given for items that don't expect them.
1651 */
1652
1653 uschar *slash = Ustrchr(arg, '/');
1654 uschar *list = arg;
1655 uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
1656 verify_type_t * vp;
1657
1658 if (ss == NULL) goto BAD_VERIFY;
1659
1660 /* Handle name/address consistency verification in a separate function. */
1661
1662 for (vp= verify_type_list;
1663      (char *)vp < (char *)verify_type_list + sizeof(verify_type_list);
1664      vp++
1665     )
1666   if (vp->alt_opt_sep ? strncmpic(ss, vp->name, vp->alt_opt_sep) == 0
1667                       : strcmpic (ss, vp->name) == 0)
1668    break;
1669 if ((char *)vp >= (char *)verify_type_list + sizeof(verify_type_list))
1670   goto BAD_VERIFY;
1671
1672 if (vp->no_options && slash != NULL)
1673   {
1674   *log_msgptr = string_sprintf("unexpected '/' found in \"%s\" "
1675     "(this verify item has no options)", arg);
1676   return ERROR;
1677   }
1678 if (!(vp->where_allowed & (1<<where)))
1679   {
1680   *log_msgptr = string_sprintf("cannot verify %s in ACL for %s", vp->name, acl_wherenames[where]);
1681   return ERROR;
1682   }
1683 switch(vp->value)
1684   {
1685   case VERIFY_REV_HOST_LKUP:
1686     if (sender_host_address == NULL) return OK;
1687     return acl_verify_reverse(user_msgptr, log_msgptr);
1688
1689   case VERIFY_CERT:
1690     /* TLS certificate verification is done at STARTTLS time; here we just
1691     test whether it was successful or not. (This is for optional verification; for
1692     mandatory verification, the connection doesn't last this long.) */
1693
1694       if (tls_in.certificate_verified) return OK;
1695       *user_msgptr = US"no verified certificate";
1696       return FAIL;
1697
1698   case VERIFY_HELO:
1699     /* We can test the result of optional HELO verification that might have
1700     occurred earlier. If not, we can attempt the verification now. */
1701
1702       if (!helo_verified && !helo_verify_failed) smtp_verify_helo();
1703       return helo_verified? OK : FAIL;
1704
1705   case VERIFY_CSA:
1706     /* Do Client SMTP Authorization checks in a separate function, and turn the
1707     result code into user-friendly strings. */
1708
1709       rc = acl_verify_csa(list);
1710       *log_msgptr = *user_msgptr = string_sprintf("client SMTP authorization %s",
1711                                               csa_reason_string[rc]);
1712       csa_status = csa_status_string[rc];
1713       DEBUG(D_acl) debug_printf("CSA result %s\n", csa_status);
1714       return csa_return_code[rc];
1715
1716   case VERIFY_HDR_SYNTAX:
1717     /* Check that all relevant header lines have the correct syntax. If there is
1718     a syntax error, we return details of the error to the sender if configured to
1719     send out full details. (But a "message" setting on the ACL can override, as
1720     always). */
1721
1722     rc = verify_check_headers(log_msgptr);
1723     if (rc != OK && smtp_return_error_details && *log_msgptr != NULL)
1724       *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1725     return rc;
1726
1727   case VERIFY_NOT_BLIND:
1728     /* Check that no recipient of this message is "blind", that is, every envelope
1729     recipient must be mentioned in either To: or Cc:. */
1730
1731     rc = verify_check_notblind();
1732     if (rc != OK)
1733       {
1734       *log_msgptr = string_sprintf("bcc recipient detected");
1735       if (smtp_return_error_details)
1736         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1737       }
1738     return rc;
1739
1740   /* The remaining verification tests check recipient and sender addresses,
1741   either from the envelope or from the header. There are a number of
1742   slash-separated options that are common to all of them. */
1743
1744   case VERIFY_HDR_SNDR:
1745     verify_header_sender = TRUE;
1746     break;
1747
1748   case VERIFY_SNDR:
1749     /* In the case of a sender, this can optionally be followed by an address to use
1750     in place of the actual sender (rare special-case requirement). */
1751     {
1752     uschar *s = ss + 6;
1753     if (*s == 0)
1754       verify_sender_address = sender_address;
1755     else
1756       {
1757       while (isspace(*s)) s++;
1758       if (*s++ != '=') goto BAD_VERIFY;
1759       while (isspace(*s)) s++;
1760       verify_sender_address = string_copy(s);
1761       }
1762     }
1763     break;
1764
1765   case VERIFY_RCPT:
1766     break;
1767   }
1768
1769
1770
1771 /* Remaining items are optional; they apply to sender and recipient
1772 verification, including "header sender" verification. */
1773
1774 while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
1775       != NULL)
1776   {
1777   if (strcmpic(ss, US"defer_ok") == 0) defer_ok = TRUE;
1778   else if (strcmpic(ss, US"no_details") == 0) no_details = TRUE;
1779   else if (strcmpic(ss, US"success_on_redirect") == 0) success_on_redirect = TRUE;
1780
1781   /* These two old options are left for backwards compatibility */
1782
1783   else if (strcmpic(ss, US"callout_defer_ok") == 0)
1784     {
1785     callout_defer_ok = TRUE;
1786     if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1787     }
1788
1789   else if (strcmpic(ss, US"check_postmaster") == 0)
1790      {
1791      pm_mailfrom = US"";
1792      if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1793      }
1794
1795   /* The callout option has a number of sub-options, comma separated */
1796
1797   else if (strncmpic(ss, US"callout", 7) == 0)
1798     {
1799     callout = CALLOUT_TIMEOUT_DEFAULT;
1800     ss += 7;
1801     if (*ss != 0)
1802       {
1803       while (isspace(*ss)) ss++;
1804       if (*ss++ == '=')
1805         {
1806         int optsep = ',';
1807         uschar *opt;
1808         uschar buffer[256];
1809         while (isspace(*ss)) ss++;
1810
1811         while ((opt = string_nextinlist(&ss, &optsep, buffer, sizeof(buffer)))
1812               != NULL)
1813           {
1814           callout_opt_t * op;
1815           double period = 1.0F;
1816
1817           for (op= callout_opt_list; op->name; op++)
1818             if (strncmpic(opt, op->name, Ustrlen(op->name)) == 0)
1819               break;
1820
1821           verify_options |= op->flag;
1822           if (op->has_option)
1823             {
1824             opt += Ustrlen(op->name);
1825             while (isspace(*opt)) opt++;
1826             if (*opt++ != '=')
1827               {
1828               *log_msgptr = string_sprintf("'=' expected after "
1829                 "\"%s\" in ACL verify condition \"%s\"", op->name, arg);
1830               return ERROR;
1831               }
1832             while (isspace(*opt)) opt++;
1833             }
1834           if (op->timeval)
1835             {
1836             period = readconf_readtime(opt, 0, FALSE);
1837             if (period < 0)
1838               {
1839               *log_msgptr = string_sprintf("bad time value in ACL condition "
1840                 "\"verify %s\"", arg);
1841               return ERROR;
1842               }
1843             }
1844
1845           switch(op->value)
1846             {
1847             case CALLOUT_DEFER_OK:              callout_defer_ok = TRUE; break;
1848             case CALLOUT_POSTMASTER:            pm_mailfrom = US"";     break;
1849             case CALLOUT_FULLPOSTMASTER:        pm_mailfrom = US"";     break;
1850             case CALLOUT_MAILFROM:
1851               if (!verify_header_sender)
1852                 {
1853                 *log_msgptr = string_sprintf("\"mailfrom\" is allowed as a "
1854                   "callout option only for verify=header_sender (detected in ACL "
1855                   "condition \"%s\")", arg);
1856                 return ERROR;
1857                 }
1858               se_mailfrom = string_copy(opt);
1859               break;
1860             case CALLOUT_POSTMASTER_MAILFROM:   pm_mailfrom = string_copy(opt); break;
1861             case CALLOUT_MAXWAIT:               callout_overall = period;       break;
1862             case CALLOUT_CONNECT:               callout_connect = period;       break;
1863             case CALLOUT_TIME:                  callout = period;               break;
1864             }
1865           }
1866         }
1867       else
1868         {
1869         *log_msgptr = string_sprintf("'=' expected after \"callout\" in "
1870           "ACL condition \"%s\"", arg);
1871         return ERROR;
1872         }
1873       }
1874     }
1875
1876   /* Option not recognized */
1877
1878   else
1879     {
1880     *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
1881       "condition \"verify %s\"", ss, arg);
1882     return ERROR;
1883     }
1884   }
1885
1886 if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)) ==
1887       (vopt_callout_recipsender|vopt_callout_recippmaster))
1888   {
1889   *log_msgptr = US"only one of use_sender and use_postmaster can be set "
1890     "for a recipient callout";
1891   return ERROR;
1892   }
1893
1894 /* Handle sender-in-header verification. Default the user message to the log
1895 message if giving out verification details. */
1896
1897 if (verify_header_sender)
1898   {
1899   int verrno;
1900   rc = verify_check_header_address(user_msgptr, log_msgptr, callout,
1901     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, verify_options,
1902     &verrno);
1903   if (rc != OK)
1904     {
1905     *basic_errno = verrno;
1906     if (smtp_return_error_details)
1907       {
1908       if (*user_msgptr == NULL && *log_msgptr != NULL)
1909         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1910       if (rc == DEFER) acl_temp_details = TRUE;
1911       }
1912     }
1913   }
1914
1915 /* Handle a sender address. The default is to verify *the* sender address, but
1916 optionally a different address can be given, for special requirements. If the
1917 address is empty, we are dealing with a bounce message that has no sender, so
1918 we cannot do any checking. If the real sender address gets rewritten during
1919 verification (e.g. DNS widening), set the flag to stop it being rewritten again
1920 during message reception.
1921
1922 A list of verified "sender" addresses is kept to try to avoid doing to much
1923 work repetitively when there are multiple recipients in a message and they all
1924 require sender verification. However, when callouts are involved, it gets too
1925 complicated because different recipients may require different callout options.
1926 Therefore, we always do a full sender verify when any kind of callout is
1927 specified. Caching elsewhere, for instance in the DNS resolver and in the
1928 callout handling, should ensure that this is not terribly inefficient. */
1929
1930 else if (verify_sender_address != NULL)
1931   {
1932   if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster))
1933        != 0)
1934     {
1935     *log_msgptr = US"use_sender or use_postmaster cannot be used for a "
1936       "sender verify callout";
1937     return ERROR;
1938     }
1939
1940   sender_vaddr = verify_checked_sender(verify_sender_address);
1941   if (sender_vaddr != NULL &&               /* Previously checked */
1942       callout <= 0)                         /* No callout needed this time */
1943     {
1944     /* If the "routed" flag is set, it means that routing worked before, so
1945     this check can give OK (the saved return code value, if set, belongs to a
1946     callout that was done previously). If the "routed" flag is not set, routing
1947     must have failed, so we use the saved return code. */
1948
1949     if (testflag(sender_vaddr, af_verify_routed)) rc = OK; else
1950       {
1951       rc = sender_vaddr->special_action;
1952       *basic_errno = sender_vaddr->basic_errno;
1953       }
1954     HDEBUG(D_acl) debug_printf("using cached sender verify result\n");
1955     }
1956
1957   /* Do a new verification, and cache the result. The cache is used to avoid
1958   verifying the sender multiple times for multiple RCPTs when callouts are not
1959   specified (see comments above).
1960
1961   The cache is also used on failure to give details in response to the first
1962   RCPT that gets bounced for this reason. However, this can be suppressed by
1963   the no_details option, which sets the flag that says "this detail has already
1964   been sent". The cache normally contains just one address, but there may be
1965   more in esoteric circumstances. */
1966
1967   else
1968     {
1969     BOOL routed = TRUE;
1970     uschar *save_address_data = deliver_address_data;
1971
1972     sender_vaddr = deliver_make_addr(verify_sender_address, TRUE);
1973     if (no_details) setflag(sender_vaddr, af_sverify_told);
1974     if (verify_sender_address[0] != 0)
1975       {
1976       /* If this is the real sender address, save the unrewritten version
1977       for use later in receive. Otherwise, set a flag so that rewriting the
1978       sender in verify_address() does not update sender_address. */
1979
1980       if (verify_sender_address == sender_address)
1981         sender_address_unrewritten = sender_address;
1982       else
1983         verify_options |= vopt_fake_sender;
1984
1985       if (success_on_redirect)
1986         verify_options |= vopt_success_on_redirect;
1987
1988       /* The recipient, qualify, and expn options are never set in
1989       verify_options. */
1990
1991       rc = verify_address(sender_vaddr, NULL, verify_options, callout,
1992         callout_overall, callout_connect, se_mailfrom, pm_mailfrom, &routed);
1993
1994       HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
1995
1996       if (rc == OK)
1997         {
1998         if (Ustrcmp(sender_vaddr->address, verify_sender_address) != 0)
1999           {
2000           DEBUG(D_acl) debug_printf("sender %s verified ok as %s\n",
2001             verify_sender_address, sender_vaddr->address);
2002           }
2003         else
2004           {
2005           DEBUG(D_acl) debug_printf("sender %s verified ok\n",
2006             verify_sender_address);
2007           }
2008         }
2009       else *basic_errno = sender_vaddr->basic_errno;
2010       }
2011     else rc = OK;  /* Null sender */
2012
2013     /* Cache the result code */
2014
2015     if (routed) setflag(sender_vaddr, af_verify_routed);
2016     if (callout > 0) setflag(sender_vaddr, af_verify_callout);
2017     sender_vaddr->special_action = rc;
2018     sender_vaddr->next = sender_verified_list;
2019     sender_verified_list = sender_vaddr;
2020
2021     /* Restore the recipient address data, which might have been clobbered by
2022     the sender verification. */
2023
2024     deliver_address_data = save_address_data;
2025     }
2026
2027   /* Put the sender address_data value into $sender_address_data */
2028
2029   sender_address_data = sender_vaddr->p.address_data;
2030   }
2031
2032 /* A recipient address just gets a straightforward verify; again we must handle
2033 the DEFER overrides. */
2034
2035 else
2036   {
2037   address_item addr2;
2038
2039   if (success_on_redirect)
2040     verify_options |= vopt_success_on_redirect;
2041
2042   /* We must use a copy of the address for verification, because it might
2043   get rewritten. */
2044
2045   addr2 = *addr;
2046   rc = verify_address(&addr2, NULL, verify_options|vopt_is_recipient, callout,
2047     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, NULL);
2048   HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
2049
2050   *basic_errno = addr2.basic_errno;
2051   *log_msgptr = addr2.message;
2052   *user_msgptr = (addr2.user_message != NULL)?
2053     addr2.user_message : addr2.message;
2054
2055   /* Allow details for temporary error if the address is so flagged. */
2056   if (testflag((&addr2), af_pass_message)) acl_temp_details = TRUE;
2057
2058   /* Make $address_data visible */
2059   deliver_address_data = addr2.p.address_data;
2060   }
2061
2062 /* We have a result from the relevant test. Handle defer overrides first. */
2063
2064 if (rc == DEFER && (defer_ok ||
2065    (callout_defer_ok && *basic_errno == ERRNO_CALLOUTDEFER)))
2066   {
2067   HDEBUG(D_acl) debug_printf("verify defer overridden by %s\n",
2068     defer_ok? "defer_ok" : "callout_defer_ok");
2069   rc = OK;
2070   }
2071
2072 /* If we've failed a sender, set up a recipient message, and point
2073 sender_verified_failed to the address item that actually failed. */
2074
2075 if (rc != OK && verify_sender_address != NULL)
2076   {
2077   if (rc != DEFER)
2078     {
2079     *log_msgptr = *user_msgptr = US"Sender verify failed";
2080     }
2081   else if (*basic_errno != ERRNO_CALLOUTDEFER)
2082     {
2083     *log_msgptr = *user_msgptr = US"Could not complete sender verify";
2084     }
2085   else
2086     {
2087     *log_msgptr = US"Could not complete sender verify callout";
2088     *user_msgptr = smtp_return_error_details? sender_vaddr->user_message :
2089       *log_msgptr;
2090     }
2091
2092   sender_verified_failed = sender_vaddr;
2093   }
2094
2095 /* Verifying an address messes up the values of $domain and $local_part,
2096 so reset them before returning if this is a RCPT ACL. */
2097
2098 if (addr != NULL)
2099   {
2100   deliver_domain = addr->domain;
2101   deliver_localpart = addr->local_part;
2102   }
2103 return rc;
2104
2105 /* Syntax errors in the verify argument come here. */
2106
2107 BAD_VERIFY:
2108 *log_msgptr = string_sprintf("expected \"sender[=address]\", \"recipient\", "
2109   "\"helo\", \"header_syntax\", \"header_sender\" or "
2110   "\"reverse_host_lookup\" at start of ACL condition "
2111   "\"verify %s\"", arg);
2112 return ERROR;
2113 }
2114
2115
2116
2117
2118 /*************************************************
2119 *        Check argument for control= modifier    *
2120 *************************************************/
2121
2122 /* Called from acl_check_condition() below
2123
2124 Arguments:
2125   arg         the argument string for control=
2126   pptr        set to point to the terminating character
2127   where       which ACL we are in
2128   log_msgptr  for error messages
2129
2130 Returns:      CONTROL_xxx value
2131 */
2132
2133 static int
2134 decode_control(uschar *arg, uschar **pptr, int where, uschar **log_msgptr)
2135 {
2136 int len;
2137 control_def *d;
2138
2139 for (d = controls_list;
2140      d < controls_list + sizeof(controls_list)/sizeof(control_def);
2141      d++)
2142   {
2143   len = Ustrlen(d->name);
2144   if (Ustrncmp(d->name, arg, len) == 0) break;
2145   }
2146
2147 if (d >= controls_list + sizeof(controls_list)/sizeof(control_def) ||
2148    (arg[len] != 0 && (!d->has_option || arg[len] != '/')))
2149   {
2150   *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
2151   return CONTROL_ERROR;
2152   }
2153
2154 *pptr = arg + len;
2155 return d->value;
2156 }
2157
2158
2159
2160
2161 /*************************************************
2162 *        Return a ratelimit error                *
2163 *************************************************/
2164
2165 /* Called from acl_ratelimit() below
2166
2167 Arguments:
2168   log_msgptr  for error messages
2169   format      format string
2170   ...         supplementary arguments
2171   ss          ratelimit option name
2172   where       ACL_WHERE_xxxx indicating which ACL this is
2173
2174 Returns:      ERROR
2175 */
2176
2177 static int
2178 ratelimit_error(uschar **log_msgptr, const char *format, ...)
2179 {
2180 va_list ap;
2181 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
2182 va_start(ap, format);
2183 if (!string_vformat(buffer, sizeof(buffer), format, ap))
2184   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
2185     "string_sprintf expansion was longer than " SIZE_T_FMT, sizeof(buffer));
2186 va_end(ap);
2187 *log_msgptr = string_sprintf(
2188   "error in arguments to \"ratelimit\" condition: %s", buffer);
2189 return ERROR;
2190 }
2191
2192
2193
2194
2195 /*************************************************
2196 *            Handle rate limiting                *
2197 *************************************************/
2198
2199 /* Called by acl_check_condition() below to calculate the result
2200 of the ACL ratelimit condition.
2201
2202 Note that the return value might be slightly unexpected: if the
2203 sender's rate is above the limit then the result is OK. This is
2204 similar to the dnslists condition, and is so that you can write
2205 ACL clauses like: defer ratelimit = 15 / 1h
2206
2207 Arguments:
2208   arg         the option string for ratelimit=
2209   where       ACL_WHERE_xxxx indicating which ACL this is
2210   log_msgptr  for error messages
2211
2212 Returns:       OK        - Sender's rate is above limit
2213                FAIL      - Sender's rate is below limit
2214                DEFER     - Problem opening ratelimit database
2215                ERROR     - Syntax error in options.
2216 */
2217
2218 static int
2219 acl_ratelimit(uschar *arg, int where, uschar **log_msgptr)
2220 {
2221 double limit, period, count;
2222 uschar *ss;
2223 uschar *key = NULL;
2224 uschar *unique = NULL;
2225 int sep = '/';
2226 BOOL leaky = FALSE, strict = FALSE, readonly = FALSE;
2227 BOOL noupdate = FALSE, badacl = FALSE;
2228 int mode = RATE_PER_WHAT;
2229 int old_pool, rc;
2230 tree_node **anchor, *t;
2231 open_db dbblock, *dbm;
2232 int dbdb_size;
2233 dbdata_ratelimit *dbd;
2234 dbdata_ratelimit_unique *dbdb;
2235 struct timeval tv;
2236
2237 /* Parse the first two options and record their values in expansion
2238 variables. These variables allow the configuration to have informative
2239 error messages based on rate limits obtained from a table lookup. */
2240
2241 /* First is the maximum number of messages per period / maximum burst
2242 size, which must be greater than or equal to zero. Zero is useful for
2243 rate measurement as opposed to rate limiting. */
2244
2245 sender_rate_limit = string_nextinlist(&arg, &sep, NULL, 0);
2246 if (sender_rate_limit == NULL)
2247   limit = -1.0;
2248 else
2249   {
2250   limit = Ustrtod(sender_rate_limit, &ss);
2251   if (tolower(*ss) == 'k') { limit *= 1024.0; ss++; }
2252   else if (tolower(*ss) == 'm') { limit *= 1024.0*1024.0; ss++; }
2253   else if (tolower(*ss) == 'g') { limit *= 1024.0*1024.0*1024.0; ss++; }
2254   }
2255 if (limit < 0.0 || *ss != '\0')
2256   return ratelimit_error(log_msgptr,
2257     "\"%s\" is not a positive number", sender_rate_limit);
2258
2259 /* Second is the rate measurement period / exponential smoothing time
2260 constant. This must be strictly greater than zero, because zero leads to
2261 run-time division errors. */
2262
2263 sender_rate_period = string_nextinlist(&arg, &sep, NULL, 0);
2264 if (sender_rate_period == NULL) period = -1.0;
2265 else period = readconf_readtime(sender_rate_period, 0, FALSE);
2266 if (period <= 0.0)
2267   return ratelimit_error(log_msgptr,
2268     "\"%s\" is not a time value", sender_rate_period);
2269
2270 /* By default we are counting one of something, but the per_rcpt,
2271 per_byte, and count options can change this. */
2272
2273 count = 1.0;
2274
2275 /* Parse the other options. */
2276
2277 while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
2278        != NULL)
2279   {
2280   if (strcmpic(ss, US"leaky") == 0) leaky = TRUE;
2281   else if (strcmpic(ss, US"strict") == 0) strict = TRUE;
2282   else if (strcmpic(ss, US"noupdate") == 0) noupdate = TRUE;
2283   else if (strcmpic(ss, US"readonly") == 0) readonly = TRUE;
2284   else if (strcmpic(ss, US"per_cmd") == 0) RATE_SET(mode, PER_CMD);
2285   else if (strcmpic(ss, US"per_conn") == 0)
2286     {
2287     RATE_SET(mode, PER_CONN);
2288     if (where == ACL_WHERE_NOTSMTP || where == ACL_WHERE_NOTSMTP_START)
2289       badacl = TRUE;
2290     }
2291   else if (strcmpic(ss, US"per_mail") == 0)
2292     {
2293     RATE_SET(mode, PER_MAIL);
2294     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2295     }
2296   else if (strcmpic(ss, US"per_rcpt") == 0)
2297     {
2298     /* If we are running in the RCPT ACL, then we'll count the recipients
2299     one by one, but if we are running when we have accumulated the whole
2300     list then we'll add them all in one batch. */
2301     if (where == ACL_WHERE_RCPT)
2302       RATE_SET(mode, PER_RCPT);
2303     else if (where >= ACL_WHERE_PREDATA && where <= ACL_WHERE_NOTSMTP)
2304       RATE_SET(mode, PER_ALLRCPTS), count = (double)recipients_count;
2305     else if (where == ACL_WHERE_MAIL || where > ACL_WHERE_NOTSMTP)
2306       RATE_SET(mode, PER_RCPT), badacl = TRUE;
2307     }
2308   else if (strcmpic(ss, US"per_byte") == 0)
2309     {
2310     /* If we have not yet received the message data and there was no SIZE
2311     declaration on the MAIL comand, then it's safe to just use a value of
2312     zero and let the recorded rate decay as if nothing happened. */
2313     RATE_SET(mode, PER_MAIL);
2314     if (where > ACL_WHERE_NOTSMTP) badacl = TRUE;
2315       else count = message_size < 0 ? 0.0 : (double)message_size;
2316     }
2317   else if (strcmpic(ss, US"per_addr") == 0)
2318     {
2319     RATE_SET(mode, PER_RCPT);
2320     if (where != ACL_WHERE_RCPT) badacl = TRUE, unique = US"*";
2321       else unique = string_sprintf("%s@%s", deliver_localpart, deliver_domain);
2322     }
2323   else if (strncmpic(ss, US"count=", 6) == 0)
2324     {
2325     uschar *e;
2326     count = Ustrtod(ss+6, &e);
2327     if (count < 0.0 || *e != '\0')
2328       return ratelimit_error(log_msgptr,
2329         "\"%s\" is not a positive number", ss);
2330     }
2331   else if (strncmpic(ss, US"unique=", 7) == 0)
2332     unique = string_copy(ss + 7);
2333   else if (key == NULL)
2334     key = string_copy(ss);
2335   else
2336     key = string_sprintf("%s/%s", key, ss);
2337   }
2338
2339 /* Sanity check. When the badacl flag is set the update mode must either
2340 be readonly (which is the default if it is omitted) or, for backwards
2341 compatibility, a combination of noupdate and strict or leaky. */
2342
2343 if (mode == RATE_PER_CLASH)
2344   return ratelimit_error(log_msgptr, "conflicting per_* options");
2345 if (leaky + strict + readonly > 1)
2346   return ratelimit_error(log_msgptr, "conflicting update modes");
2347 if (badacl && (leaky || strict) && !noupdate)
2348   return ratelimit_error(log_msgptr,
2349     "\"%s\" must not have /leaky or /strict option in %s ACL",
2350     ratelimit_option_string[mode], acl_wherenames[where]);
2351
2352 /* Set the default values of any unset options. In readonly mode we
2353 perform the rate computation without any increment so that its value
2354 decays to eventually allow over-limit senders through. */
2355
2356 if (noupdate) readonly = TRUE, leaky = strict = FALSE;
2357 if (badacl) readonly = TRUE;
2358 if (readonly) count = 0.0;
2359 if (!strict && !readonly) leaky = TRUE;
2360 if (mode == RATE_PER_WHAT) mode = RATE_PER_MAIL;
2361
2362 /* Create the lookup key. If there is no explicit key, use sender_host_address.
2363 If there is no sender_host_address (e.g. -bs or acl_not_smtp) then we simply
2364 omit it. The smoothing constant (sender_rate_period) and the per_xxx options
2365 are added to the key because they alter the meaning of the stored data. */
2366
2367 if (key == NULL)
2368   key = (sender_host_address == NULL)? US"" : sender_host_address;
2369
2370 key = string_sprintf("%s/%s/%s%s",
2371   sender_rate_period,
2372   ratelimit_option_string[mode],
2373   unique == NULL ? "" : "unique/",
2374   key);
2375
2376 HDEBUG(D_acl)
2377   debug_printf("ratelimit condition count=%.0f %.1f/%s\n", count, limit, key);
2378
2379 /* See if we have already computed the rate by looking in the relevant tree.
2380 For per-connection rate limiting, store tree nodes and dbdata in the permanent
2381 pool so that they survive across resets. In readonly mode we only remember the
2382 result for the rest of this command in case a later command changes it. After
2383 this bit of logic the code is independent of the per_* mode. */
2384
2385 old_pool = store_pool;
2386
2387 if (readonly)
2388   anchor = &ratelimiters_cmd;
2389 else switch(mode) {
2390 case RATE_PER_CONN:
2391   anchor = &ratelimiters_conn;
2392   store_pool = POOL_PERM;
2393   break;
2394 case RATE_PER_BYTE:
2395 case RATE_PER_MAIL:
2396 case RATE_PER_ALLRCPTS:
2397   anchor = &ratelimiters_mail;
2398   break;
2399 case RATE_PER_ADDR:
2400 case RATE_PER_CMD:
2401 case RATE_PER_RCPT:
2402   anchor = &ratelimiters_cmd;
2403   break;
2404 default:
2405   anchor = NULL; /* silence an "unused" complaint */
2406   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
2407     "internal ACL error: unknown ratelimit mode %d", mode);
2408   break;
2409 }
2410
2411 t = tree_search(*anchor, key);
2412 if (t != NULL)
2413   {
2414   dbd = t->data.ptr;
2415   /* The following few lines duplicate some of the code below. */
2416   rc = (dbd->rate < limit)? FAIL : OK;
2417   store_pool = old_pool;
2418   sender_rate = string_sprintf("%.1f", dbd->rate);
2419   HDEBUG(D_acl)
2420     debug_printf("ratelimit found pre-computed rate %s\n", sender_rate);
2421   return rc;
2422   }
2423
2424 /* We aren't using a pre-computed rate, so get a previously recorded rate
2425 from the database, which will be updated and written back if required. */
2426
2427 dbm = dbfn_open(US"ratelimit", O_RDWR, &dbblock, TRUE);
2428 if (dbm == NULL)
2429   {
2430   store_pool = old_pool;
2431   sender_rate = NULL;
2432   HDEBUG(D_acl) debug_printf("ratelimit database not available\n");
2433   *log_msgptr = US"ratelimit database not available";
2434   return DEFER;
2435   }
2436 dbdb = dbfn_read_with_length(dbm, key, &dbdb_size);
2437 dbd = NULL;
2438
2439 gettimeofday(&tv, NULL);
2440
2441 if (dbdb != NULL)
2442   {
2443   /* Locate the basic ratelimit block inside the DB data. */
2444   HDEBUG(D_acl) debug_printf("ratelimit found key in database\n");
2445   dbd = &dbdb->dbd;
2446
2447   /* Forget the old Bloom filter if it is too old, so that we count each
2448   repeating event once per period. We don't simply clear and re-use the old
2449   filter because we want its size to change if the limit changes. Note that
2450   we keep the dbd pointer for copying the rate into the new data block. */
2451
2452   if(unique != NULL && tv.tv_sec > dbdb->bloom_epoch + period)
2453     {
2454     HDEBUG(D_acl) debug_printf("ratelimit discarding old Bloom filter\n");
2455     dbdb = NULL;
2456     }
2457
2458   /* Sanity check. */
2459
2460   if(unique != NULL && dbdb_size < sizeof(*dbdb))
2461     {
2462     HDEBUG(D_acl) debug_printf("ratelimit discarding undersize Bloom filter\n");
2463     dbdb = NULL;
2464     }
2465   }
2466
2467 /* Allocate a new data block if the database lookup failed
2468 or the Bloom filter passed its age limit. */
2469
2470 if (dbdb == NULL)
2471   {
2472   if (unique == NULL)
2473     {
2474     /* No Bloom filter. This basic ratelimit block is initialized below. */
2475     HDEBUG(D_acl) debug_printf("ratelimit creating new rate data block\n");
2476     dbdb_size = sizeof(*dbd);
2477     dbdb = store_get(dbdb_size);
2478     }
2479   else
2480     {
2481     int extra;
2482     HDEBUG(D_acl) debug_printf("ratelimit creating new Bloom filter\n");
2483
2484     /* See the long comment below for an explanation of the magic number 2.
2485     The filter has a minimum size in case the rate limit is very small;
2486     this is determined by the definition of dbdata_ratelimit_unique. */
2487
2488     extra = (int)limit * 2 - sizeof(dbdb->bloom);
2489     if (extra < 0) extra = 0;
2490     dbdb_size = sizeof(*dbdb) + extra;
2491     dbdb = store_get(dbdb_size);
2492     dbdb->bloom_epoch = tv.tv_sec;
2493     dbdb->bloom_size = sizeof(dbdb->bloom) + extra;
2494     memset(dbdb->bloom, 0, dbdb->bloom_size);
2495
2496     /* Preserve any basic ratelimit data (which is our longer-term memory)
2497     by copying it from the discarded block. */
2498
2499     if (dbd != NULL)
2500       {
2501       dbdb->dbd = *dbd;
2502       dbd = &dbdb->dbd;
2503       }
2504     }
2505   }
2506
2507 /* If we are counting unique events, find out if this event is new or not.
2508 If the client repeats the event during the current period then it should be
2509 counted. We skip this code in readonly mode for efficiency, because any
2510 changes to the filter will be discarded and because count is already set to
2511 zero. */
2512
2513 if (unique != NULL && !readonly)
2514   {
2515   /* We identify unique events using a Bloom filter. (You can find my
2516   notes on Bloom filters at http://fanf.livejournal.com/81696.html)
2517   With the per_addr option, an "event" is a recipient address, though the
2518   user can use the unique option to define their own events. We only count
2519   an event if we have not seen it before.
2520
2521   We size the filter according to the rate limit, which (in leaky mode)
2522   is the limit on the population of the filter. We allow 16 bits of space
2523   per entry (see the construction code above) and we set (up to) 8 of them
2524   when inserting an element (see the loop below). The probability of a false
2525   positive (an event we have not seen before but which we fail to count) is
2526
2527     size    = limit * 16
2528     numhash = 8
2529     allzero = exp(-numhash * pop / size)
2530             = exp(-0.5 * pop / limit)
2531     fpr     = pow(1 - allzero, numhash)
2532
2533   For senders at the limit the fpr is      0.06%    or  1 in 1700
2534   and for senders at half the limit it is  0.0006%  or  1 in 170000
2535
2536   In strict mode the Bloom filter can fill up beyond the normal limit, in
2537   which case the false positive rate will rise. This means that the
2538   measured rate for very fast senders can bogusly drop off after a while.
2539
2540   At twice the limit, the fpr is  2.5%  or  1 in 40
2541   At four times the limit, it is  31%   or  1 in 3.2
2542
2543   It takes ln(pop/limit) periods for an over-limit burst of pop events to
2544   decay below the limit, and if this is more than one then the Bloom filter
2545   will be discarded before the decay gets that far. The false positive rate
2546   at this threshold is 9.3% or 1 in 10.7. */
2547
2548   BOOL seen;
2549   unsigned n, hash, hinc;
2550   uschar md5sum[16];
2551   md5 md5info;
2552
2553   /* Instead of using eight independent hash values, we combine two values
2554   using the formula h1 + n * h2. This does not harm the Bloom filter's
2555   performance, and means the amount of hash we need is independent of the
2556   number of bits we set in the filter. */
2557
2558   md5_start(&md5info);
2559   md5_end(&md5info, unique, Ustrlen(unique), md5sum);
2560   hash = md5sum[0] | md5sum[1] << 8 | md5sum[2] << 16 | md5sum[3] << 24;
2561   hinc = md5sum[4] | md5sum[5] << 8 | md5sum[6] << 16 | md5sum[7] << 24;
2562
2563   /* Scan the bits corresponding to this event. A zero bit means we have
2564   not seen it before. Ensure all bits are set to record this event. */
2565
2566   HDEBUG(D_acl) debug_printf("ratelimit checking uniqueness of %s\n", unique);
2567
2568   seen = TRUE;
2569   for (n = 0; n < 8; n++, hash += hinc)
2570     {
2571     int bit = 1 << (hash % 8);
2572     int byte = (hash / 8) % dbdb->bloom_size;
2573     if ((dbdb->bloom[byte] & bit) == 0)
2574       {
2575       dbdb->bloom[byte] |= bit;
2576       seen = FALSE;
2577       }
2578     }
2579
2580   /* If this event has occurred before, do not count it. */
2581
2582   if (seen)
2583     {
2584     HDEBUG(D_acl) debug_printf("ratelimit event found in Bloom filter\n");
2585     count = 0.0;
2586     }
2587   else
2588     HDEBUG(D_acl) debug_printf("ratelimit event added to Bloom filter\n");
2589   }
2590
2591 /* If there was no previous ratelimit data block for this key, initialize
2592 the new one, otherwise update the block from the database. The initial rate
2593 is what would be computed by the code below for an infinite interval. */
2594
2595 if (dbd == NULL)
2596   {
2597   HDEBUG(D_acl) debug_printf("ratelimit initializing new key's rate data\n");
2598   dbd = &dbdb->dbd;
2599   dbd->time_stamp = tv.tv_sec;
2600   dbd->time_usec = tv.tv_usec;
2601   dbd->rate = count;
2602   }
2603 else
2604   {
2605   /* The smoothed rate is computed using an exponentially weighted moving
2606   average adjusted for variable sampling intervals. The standard EWMA for
2607   a fixed sampling interval is:  f'(t) = (1 - a) * f(t) + a * f'(t - 1)
2608   where f() is the measured value and f'() is the smoothed value.
2609
2610   Old data decays out of the smoothed value exponentially, such that data n
2611   samples old is multiplied by a^n. The exponential decay time constant p
2612   is defined such that data p samples old is multiplied by 1/e, which means
2613   that a = exp(-1/p). We can maintain the same time constant for a variable
2614   sampling interval i by using a = exp(-i/p).
2615
2616   The rate we are measuring is messages per period, suitable for directly
2617   comparing with the limit. The average rate between now and the previous
2618   message is period / interval, which we feed into the EWMA as the sample.
2619
2620   It turns out that the number of messages required for the smoothed rate
2621   to reach the limit when they are sent in a burst is equal to the limit.
2622   This can be seen by analysing the value of the smoothed rate after N
2623   messages sent at even intervals. Let k = (1 - a) * p/i
2624
2625     rate_1 = (1 - a) * p/i + a * rate_0
2626            = k + a * rate_0
2627     rate_2 = k + a * rate_1
2628            = k + a * k + a^2 * rate_0
2629     rate_3 = k + a * k + a^2 * k + a^3 * rate_0
2630     rate_N = rate_0 * a^N + k * SUM(x=0..N-1)(a^x)
2631            = rate_0 * a^N + k * (1 - a^N) / (1 - a)
2632            = rate_0 * a^N + p/i * (1 - a^N)
2633
2634   When N is large, a^N -> 0 so rate_N -> p/i as desired.
2635
2636     rate_N = p/i + (rate_0 - p/i) * a^N
2637     a^N = (rate_N - p/i) / (rate_0 - p/i)
2638     N * -i/p = log((rate_N - p/i) / (rate_0 - p/i))
2639     N = p/i * log((rate_0 - p/i) / (rate_N - p/i))
2640
2641   Numerical analysis of the above equation, setting the computed rate to
2642   increase from rate_0 = 0 to rate_N = limit, shows that for large sending
2643   rates, p/i, the number of messages N = limit. So limit serves as both the
2644   maximum rate measured in messages per period, and the maximum number of
2645   messages that can be sent in a fast burst. */
2646
2647   double this_time = (double)tv.tv_sec
2648                    + (double)tv.tv_usec / 1000000.0;
2649   double prev_time = (double)dbd->time_stamp
2650                    + (double)dbd->time_usec / 1000000.0;
2651
2652   /* We must avoid division by zero, and deal gracefully with the clock going
2653   backwards. If we blunder ahead when time is in reverse then the computed
2654   rate will be bogus. To be safe we clamp interval to a very small number. */
2655
2656   double interval = this_time - prev_time <= 0.0 ? 1e-9
2657                   : this_time - prev_time;
2658
2659   double i_over_p = interval / period;
2660   double a = exp(-i_over_p);
2661
2662   /* Combine the instantaneous rate (period / interval) with the previous rate
2663   using the smoothing factor a. In order to measure sized events, multiply the
2664   instantaneous rate by the count of bytes or recipients etc. */
2665
2666   dbd->time_stamp = tv.tv_sec;
2667   dbd->time_usec = tv.tv_usec;
2668   dbd->rate = (1 - a) * count / i_over_p + a * dbd->rate;
2669
2670   /* When events are very widely spaced the computed rate tends towards zero.
2671   Although this is accurate it turns out not to be useful for our purposes,
2672   especially when the first event after a long silence is the start of a spam
2673   run. A more useful model is that the rate for an isolated event should be the
2674   size of the event per the period size, ignoring the lack of events outside
2675   the current period and regardless of where the event falls in the period. So,
2676   if the interval was so long that the calculated rate is unhelpfully small, we
2677   re-intialize the rate. In the absence of higher-rate bursts, the condition
2678   below is true if the interval is greater than the period. */
2679
2680   if (dbd->rate < count) dbd->rate = count;
2681   }
2682
2683 /* Clients sending at the limit are considered to be over the limit.
2684 This matters for edge cases such as a limit of zero, when the client
2685 should be completely blocked. */
2686
2687 rc = (dbd->rate < limit)? FAIL : OK;
2688
2689 /* Update the state if the rate is low or if we are being strict. If we
2690 are in leaky mode and the sender's rate is too high, we do not update
2691 the recorded rate in order to avoid an over-aggressive sender's retry
2692 rate preventing them from getting any email through. If readonly is set,
2693 neither leaky nor strict are set, so we do not do any updates. */
2694
2695 if ((rc == FAIL && leaky) || strict)
2696   {
2697   dbfn_write(dbm, key, dbdb, dbdb_size);
2698   HDEBUG(D_acl) debug_printf("ratelimit db updated\n");
2699   }
2700 else
2701   {
2702   HDEBUG(D_acl) debug_printf("ratelimit db not updated: %s\n",
2703     readonly? "readonly mode" : "over the limit, but leaky");
2704   }
2705
2706 dbfn_close(dbm);
2707
2708 /* Store the result in the tree for future reference. */
2709
2710 t = store_get(sizeof(tree_node) + Ustrlen(key));
2711 t->data.ptr = dbd;
2712 Ustrcpy(t->name, key);
2713 (void)tree_insertnode(anchor, t);
2714
2715 /* We create the formatted version of the sender's rate very late in
2716 order to ensure that it is done using the correct storage pool. */
2717
2718 store_pool = old_pool;
2719 sender_rate = string_sprintf("%.1f", dbd->rate);
2720
2721 HDEBUG(D_acl)
2722   debug_printf("ratelimit computed rate %s\n", sender_rate);
2723
2724 return rc;
2725 }
2726
2727
2728
2729 /*************************************************
2730 *   Handle conditions/modifiers on an ACL item   *
2731 *************************************************/
2732
2733 /* Called from acl_check() below.
2734
2735 Arguments:
2736   verb         ACL verb
2737   cb           ACL condition block - if NULL, result is OK
2738   where        where called from
2739   addr         the address being checked for RCPT, or NULL
2740   level        the nesting level
2741   epp          pointer to pass back TRUE if "endpass" encountered
2742                  (applies only to "accept" and "discard")
2743   user_msgptr  user message pointer
2744   log_msgptr   log message pointer
2745   basic_errno  pointer to where to put verify error
2746
2747 Returns:       OK        - all conditions are met
2748                DISCARD   - an "acl" condition returned DISCARD - only allowed
2749                              for "accept" or "discard" verbs
2750                FAIL      - at least one condition fails
2751                FAIL_DROP - an "acl" condition returned FAIL_DROP
2752                DEFER     - can't tell at the moment (typically, lookup defer,
2753                              but can be temporary callout problem)
2754                ERROR     - ERROR from nested ACL or expansion failure or other
2755                              error
2756 */
2757
2758 static int
2759 acl_check_condition(int verb, acl_condition_block *cb, int where,
2760   address_item *addr, int level, BOOL *epp, uschar **user_msgptr,
2761   uschar **log_msgptr, int *basic_errno)
2762 {
2763 uschar *user_message = NULL;
2764 uschar *log_message = NULL;
2765 uschar *debug_tag = NULL;
2766 uschar *debug_opts = NULL;
2767 uschar *p = NULL;
2768 int rc = OK;
2769 #ifdef WITH_CONTENT_SCAN
2770 int sep = '/';
2771 #endif
2772
2773 for (; cb != NULL; cb = cb->next)
2774   {
2775   uschar *arg;
2776   int control_type;
2777
2778   /* The message and log_message items set up messages to be used in
2779   case of rejection. They are expanded later. */
2780
2781   if (cb->type == ACLC_MESSAGE)
2782     {
2783     user_message = cb->arg;
2784     continue;
2785     }
2786
2787   if (cb->type == ACLC_LOG_MESSAGE)
2788     {
2789     log_message = cb->arg;
2790     continue;
2791     }
2792
2793   /* The endpass "condition" just sets a flag to show it occurred. This is
2794   checked at compile time to be on an "accept" or "discard" item. */
2795
2796   if (cb->type == ACLC_ENDPASS)
2797     {
2798     *epp = TRUE;
2799     continue;
2800     }
2801
2802   /* For other conditions and modifiers, the argument is expanded now for some
2803   of them, but not for all, because expansion happens down in some lower level
2804   checking functions in some cases. */
2805
2806   if (cond_expand_at_top[cb->type])
2807     {
2808     arg = expand_string(cb->arg);
2809     if (arg == NULL)
2810       {
2811       if (expand_string_forcedfail) continue;
2812       *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
2813         cb->arg, expand_string_message);
2814       return search_find_defer? DEFER : ERROR;
2815       }
2816     }
2817   else arg = cb->arg;
2818
2819   /* Show condition, and expanded condition if it's different */
2820
2821   HDEBUG(D_acl)
2822     {
2823     int lhswidth = 0;
2824     debug_printf("check %s%s %n",
2825       (!cond_modifiers[cb->type] && cb->u.negated)? "!":"",
2826       conditions[cb->type], &lhswidth);
2827
2828     if (cb->type == ACLC_SET)
2829       {
2830       debug_printf("acl_%s ", cb->u.varname);
2831       lhswidth += 5 + Ustrlen(cb->u.varname);
2832       }
2833
2834     debug_printf("= %s\n", cb->arg);
2835
2836     if (arg != cb->arg)
2837       debug_printf("%.*s= %s\n", lhswidth,
2838       US"                             ", CS arg);
2839     }
2840
2841   /* Check that this condition makes sense at this time */
2842
2843   if ((cond_forbids[cb->type] & (1 << where)) != 0)
2844     {
2845     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
2846       cond_modifiers[cb->type]? "use" : "test",
2847       conditions[cb->type], acl_wherenames[where]);
2848     return ERROR;
2849     }
2850
2851   /* Run the appropriate test for each condition, or take the appropriate
2852   action for the remaining modifiers. */
2853
2854   switch(cb->type)
2855     {
2856     case ACLC_ADD_HEADER:
2857     setup_header(arg);
2858     break;
2859
2860     /* A nested ACL that returns "discard" makes sense only for an "accept" or
2861     "discard" verb. */
2862
2863     case ACLC_ACL:
2864       rc = acl_check_wargs(where, addr, arg, level+1, user_msgptr, log_msgptr);
2865       if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
2866         {
2867         *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
2868           "\"%s\" command (only allowed with \"accept\" or \"discard\")",
2869           verbs[verb]);
2870         return ERROR;
2871         }
2872     break;
2873
2874     case ACLC_AUTHENTICATED:
2875     rc = (sender_host_authenticated == NULL)? FAIL :
2876       match_isinlist(sender_host_authenticated, &arg, 0, NULL, NULL, MCL_STRING,
2877         TRUE, NULL);
2878     break;
2879
2880     #ifdef EXPERIMENTAL_BRIGHTMAIL
2881     case ACLC_BMI_OPTIN:
2882       {
2883       int old_pool = store_pool;
2884       store_pool = POOL_PERM;
2885       bmi_current_optin = string_copy(arg);
2886       store_pool = old_pool;
2887       }
2888     break;
2889     #endif
2890
2891     case ACLC_CONDITION:
2892     /* The true/false parsing here should be kept in sync with that used in
2893     expand.c when dealing with ECOND_BOOL so that we don't have too many
2894     different definitions of what can be a boolean. */
2895     if (Ustrspn(arg, "0123456789") == Ustrlen(arg))     /* Digits, or empty */
2896       rc = (Uatoi(arg) == 0)? FAIL : OK;
2897     else
2898       rc = (strcmpic(arg, US"no") == 0 ||
2899             strcmpic(arg, US"false") == 0)? FAIL :
2900            (strcmpic(arg, US"yes") == 0 ||
2901             strcmpic(arg, US"true") == 0)? OK : DEFER;
2902     if (rc == DEFER)
2903       *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
2904     break;
2905
2906     case ACLC_CONTINUE:    /* Always succeeds */
2907     break;
2908
2909     case ACLC_CONTROL:
2910     control_type = decode_control(arg, &p, where, log_msgptr);
2911
2912     /* Check if this control makes sense at this time */
2913
2914     if ((control_forbids[control_type] & (1 << where)) != 0)
2915       {
2916       *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
2917         controls[control_type], acl_wherenames[where]);
2918       return ERROR;
2919       }
2920
2921     switch(control_type)
2922       {
2923       case CONTROL_AUTH_UNADVERTISED:
2924       allow_auth_unadvertised = TRUE;
2925       break;
2926
2927       #ifdef EXPERIMENTAL_BRIGHTMAIL
2928       case CONTROL_BMI_RUN:
2929       bmi_run = 1;
2930       break;
2931       #endif
2932
2933       #ifndef DISABLE_DKIM
2934       case CONTROL_DKIM_VERIFY:
2935       dkim_disable_verify = TRUE;
2936       break;
2937       #endif
2938
2939       case CONTROL_DSCP:
2940       if (*p == '/')
2941         {
2942         int fd, af, level, optname, value;
2943         /* If we are acting on stdin, the setsockopt may fail if stdin is not
2944         a socket; we can accept that, we'll just debug-log failures anyway. */
2945         fd = fileno(smtp_in);
2946         af = ip_get_address_family(fd);
2947         if (af < 0)
2948           {
2949           HDEBUG(D_acl)
2950             debug_printf("smtp input is probably not a socket [%s], not setting DSCP\n",
2951                 strerror(errno));
2952           break;
2953           }
2954         if (dscp_lookup(p+1, af, &level, &optname, &value))
2955           {
2956           if (setsockopt(fd, level, optname, &value, sizeof(value)) < 0)
2957             {
2958             HDEBUG(D_acl) debug_printf("failed to set input DSCP[%s]: %s\n",
2959                 p+1, strerror(errno));
2960             }
2961           else
2962             {
2963             HDEBUG(D_acl) debug_printf("set input DSCP to \"%s\"\n", p+1);
2964             }
2965           }
2966         else
2967           {
2968           *log_msgptr = string_sprintf("unrecognised DSCP value in \"control=%s\"", arg);
2969           return ERROR;
2970           }
2971         }
2972       else
2973         {
2974         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
2975         return ERROR;
2976         }
2977       break;
2978
2979       case CONTROL_ERROR:
2980       return ERROR;
2981
2982       case CONTROL_CASEFUL_LOCAL_PART:
2983       deliver_localpart = addr->cc_local_part;
2984       break;
2985
2986       case CONTROL_CASELOWER_LOCAL_PART:
2987       deliver_localpart = addr->lc_local_part;
2988       break;
2989
2990       case CONTROL_ENFORCE_SYNC:
2991       smtp_enforce_sync = TRUE;
2992       break;
2993
2994       case CONTROL_NO_ENFORCE_SYNC:
2995       smtp_enforce_sync = FALSE;
2996       break;
2997
2998       #ifdef WITH_CONTENT_SCAN
2999       case CONTROL_NO_MBOX_UNSPOOL:
3000       no_mbox_unspool = TRUE;
3001       break;
3002       #endif
3003
3004       case CONTROL_NO_MULTILINE:
3005       no_multiline_responses = TRUE;
3006       break;
3007
3008       case CONTROL_NO_PIPELINING:
3009       pipelining_enable = FALSE;
3010       break;
3011
3012       case CONTROL_NO_DELAY_FLUSH:
3013       disable_delay_flush = TRUE;
3014       break;
3015
3016       case CONTROL_NO_CALLOUT_FLUSH:
3017       disable_callout_flush = TRUE;
3018       break;
3019
3020       case CONTROL_FAKEDEFER:
3021       case CONTROL_FAKEREJECT:
3022       fake_response = (control_type == CONTROL_FAKEDEFER) ? DEFER : FAIL;
3023       if (*p == '/')
3024         {
3025         uschar *pp = p + 1;
3026         while (*pp != 0) pp++;
3027         fake_response_text = expand_string(string_copyn(p+1, pp-p-1));
3028         p = pp;
3029         }
3030        else
3031         {
3032         /* Explicitly reset to default string */
3033         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).";
3034         }
3035       break;
3036
3037       case CONTROL_FREEZE:
3038       deliver_freeze = TRUE;
3039       deliver_frozen_at = time(NULL);
3040       freeze_tell = freeze_tell_config;       /* Reset to configured value */
3041       if (Ustrncmp(p, "/no_tell", 8) == 0)
3042         {
3043         p += 8;
3044         freeze_tell = NULL;
3045         }
3046       if (*p != 0)
3047         {
3048         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3049         return ERROR;
3050         }
3051       break;
3052
3053       case CONTROL_QUEUE_ONLY:
3054       queue_only_policy = TRUE;
3055       break;
3056
3057       case CONTROL_SUBMISSION:
3058       originator_name = US"";
3059       submission_mode = TRUE;
3060       while (*p == '/')
3061         {
3062         if (Ustrncmp(p, "/sender_retain", 14) == 0)
3063           {
3064           p += 14;
3065           active_local_sender_retain = TRUE;
3066           active_local_from_check = FALSE;
3067           }
3068         else if (Ustrncmp(p, "/domain=", 8) == 0)
3069           {
3070           uschar *pp = p + 8;
3071           while (*pp != 0 && *pp != '/') pp++;
3072           submission_domain = string_copyn(p+8, pp-p-8);
3073           p = pp;
3074           }
3075         /* The name= option must be last, because it swallows the rest of
3076         the string. */
3077         else if (Ustrncmp(p, "/name=", 6) == 0)
3078           {
3079           uschar *pp = p + 6;
3080           while (*pp != 0) pp++;
3081           submission_name = string_copy(parse_fix_phrase(p+6, pp-p-6,
3082             big_buffer, big_buffer_size));
3083           p = pp;
3084           }
3085         else break;
3086         }
3087       if (*p != 0)
3088         {
3089         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3090         return ERROR;
3091         }
3092       break;
3093
3094       case CONTROL_DEBUG:
3095       while (*p == '/')
3096         {
3097         if (Ustrncmp(p, "/tag=", 5) == 0)
3098           {
3099           uschar *pp = p + 5;
3100           while (*pp != '\0' && *pp != '/') pp++;
3101           debug_tag = string_copyn(p+5, pp-p-5);
3102           p = pp;
3103           }
3104         else if (Ustrncmp(p, "/opts=", 6) == 0)
3105           {
3106           uschar *pp = p + 6;
3107           while (*pp != '\0' && *pp != '/') pp++;
3108           debug_opts = string_copyn(p+6, pp-p-6);
3109           p = pp;
3110           }
3111         }
3112         debug_logging_activate(debug_tag, debug_opts);
3113       break;
3114
3115       case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3116       suppress_local_fixups = TRUE;
3117       break;
3118
3119       case CONTROL_CUTTHROUGH_DELIVERY:
3120       if (deliver_freeze)
3121         {
3122         *log_msgptr = string_sprintf("\"control=%s\" on frozen item", arg);
3123         return ERROR;
3124         }
3125        if (queue_only_policy)
3126         {
3127         *log_msgptr = string_sprintf("\"control=%s\" on queue-only item", arg);
3128         return ERROR;
3129         }
3130       cutthrough_delivery = TRUE;
3131       break;
3132       }
3133     break;
3134
3135     #ifdef EXPERIMENTAL_DCC
3136     case ACLC_DCC:
3137       {
3138       /* Seperate the regular expression and any optional parameters. */
3139       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
3140       /* Run the dcc backend. */
3141       rc = dcc_process(&ss);
3142       /* Modify return code based upon the existance of options. */
3143       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
3144             != NULL) {
3145         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3146           {
3147           /* FAIL so that the message is passed to the next ACL */
3148           rc = FAIL;
3149           }
3150         }
3151       }
3152     break;
3153     #endif
3154
3155     #ifdef WITH_CONTENT_SCAN
3156     case ACLC_DECODE:
3157     rc = mime_decode(&arg);
3158     break;
3159     #endif
3160
3161     case ACLC_DELAY:
3162       {
3163       int delay = readconf_readtime(arg, 0, FALSE);
3164       if (delay < 0)
3165         {
3166         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3167           "modifier: \"%s\" is not a time value", arg);
3168         return ERROR;
3169         }
3170       else
3171         {
3172         HDEBUG(D_acl) debug_printf("delay modifier requests %d-second delay\n",
3173           delay);
3174         if (host_checking)
3175           {
3176           HDEBUG(D_acl)
3177             debug_printf("delay skipped in -bh checking mode\n");
3178           }
3179
3180         /* It appears to be impossible to detect that a TCP/IP connection has
3181         gone away without reading from it. This means that we cannot shorten
3182         the delay below if the client goes away, because we cannot discover
3183         that the client has closed its end of the connection. (The connection
3184         is actually in a half-closed state, waiting for the server to close its
3185         end.) It would be nice to be able to detect this state, so that the
3186         Exim process is not held up unnecessarily. However, it seems that we
3187         can't. The poll() function does not do the right thing, and in any case
3188         it is not always available.
3189
3190         NOTE 1: If ever this state of affairs changes, remember that we may be
3191         dealing with stdin/stdout here, in addition to TCP/IP connections.
3192         Also, delays may be specified for non-SMTP input, where smtp_out and
3193         smtp_in will be NULL. Whatever is done must work in all cases.
3194
3195         NOTE 2: The added feature of flushing the output before a delay must
3196         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3197         */
3198
3199         else
3200           {
3201           if (smtp_out != NULL && !disable_delay_flush) mac_smtp_fflush();
3202           while (delay > 0) delay = sleep(delay);
3203           }
3204         }
3205       }
3206     break;
3207
3208     #ifdef WITH_OLD_DEMIME
3209     case ACLC_DEMIME:
3210       rc = demime(&arg);
3211     break;
3212     #endif
3213
3214     #ifndef DISABLE_DKIM
3215     case ACLC_DKIM_SIGNER:
3216     if (dkim_cur_signer != NULL)
3217       rc = match_isinlist(dkim_cur_signer,
3218                           &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3219     else
3220        rc = FAIL;
3221     break;
3222
3223     case ACLC_DKIM_STATUS:
3224     rc = match_isinlist(dkim_exim_expand_query(DKIM_VERIFY_STATUS),
3225                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3226     break;
3227     #endif
3228
3229     case ACLC_DNSLISTS:
3230     rc = verify_check_dnsbl(&arg);
3231     break;
3232
3233     case ACLC_DOMAINS:
3234     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3235       addr->domain_cache, MCL_DOMAIN, TRUE, &deliver_domain_data);
3236     break;
3237
3238     /* The value in tls_cipher is the full cipher name, for example,
3239     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3240     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3241     what may in practice come out of the SSL library - which at the time of
3242     writing is poorly documented. */
3243
3244     case ACLC_ENCRYPTED:
3245     if (tls_in.cipher == NULL) rc = FAIL; else
3246       {
3247       uschar *endcipher = NULL;
3248       uschar *cipher = Ustrchr(tls_in.cipher, ':');
3249       if (cipher == NULL) cipher = tls_in.cipher; else
3250         {
3251         endcipher = Ustrchr(++cipher, ':');
3252         if (endcipher != NULL) *endcipher = 0;
3253         }
3254       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3255       if (endcipher != NULL) *endcipher = ':';
3256       }
3257     break;
3258
3259     /* Use verify_check_this_host() instead of verify_check_host() so that
3260     we can pass over &host_data to catch any looked up data. Once it has been
3261     set, it retains its value so that it's still there if another ACL verb
3262     comes through here and uses the cache. However, we must put it into
3263     permanent store in case it is also expected to be used in a subsequent
3264     message in the same SMTP connection. */
3265
3266     case ACLC_HOSTS:
3267     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3268       (sender_host_address == NULL)? US"" : sender_host_address, &host_data);
3269     if (host_data != NULL) host_data = string_copy_malloc(host_data);
3270     break;
3271
3272     case ACLC_LOCAL_PARTS:
3273     rc = match_isinlist(addr->cc_local_part, &arg, 0,
3274       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3275       &deliver_localpart_data);
3276     break;
3277
3278     case ACLC_LOG_REJECT_TARGET:
3279       {
3280       int logbits = 0;
3281       int sep = 0;
3282       uschar *s = arg;
3283       uschar *ss;
3284       while ((ss = string_nextinlist(&s, &sep, big_buffer, big_buffer_size))
3285               != NULL)
3286         {
3287         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3288         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3289         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3290         else
3291           {
3292           logbits |= LOG_MAIN|LOG_REJECT;
3293           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3294             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3295           }
3296         }
3297       log_reject_target = logbits;
3298       }
3299     break;
3300
3301     case ACLC_LOGWRITE:
3302       {
3303       int logbits = 0;
3304       uschar *s = arg;
3305       if (*s == ':')
3306         {
3307         s++;
3308         while (*s != ':')
3309           {
3310           if (Ustrncmp(s, "main", 4) == 0)
3311             { logbits |= LOG_MAIN; s += 4; }
3312           else if (Ustrncmp(s, "panic", 5) == 0)
3313             { logbits |= LOG_PANIC; s += 5; }
3314           else if (Ustrncmp(s, "reject", 6) == 0)
3315             { logbits |= LOG_REJECT; s += 6; }
3316           else
3317             {
3318             logbits = LOG_MAIN|LOG_PANIC;
3319             s = string_sprintf(":unknown log name in \"%s\" in "
3320               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3321             }
3322           if (*s == ',') s++;
3323           }
3324         s++;
3325         }
3326       while (isspace(*s)) s++;
3327
3328
3329       if (logbits == 0) logbits = LOG_MAIN;
3330       log_write(0, logbits, "%s", string_printing(s));
3331       }
3332     break;
3333
3334     #ifdef WITH_CONTENT_SCAN
3335     case ACLC_MALWARE:
3336       {
3337       /* Separate the regular expression and any optional parameters. */
3338       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
3339       /* Run the malware backend. */
3340       rc = malware(&ss);
3341       /* Modify return code based upon the existance of options. */
3342       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
3343             != NULL) {
3344         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3345           {
3346           /* FAIL so that the message is passed to the next ACL */
3347           rc = FAIL;
3348           }
3349         }
3350       }
3351     break;
3352
3353     case ACLC_MIME_REGEX:
3354     rc = mime_regex(&arg);
3355     break;
3356     #endif
3357
3358     case ACLC_RATELIMIT:
3359     rc = acl_ratelimit(arg, where, log_msgptr);
3360     break;
3361
3362     case ACLC_RECIPIENTS:
3363     rc = match_address_list(addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3364       &recipient_data);
3365     break;
3366
3367     #ifdef WITH_CONTENT_SCAN
3368     case ACLC_REGEX:
3369     rc = regex(&arg);
3370     break;
3371     #endif
3372
3373     case ACLC_REMOVE_HEADER:
3374     setup_remove_header(arg);
3375     break;
3376
3377     case ACLC_SENDER_DOMAINS:
3378       {
3379       uschar *sdomain;
3380       sdomain = Ustrrchr(sender_address, '@');
3381       sdomain = (sdomain == NULL)? US"" : sdomain + 1;
3382       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3383         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3384       }
3385     break;
3386
3387     case ACLC_SENDERS:
3388     rc = match_address_list(sender_address, TRUE, TRUE, &arg,
3389       sender_address_cache, -1, 0, &sender_data);
3390     break;
3391
3392     /* Connection variables must persist forever */
3393
3394     case ACLC_SET:
3395       {
3396       int old_pool = store_pool;
3397       if (cb->u.varname[0] == 'c') store_pool = POOL_PERM;
3398       acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
3399       store_pool = old_pool;
3400       }
3401     break;
3402
3403     #ifdef WITH_CONTENT_SCAN
3404     case ACLC_SPAM:
3405       {
3406       /* Seperate the regular expression and any optional parameters. */
3407       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
3408       /* Run the spam backend. */
3409       rc = spam(&ss);
3410       /* Modify return code based upon the existance of options. */
3411       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
3412             != NULL) {
3413         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3414           {
3415           /* FAIL so that the message is passed to the next ACL */
3416           rc = FAIL;
3417           }
3418         }
3419       }
3420     break;
3421     #endif
3422
3423     #ifdef EXPERIMENTAL_SPF
3424     case ACLC_SPF:
3425       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
3426     break;
3427     case ACLC_SPF_GUESS:
3428       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
3429     break;
3430     #endif
3431
3432     /* If the verb is WARN, discard any user message from verification, because
3433     such messages are SMTP responses, not header additions. The latter come
3434     only from explicit "message" modifiers. However, put the user message into
3435     $acl_verify_message so it can be used in subsequent conditions or modifiers
3436     (until something changes it). */
3437
3438     case ACLC_VERIFY:
3439     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
3440     acl_verify_message = *user_msgptr;
3441     if (verb == ACL_WARN) *user_msgptr = NULL;
3442     break;
3443
3444     default:
3445     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
3446       "condition %d", cb->type);
3447     break;
3448     }
3449
3450   /* If a condition was negated, invert OK/FAIL. */
3451
3452   if (!cond_modifiers[cb->type] && cb->u.negated)
3453     {
3454     if (rc == OK) rc = FAIL;
3455       else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
3456     }
3457
3458   if (rc != OK) break;   /* Conditions loop */
3459   }
3460
3461
3462 /* If the result is the one for which "message" and/or "log_message" are used,
3463 handle the values of these modifiers. If there isn't a log message set, we make
3464 it the same as the user message.
3465
3466 "message" is a user message that will be included in an SMTP response. Unless
3467 it is empty, it overrides any previously set user message.
3468
3469 "log_message" is a non-user message, and it adds to any existing non-user
3470 message that is already set.
3471
3472 Most verbs have but a single return for which the messages are relevant, but
3473 for "discard", it's useful to have the log message both when it succeeds and
3474 when it fails. For "accept", the message is used in the OK case if there is no
3475 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
3476 present. */
3477
3478 if (*epp && rc == OK) user_message = NULL;
3479
3480 if (((1<<rc) & msgcond[verb]) != 0)
3481   {
3482   uschar *expmessage;
3483   uschar *old_user_msgptr = *user_msgptr;
3484   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
3485
3486   /* If the verb is "warn", messages generated by conditions (verification or
3487   nested ACLs) are always discarded. This also happens for acceptance verbs
3488   when they actually do accept. Only messages specified at this level are used.
3489   However, the value of an existing message is available in $acl_verify_message
3490   during expansions. */
3491
3492   if (verb == ACL_WARN ||
3493       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
3494     *log_msgptr = *user_msgptr = NULL;
3495
3496   if (user_message != NULL)
3497     {
3498     acl_verify_message = old_user_msgptr;
3499     expmessage = expand_string(user_message);
3500     if (expmessage == NULL)
3501       {
3502       if (!expand_string_forcedfail)
3503         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3504           user_message, expand_string_message);
3505       }
3506     else if (expmessage[0] != 0) *user_msgptr = expmessage;
3507     }
3508
3509   if (log_message != NULL)
3510     {
3511     acl_verify_message = old_log_msgptr;
3512     expmessage = expand_string(log_message);
3513     if (expmessage == NULL)
3514       {
3515       if (!expand_string_forcedfail)
3516         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3517           log_message, expand_string_message);
3518       }
3519     else if (expmessage[0] != 0)
3520       {
3521       *log_msgptr = (*log_msgptr == NULL)? expmessage :
3522         string_sprintf("%s: %s", expmessage, *log_msgptr);
3523       }
3524     }
3525
3526   /* If no log message, default it to the user message */
3527
3528   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
3529   }
3530
3531 acl_verify_message = NULL;
3532 return rc;
3533 }
3534
3535
3536
3537
3538
3539 /*************************************************
3540 *        Get line from a literal ACL             *
3541 *************************************************/
3542
3543 /* This function is passed to acl_read() in order to extract individual lines
3544 of a literal ACL, which we access via static pointers. We can destroy the
3545 contents because this is called only once (the compiled ACL is remembered).
3546
3547 This code is intended to treat the data in the same way as lines in the main
3548 Exim configuration file. That is:
3549
3550   . Leading spaces are ignored.
3551
3552   . A \ at the end of a line is a continuation - trailing spaces after the \
3553     are permitted (this is because I don't believe in making invisible things
3554     significant). Leading spaces on the continued part of a line are ignored.
3555
3556   . Physical lines starting (significantly) with # are totally ignored, and
3557     may appear within a sequence of backslash-continued lines.
3558
3559   . Blank lines are ignored, but will end a sequence of continuations.
3560
3561 Arguments: none
3562 Returns:   a pointer to the next line
3563 */
3564
3565
3566 static uschar *acl_text;          /* Current pointer in the text */
3567 static uschar *acl_text_end;      /* Points one past the terminating '0' */
3568
3569
3570 static uschar *
3571 acl_getline(void)
3572 {
3573 uschar *yield;
3574
3575 /* This loop handles leading blank lines and comments. */
3576
3577 for(;;)
3578   {
3579   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
3580   if (*acl_text == 0) return NULL;         /* No more data */
3581   yield = acl_text;                        /* Potential data line */
3582
3583   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3584
3585   /* If we hit the end before a newline, we have the whole logical line. If
3586   it's a comment, there's no more data to be given. Otherwise, yield it. */
3587
3588   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
3589
3590   /* After reaching a newline, end this loop if the physical line does not
3591   start with '#'. If it does, it's a comment, and the loop continues. */
3592
3593   if (*yield != '#') break;
3594   }
3595
3596 /* This loop handles continuations. We know we have some real data, ending in
3597 newline. See if there is a continuation marker at the end (ignoring trailing
3598 white space). We know that *yield is not white space, so no need to test for
3599 cont > yield in the backwards scanning loop. */
3600
3601 for(;;)
3602   {
3603   uschar *cont;
3604   for (cont = acl_text - 1; isspace(*cont); cont--);
3605
3606   /* If no continuation follows, we are done. Mark the end of the line and
3607   return it. */
3608
3609   if (*cont != '\\')
3610     {
3611     *acl_text++ = 0;
3612     return yield;
3613     }
3614
3615   /* We have encountered a continuation. Skip over whitespace at the start of
3616   the next line, and indeed the whole of the next line or lines if they are
3617   comment lines. */
3618
3619   for (;;)
3620     {
3621     while (*(++acl_text) == ' ' || *acl_text == '\t');
3622     if (*acl_text != '#') break;
3623     while (*(++acl_text) != 0 && *acl_text != '\n');
3624     }
3625
3626   /* We have the start of a continuation line. Move all the rest of the data
3627   to join onto the previous line, and then find its end. If the end is not a
3628   newline, we are done. Otherwise loop to look for another continuation. */
3629
3630   memmove(cont, acl_text, acl_text_end - acl_text);
3631   acl_text_end -= acl_text - cont;
3632   acl_text = cont;
3633   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3634   if (*acl_text == 0) return yield;
3635   }
3636
3637 /* Control does not reach here */
3638 }
3639
3640
3641
3642
3643
3644 /*************************************************
3645 *        Check access using an ACL               *
3646 *************************************************/
3647
3648 /* This function is called from address_check. It may recurse via
3649 acl_check_condition() - hence the use of a level to stop looping. The ACL is
3650 passed as a string which is expanded. A forced failure implies no access check
3651 is required. If the result is a single word, it is taken as the name of an ACL
3652 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
3653 text, complete with newlines, and parsed as such. In both cases, the ACL check
3654 is then run. This function uses an auxiliary function for acl_read() to call
3655 for reading individual lines of a literal ACL. This is acl_getline(), which
3656 appears immediately above.
3657
3658 Arguments:
3659   where        where called from
3660   addr         address item when called from RCPT; otherwise NULL
3661   s            the input string; NULL is the same as an empty ACL => DENY
3662   level        the nesting level
3663   user_msgptr  where to put a user error (for SMTP response)
3664   log_msgptr   where to put a logging message (not for SMTP response)
3665
3666 Returns:       OK         access is granted
3667                DISCARD    access is apparently granted...
3668                FAIL       access is denied
3669                FAIL_DROP  access is denied; drop the connection
3670                DEFER      can't tell at the moment
3671                ERROR      disaster
3672 */
3673
3674 static int
3675 acl_check_internal(int where, address_item *addr, uschar *s, int level,
3676   uschar **user_msgptr, uschar **log_msgptr)
3677 {
3678 int fd = -1;
3679 acl_block *acl = NULL;
3680 uschar *acl_name = US"inline ACL";
3681 uschar *ss;
3682
3683 /* Catch configuration loops */
3684
3685 if (level > 20)
3686   {
3687   *log_msgptr = US"ACL nested too deep: possible loop";
3688   return ERROR;
3689   }
3690
3691 if (s == NULL)
3692   {
3693   HDEBUG(D_acl) debug_printf("ACL is NULL: implicit DENY\n");
3694   return FAIL;
3695   }
3696
3697 /* At top level, we expand the incoming string. At lower levels, it has already
3698 been expanded as part of condition processing. */
3699
3700 if (level == 0)
3701   {
3702   ss = expand_string(s);
3703   if (ss == NULL)
3704     {
3705     if (expand_string_forcedfail) return OK;
3706     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
3707       expand_string_message);
3708     return ERROR;
3709     }
3710   }
3711 else ss = s;
3712
3713 while (isspace(*ss))ss++;
3714
3715 /* If we can't find a named ACL, the default is to parse it as an inline one.
3716 (Unless it begins with a slash; non-existent files give rise to an error.) */
3717
3718 acl_text = ss;
3719
3720 /* Handle the case of a string that does not contain any spaces. Look for a
3721 named ACL among those read from the configuration, or a previously read file.
3722 It is possible that the pointer to the ACL is NULL if the configuration
3723 contains a name with no data. If not found, and the text begins with '/',
3724 read an ACL from a file, and save it so it can be re-used. */
3725
3726 if (Ustrchr(ss, ' ') == NULL)
3727   {
3728   tree_node *t = tree_search(acl_anchor, ss);
3729   if (t != NULL)
3730     {
3731     acl = (acl_block *)(t->data.ptr);
3732     if (acl == NULL)
3733       {
3734       HDEBUG(D_acl) debug_printf("ACL \"%s\" is empty: implicit DENY\n", ss);
3735       return FAIL;
3736       }
3737     acl_name = string_sprintf("ACL \"%s\"", ss);
3738     HDEBUG(D_acl) debug_printf("using ACL \"%s\"\n", ss);
3739     }
3740
3741   else if (*ss == '/')
3742     {
3743     struct stat statbuf;
3744     fd = Uopen(ss, O_RDONLY, 0);
3745     if (fd < 0)
3746       {
3747       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
3748         strerror(errno));
3749       return ERROR;
3750       }
3751
3752     if (fstat(fd, &statbuf) != 0)
3753       {
3754       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
3755         strerror(errno));
3756       return ERROR;
3757       }
3758
3759     acl_text = store_get(statbuf.st_size + 1);
3760     acl_text_end = acl_text + statbuf.st_size + 1;
3761
3762     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
3763       {
3764       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
3765         ss, strerror(errno));
3766       return ERROR;
3767       }
3768     acl_text[statbuf.st_size] = 0;
3769     (void)close(fd);
3770
3771     acl_name = string_sprintf("ACL \"%s\"", ss);
3772     HDEBUG(D_acl) debug_printf("read ACL from file %s\n", ss);
3773     }
3774   }
3775
3776 /* Parse an ACL that is still in text form. If it came from a file, remember it
3777 in the ACL tree, having read it into the POOL_PERM store pool so that it
3778 persists between multiple messages. */
3779
3780 if (acl == NULL)
3781   {
3782   int old_pool = store_pool;
3783   if (fd >= 0) store_pool = POOL_PERM;
3784   acl = acl_read(acl_getline, log_msgptr);
3785   store_pool = old_pool;
3786   if (acl == NULL && *log_msgptr != NULL) return ERROR;
3787   if (fd >= 0)
3788     {
3789     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
3790     Ustrcpy(t->name, ss);
3791     t->data.ptr = acl;
3792     (void)tree_insertnode(&acl_anchor, t);
3793     }
3794   }
3795
3796 /* Now we have an ACL to use. It's possible it may be NULL. */
3797
3798 while (acl != NULL)
3799   {
3800   int cond;
3801   int basic_errno = 0;
3802   BOOL endpass_seen = FALSE;
3803
3804   *log_msgptr = *user_msgptr = NULL;
3805   acl_temp_details = FALSE;
3806
3807   if ((where == ACL_WHERE_QUIT || where == ACL_WHERE_NOTQUIT) &&
3808       acl->verb != ACL_ACCEPT &&
3809       acl->verb != ACL_WARN)
3810     {
3811     *log_msgptr = string_sprintf("\"%s\" is not allowed in a QUIT or not-QUIT ACL",
3812       verbs[acl->verb]);
3813     return ERROR;
3814     }
3815
3816   HDEBUG(D_acl) debug_printf("processing \"%s\"\n", verbs[acl->verb]);
3817
3818   /* Clear out any search error message from a previous check before testing
3819   this condition. */
3820
3821   search_error_message = NULL;
3822   cond = acl_check_condition(acl->verb, acl->condition, where, addr, level,
3823     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
3824
3825   /* Handle special returns: DEFER causes a return except on a WARN verb;
3826   ERROR always causes a return. */
3827
3828   switch (cond)
3829     {
3830     case DEFER:
3831     HDEBUG(D_acl) debug_printf("%s: condition test deferred in %s\n", verbs[acl->verb], acl_name);
3832     if (basic_errno != ERRNO_CALLOUTDEFER)
3833       {
3834       if (search_error_message != NULL && *search_error_message != 0)
3835         *log_msgptr = search_error_message;
3836       if (smtp_return_error_details) acl_temp_details = TRUE;
3837       }
3838     else
3839       {
3840       acl_temp_details = TRUE;
3841       }
3842     if (acl->verb != ACL_WARN) return DEFER;
3843     break;
3844
3845     default:      /* Paranoia */
3846     case ERROR:
3847     HDEBUG(D_acl) debug_printf("%s: condition test error in %s\n", verbs[acl->verb], acl_name);
3848     return ERROR;
3849
3850     case OK:
3851     HDEBUG(D_acl) debug_printf("%s: condition test succeeded in %s\n",
3852       verbs[acl->verb], acl_name);
3853     break;
3854
3855     case FAIL:
3856     HDEBUG(D_acl) debug_printf("%s: condition test failed in %s\n", verbs[acl->verb], acl_name);
3857     break;
3858
3859     /* DISCARD and DROP can happen only from a nested ACL condition, and
3860     DISCARD can happen only for an "accept" or "discard" verb. */
3861
3862     case DISCARD:
3863     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"discard\" in %s\n",
3864       verbs[acl->verb], acl_name);
3865     break;
3866
3867     case FAIL_DROP:
3868     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"drop\" in %s\n",
3869       verbs[acl->verb], acl_name);
3870     break;
3871     }
3872
3873   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
3874   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
3875   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
3876
3877   switch(acl->verb)
3878     {
3879     case ACL_ACCEPT:
3880     if (cond == OK || cond == DISCARD) return cond;
3881     if (endpass_seen)
3882       {
3883       HDEBUG(D_acl) debug_printf("accept: endpass encountered - denying access\n");
3884       return cond;
3885       }
3886     break;
3887
3888     case ACL_DEFER:
3889     if (cond == OK)
3890       {
3891       acl_temp_details = TRUE;
3892       return DEFER;
3893       }
3894     break;
3895
3896     case ACL_DENY:
3897     if (cond == OK) return FAIL;
3898     break;
3899
3900     case ACL_DISCARD:
3901     if (cond == OK || cond == DISCARD) return DISCARD;
3902     if (endpass_seen)
3903       {
3904       HDEBUG(D_acl) debug_printf("discard: endpass encountered - denying access\n");
3905       return cond;
3906       }
3907     break;
3908
3909     case ACL_DROP:
3910     if (cond == OK) return FAIL_DROP;
3911     break;
3912
3913     case ACL_REQUIRE:
3914     if (cond != OK) return cond;
3915     break;
3916
3917     case ACL_WARN:
3918     if (cond == OK)
3919       acl_warn(where, *user_msgptr, *log_msgptr);
3920     else if (cond == DEFER && (log_extra_selector & LX_acl_warn_skipped) != 0)
3921       log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
3922         "condition test deferred%s%s", host_and_ident(TRUE),
3923         (*log_msgptr == NULL)? US"" : US": ",
3924         (*log_msgptr == NULL)? US"" : *log_msgptr);
3925     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
3926     break;
3927
3928     default:
3929     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
3930       acl->verb);
3931     break;
3932     }
3933
3934   /* Pass to the next ACL item */
3935
3936   acl = acl->next;
3937   }
3938
3939 /* We have reached the end of the ACL. This is an implicit DENY. */
3940
3941 HDEBUG(D_acl) debug_printf("end of %s: implicit DENY\n", acl_name);
3942 return FAIL;
3943 }
3944
3945
3946
3947
3948 /* Same args as acl_check_internal() above, but the string s is
3949 the name of an ACL followed optionally by up to 9 space-separated arguments.
3950 The name and args are separately expanded.  Args go into $acl_arg globals. */
3951 static int
3952 acl_check_wargs(int where, address_item *addr, uschar *s, int level,
3953   uschar **user_msgptr, uschar **log_msgptr)
3954 {
3955 uschar * tmp;
3956 uschar * tmp_arg[9];    /* must match acl_arg[] */
3957 uschar * sav_arg[9];    /* must match acl_arg[] */
3958 int sav_narg;
3959 uschar * name;
3960 int i;
3961 int ret;
3962
3963 if (!(tmp = string_dequote(&s)) || !(name = expand_string(tmp)))
3964   goto bad;
3965
3966 for (i = 0; i < 9; i++)
3967   {
3968   while (*s && isspace(*s)) s++;
3969   if (!*s) break;
3970   if (!(tmp = string_dequote(&s)) || !(tmp_arg[i] = expand_string(tmp)))
3971     {
3972     tmp = name;
3973     goto bad;
3974     }
3975   }
3976
3977 sav_narg = acl_narg;
3978 acl_narg = i;
3979 for (i = 0; i < acl_narg; i++)
3980   {
3981   sav_arg[i] = acl_arg[i];
3982   acl_arg[i] = tmp_arg[i];
3983   }
3984 while (i < 9)
3985   {
3986   sav_arg[i] = acl_arg[i];
3987   acl_arg[i++] = NULL;
3988   }
3989
3990 ret = acl_check_internal(where, addr, name, level, user_msgptr, log_msgptr);
3991
3992 acl_narg = sav_narg;
3993 for (i = 0; i < 9; i++) acl_arg[i] = sav_arg[i];
3994 return ret;
3995
3996 bad:
3997 if (expand_string_forcedfail) return ERROR;
3998 *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
3999   tmp, expand_string_message);
4000 return search_find_defer?DEFER:ERROR;
4001 }
4002
4003
4004
4005 /*************************************************
4006 *        Check access using an ACL               *
4007 *************************************************/
4008
4009 /* This is the external interface for ACL checks. It sets up an address and the
4010 expansions for $domain and $local_part when called after RCPT, then calls
4011 acl_check_internal() to do the actual work.
4012
4013 Arguments:
4014   where        ACL_WHERE_xxxx indicating where called from
4015   recipient    RCPT address for RCPT check, else NULL
4016   s            the input string; NULL is the same as an empty ACL => DENY
4017   user_msgptr  where to put a user error (for SMTP response)
4018   log_msgptr   where to put a logging message (not for SMTP response)
4019
4020 Returns:       OK         access is granted by an ACCEPT verb
4021                DISCARD    access is granted by a DISCARD verb
4022                FAIL       access is denied
4023                FAIL_DROP  access is denied; drop the connection
4024                DEFER      can't tell at the moment
4025                ERROR      disaster
4026 */
4027
4028 int
4029 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
4030   uschar **log_msgptr)
4031 {
4032 int rc;
4033 address_item adb;
4034 address_item *addr = NULL;
4035
4036 *user_msgptr = *log_msgptr = NULL;
4037 sender_verified_failed = NULL;
4038 ratelimiters_cmd = NULL;
4039 log_reject_target = LOG_MAIN|LOG_REJECT;
4040
4041 if (where == ACL_WHERE_RCPT)
4042   {
4043   adb = address_defaults;
4044   addr = &adb;
4045   addr->address = recipient;
4046   if (deliver_split_address(addr) == DEFER)
4047     {
4048     *log_msgptr = US"defer in percent_hack_domains check";
4049     return DEFER;
4050     }
4051   deliver_domain = addr->domain;
4052   deliver_localpart = addr->local_part;
4053   }
4054
4055 rc = acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
4056
4057 /* Cutthrough - if requested,
4058 and WHERE_RCPT and not yet opened conn as result of recipient-verify,
4059 and rcpt acl returned accept,
4060 and first recipient (cancel on any subsequents)
4061 open one now and run it up to RCPT acceptance.
4062 A failed verify should cancel cutthrough request.
4063
4064 Initial implementation:  dual-write to spool.
4065 Assume the rxd datastream is now being copied byte-for-byte to an open cutthrough connection.
4066
4067 Cease cutthrough copy on rxd final dot; do not send one.
4068
4069 On a data acl, if not accept and a cutthrough conn is open, hard-close it (no SMTP niceness).
4070
4071 On data acl accept, terminate the dataphase on an open cutthrough conn.  If accepted or
4072 perm-rejected, reflect that to the original sender - and dump the spooled copy.
4073 If temp-reject, close the conn (and keep the spooled copy).
4074 If conn-failure, no action (and keep the spooled copy).
4075 */
4076 switch (where)
4077 {
4078 case ACL_WHERE_RCPT:
4079   if( rcpt_count > 1 )
4080     cancel_cutthrough_connection("more than one recipient");
4081   else if (rc == OK  &&  cutthrough_delivery  &&  cutthrough_fd < 0)
4082     open_cutthrough_connection(addr);
4083   break;
4084
4085 case ACL_WHERE_PREDATA:
4086   if( rc == OK )
4087     cutthrough_predata();
4088   else
4089     cancel_cutthrough_connection("predata acl not ok");
4090   break;
4091
4092 case ACL_WHERE_QUIT:
4093 case ACL_WHERE_NOTQUIT:
4094   cancel_cutthrough_connection("quit or notquit");
4095   break;
4096
4097 default:
4098   break;
4099 }
4100
4101 deliver_domain = deliver_localpart = deliver_address_data =
4102   sender_address_data = NULL;
4103
4104 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
4105 ACL, which is really in the middle of an SMTP command. */
4106
4107 if (rc == DISCARD)
4108   {
4109   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
4110     {
4111     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
4112       "ACL", acl_wherenames[where]);
4113     return ERROR;
4114     }
4115   return DISCARD;
4116   }
4117
4118 /* A DROP response is not permitted from MAILAUTH */
4119
4120 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
4121   {
4122   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
4123     "ACL", acl_wherenames[where]);
4124   return ERROR;
4125   }
4126
4127 /* Before giving a response, take a look at the length of any user message, and
4128 split it up into multiple lines if possible. */
4129
4130 *user_msgptr = string_split_message(*user_msgptr);
4131 if (fake_response != OK)
4132   fake_response_text = string_split_message(fake_response_text);
4133
4134 return rc;
4135 }
4136
4137
4138
4139 /*************************************************
4140 *             Create ACL variable                *
4141 *************************************************/
4142
4143 /* Create an ACL variable or reuse an existing one. ACL variables are in a
4144 binary tree (see tree.c) with acl_var_c and acl_var_m as root nodes.
4145
4146 Argument:
4147   name    pointer to the variable's name, starting with c or m
4148
4149 Returns   the pointer to variable's tree node
4150 */
4151
4152 tree_node *
4153 acl_var_create(uschar *name)
4154 {
4155 tree_node *node, **root;
4156 root = (name[0] == 'c')? &acl_var_c : &acl_var_m;
4157 node = tree_search(*root, name);
4158 if (node == NULL)
4159   {
4160   node = store_get(sizeof(tree_node) + Ustrlen(name));
4161   Ustrcpy(node->name, name);
4162   (void)tree_insertnode(root, node);
4163   }
4164 node->data.ptr = NULL;
4165 return node;
4166 }
4167
4168
4169
4170 /*************************************************
4171 *       Write an ACL variable in spool format    *
4172 *************************************************/
4173
4174 /* This function is used as a callback for tree_walk when writing variables to
4175 the spool file. To retain spool file compatibility, what is written is -aclc or
4176 -aclm followed by the rest of the name and the data length, space separated,
4177 then the value itself, starting on a new line, and terminated by an additional
4178 newline. When we had only numbered ACL variables, the first line might look
4179 like this: "-aclc 5 20". Now it might be "-aclc foo 20" for the variable called
4180 acl_cfoo.
4181
4182 Arguments:
4183   name    of the variable
4184   value   of the variable
4185   ctx     FILE pointer (as a void pointer)
4186
4187 Returns:  nothing
4188 */
4189
4190 void
4191 acl_var_write(uschar *name, uschar *value, void *ctx)
4192 {
4193 FILE *f = (FILE *)ctx;
4194 fprintf(f, "-acl%c %s %d\n%s\n", name[0], name+1, Ustrlen(value), value);
4195 }
4196
4197 /* End of acl.c */