src/src/acl.c

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