src/src/acl.c

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