src/src/acl.c

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