src/src/acl.c

   1 /* $Cambridge: exim/src/src/acl.c,v 1.52 2005/12/06 10:25:59 ph10 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) != 0)
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         /* The name= option must be last, because it swallows the rest of
2501         the string. */
2502         else if (Ustrncmp(p, "/name=", 6) == 0)
2503           {
2504           uschar *pp = p + 6;
2505           while (*pp != 0) pp++;
2506           submission_name = string_copy(parse_fix_phrase(p+6, pp-p-6,
2507             big_buffer, big_buffer_size));
2508           p = pp;
2509           }
2510         else break;
2511         }
2512       if (*p != 0)
2513         {
2514         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
2515         return ERROR;
2516         }
2517       break;
2518
2519       case CONTROL_SUPPRESS_LOCAL_FIXUPS:
2520       suppress_local_fixups = TRUE;
2521       break;
2522       }
2523     break;
2524
2525 #ifdef WITH_CONTENT_SCAN
2526     case ACLC_DECODE:
2527     rc = mime_decode(&arg);
2528     break;
2529 #endif
2530
2531     case ACLC_DELAY:
2532       {
2533       int delay = readconf_readtime(arg, 0, FALSE);
2534       if (delay < 0)
2535         {
2536         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
2537           "modifier: \"%s\" is not a time value", arg);
2538         return ERROR;
2539         }
2540       else
2541         {
2542         HDEBUG(D_acl) debug_printf("delay modifier requests %d-second delay\n",
2543           delay);
2544         if (host_checking)
2545           {
2546           HDEBUG(D_acl)
2547             debug_printf("delay skipped in -bh checking mode\n");
2548           }
2549
2550         /* It appears to be impossible to detect that a TCP/IP connection has
2551         gone away without reading from it. This means that we cannot shorten
2552         the delay below if the client goes away, because we cannot discover
2553         that the client has closed its end of the connection. (The connection
2554         is actually in a half-closed state, waiting for the server to close its
2555         end.) It would be nice to be able to detect this state, so that the
2556         Exim process is not held up unnecessarily. However, it seems that we
2557         can't. The poll() function does not do the right thing, and in any case
2558         it is not always available.
2559
2560         NOTE: If ever this state of affairs changes, remember that we may be
2561         dealing with stdin/stdout here, in addition to TCP/IP connections.
2562         Whatever is done must work in both cases. To detected the stdin/stdout
2563         case, check for smtp_in or smtp_out being NULL. */
2564
2565         else
2566           {
2567           while (delay > 0) delay = sleep(delay);
2568           }
2569         }
2570       }
2571     break;
2572
2573 #ifdef WITH_OLD_DEMIME
2574     case ACLC_DEMIME:
2575       rc = demime(&arg);
2576     break;
2577 #endif
2578
2579 #ifdef EXPERIMENTAL_DOMAINKEYS
2580   case ACLC_DK_DOMAIN_SOURCE:
2581     if (dk_verify_block == NULL) { rc = FAIL; break; };
2582     /* check header source of domain against given string */
2583     switch (dk_verify_block->address_source) {
2584       case DK_EXIM_ADDRESS_FROM_FROM:
2585         rc = match_isinlist(US"from", &arg, 0, NULL,
2586                             NULL, MCL_STRING, TRUE, NULL);
2587       break;
2588       case DK_EXIM_ADDRESS_FROM_SENDER:
2589         rc = match_isinlist(US"sender", &arg, 0, NULL,
2590                             NULL, MCL_STRING, TRUE, NULL);
2591       break;
2592       case DK_EXIM_ADDRESS_NONE:
2593         rc = match_isinlist(US"none", &arg, 0, NULL,
2594                             NULL, MCL_STRING, TRUE, NULL);
2595       break;
2596     }
2597   break;
2598   case ACLC_DK_POLICY:
2599     if (dk_verify_block == NULL) { rc = FAIL; break; };
2600     /* check policy against given string, default FAIL */
2601     rc = FAIL;
2602     if (dk_verify_block->signsall)
2603       rc = match_isinlist(US"signsall", &arg, 0, NULL,
2604                           NULL, MCL_STRING, TRUE, NULL);
2605     if (dk_verify_block->testing)
2606       rc = match_isinlist(US"testing", &arg, 0, NULL,
2607                           NULL, MCL_STRING, TRUE, NULL);
2608   break;
2609   case ACLC_DK_SENDER_DOMAINS:
2610     if (dk_verify_block == NULL) { rc = FAIL; break; };
2611     if (dk_verify_block->domain != NULL)
2612       rc = match_isinlist(dk_verify_block->domain, &arg, 0, &domainlist_anchor,
2613                           NULL, MCL_DOMAIN, TRUE, NULL);
2614     else rc = FAIL;
2615   break;
2616   case ACLC_DK_SENDER_LOCAL_PARTS:
2617     if (dk_verify_block == NULL) { rc = FAIL; break; };
2618     if (dk_verify_block->local_part != NULL)
2619       rc = match_isinlist(dk_verify_block->local_part, &arg, 0, &localpartlist_anchor,
2620                           NULL, MCL_LOCALPART, TRUE, NULL);
2621     else rc = FAIL;
2622   break;
2623   case ACLC_DK_SENDERS:
2624     if (dk_verify_block == NULL) { rc = FAIL; break; };
2625     if (dk_verify_block->address != NULL)
2626       rc = match_address_list(dk_verify_block->address, TRUE, TRUE, &arg, NULL, -1, 0, NULL);
2627     else rc = FAIL;
2628   break;
2629   case ACLC_DK_STATUS:
2630     if (dk_verify_block == NULL) { rc = FAIL; break; };
2631     if (dk_verify_block->result > 0) {
2632       switch(dk_verify_block->result) {
2633         case DK_EXIM_RESULT_BAD_FORMAT:
2634           rc = match_isinlist(US"bad format", &arg, 0, NULL,
2635                               NULL, MCL_STRING, TRUE, NULL);
2636         break;
2637         case DK_EXIM_RESULT_NO_KEY:
2638           rc = match_isinlist(US"no key", &arg, 0, NULL,
2639                               NULL, MCL_STRING, TRUE, NULL);
2640         break;
2641         case DK_EXIM_RESULT_NO_SIGNATURE:
2642           rc = match_isinlist(US"no signature", &arg, 0, NULL,
2643                               NULL, MCL_STRING, TRUE, NULL);
2644         break;
2645         case DK_EXIM_RESULT_REVOKED:
2646           rc = match_isinlist(US"revoked", &arg, 0, NULL,
2647                               NULL, MCL_STRING, TRUE, NULL);
2648         break;
2649         case DK_EXIM_RESULT_NON_PARTICIPANT:
2650           rc = match_isinlist(US"non-participant", &arg, 0, NULL,
2651                               NULL, MCL_STRING, TRUE, NULL);
2652         break;
2653         case DK_EXIM_RESULT_GOOD:
2654           rc = match_isinlist(US"good", &arg, 0, NULL,
2655                               NULL, MCL_STRING, TRUE, NULL);
2656         break;
2657         case DK_EXIM_RESULT_BAD:
2658           rc = match_isinlist(US"bad", &arg, 0, NULL,
2659                               NULL, MCL_STRING, TRUE, NULL);
2660         break;
2661       }
2662     }
2663   break;
2664 #endif
2665
2666     case ACLC_DNSLISTS:
2667     rc = verify_check_dnsbl(&arg);
2668     break;
2669
2670     case ACLC_DOMAINS:
2671     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
2672       addr->domain_cache, MCL_DOMAIN, TRUE, &deliver_domain_data);
2673     break;
2674
2675     /* The value in tls_cipher is the full cipher name, for example,
2676     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
2677     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
2678     what may in practice come out of the SSL library - which at the time of
2679     writing is poorly documented. */
2680
2681     case ACLC_ENCRYPTED:
2682     if (tls_cipher == NULL) rc = FAIL; else
2683       {
2684       uschar *endcipher = NULL;
2685       uschar *cipher = Ustrchr(tls_cipher, ':');
2686       if (cipher == NULL) cipher = tls_cipher; else
2687         {
2688         endcipher = Ustrchr(++cipher, ':');
2689         if (endcipher != NULL) *endcipher = 0;
2690         }
2691       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
2692       if (endcipher != NULL) *endcipher = ':';
2693       }
2694     break;
2695
2696     /* Use verify_check_this_host() instead of verify_check_host() so that
2697     we can pass over &host_data to catch any looked up data. Once it has been
2698     set, it retains its value so that it's still there if another ACL verb
2699     comes through here and uses the cache. However, we must put it into
2700     permanent store in case it is also expected to be used in a subsequent
2701     message in the same SMTP connection. */
2702
2703     case ACLC_HOSTS:
2704     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
2705       (sender_host_address == NULL)? US"" : sender_host_address, &host_data);
2706     if (host_data != NULL) host_data = string_copy_malloc(host_data);
2707     break;
2708
2709     case ACLC_LOCAL_PARTS:
2710     rc = match_isinlist(addr->cc_local_part, &arg, 0,
2711       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
2712       &deliver_localpart_data);
2713     break;
2714
2715     case ACLC_LOGWRITE:
2716       {
2717       int logbits = 0;
2718       uschar *s = arg;
2719       if (*s == ':')
2720         {
2721         s++;
2722         while (*s != ':')
2723           {
2724           if (Ustrncmp(s, "main", 4) == 0)
2725             { logbits |= LOG_MAIN; s += 4; }
2726           else if (Ustrncmp(s, "panic", 5) == 0)
2727             { logbits |= LOG_PANIC; s += 5; }
2728           else if (Ustrncmp(s, "reject", 6) == 0)
2729             { logbits |= LOG_REJECT; s += 6; }
2730           else
2731             {
2732             logbits = LOG_MAIN|LOG_PANIC;
2733             s = string_sprintf(":unknown log name in \"%s\" in "
2734               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
2735             }
2736           if (*s == ',') s++;
2737           }
2738         s++;
2739         }
2740       while (isspace(*s)) s++;
2741       if (logbits == 0) logbits = LOG_MAIN;
2742       log_write(0, logbits, "%s", string_printing(s));
2743       }
2744     break;
2745
2746 #ifdef WITH_CONTENT_SCAN
2747     case ACLC_MALWARE:
2748       {
2749       /* Seperate the regular expression and any optional parameters. */
2750       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
2751       /* Run the malware backend. */
2752       rc = malware(&ss);
2753       /* Modify return code based upon the existance of options. */
2754       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
2755             != NULL) {
2756         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
2757           {
2758           /* FAIL so that the message is passed to the next ACL */
2759           rc = FAIL;
2760           }
2761         }
2762       }
2763     break;
2764
2765     case ACLC_MIME_REGEX:
2766       rc = mime_regex(&arg);
2767     break;
2768 #endif
2769
2770     case ACLC_RATELIMIT:
2771       rc = acl_ratelimit(arg, log_msgptr);
2772     break;
2773
2774     case ACLC_RECIPIENTS:
2775     rc = match_address_list(addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
2776       &recipient_data);
2777     break;
2778
2779 #ifdef WITH_CONTENT_SCAN
2780    case ACLC_REGEX:
2781       rc = regex(&arg);
2782     break;
2783 #endif
2784
2785     case ACLC_SENDER_DOMAINS:
2786       {
2787       uschar *sdomain;
2788       sdomain = Ustrrchr(sender_address, '@');
2789       sdomain = (sdomain == NULL)? US"" : sdomain + 1;
2790       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
2791         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
2792       }
2793     break;
2794
2795     case ACLC_SENDERS:
2796     rc = match_address_list(sender_address, TRUE, TRUE, &arg,
2797       sender_address_cache, -1, 0, &sender_data);
2798     break;
2799
2800     /* Connection variables must persist forever */
2801
2802     case ACLC_SET:
2803       {
2804       int old_pool = store_pool;
2805       if (cb->u.varnumber < ACL_C_MAX) store_pool = POOL_PERM;
2806       acl_var[cb->u.varnumber] = string_copy(arg);
2807       store_pool = old_pool;
2808       }
2809     break;
2810
2811 #ifdef WITH_CONTENT_SCAN
2812     case ACLC_SPAM:
2813       {
2814       /* Seperate the regular expression and any optional parameters. */
2815       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
2816       /* Run the spam backend. */
2817       rc = spam(&ss);
2818       /* Modify return code based upon the existance of options. */
2819       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
2820             != NULL) {
2821         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
2822           {
2823           /* FAIL so that the message is passed to the next ACL */
2824           rc = FAIL;
2825           }
2826         }
2827       }
2828     break;
2829 #endif
2830
2831 #ifdef EXPERIMENTAL_SPF
2832     case ACLC_SPF:
2833       rc = spf_process(&arg, sender_address);
2834     break;
2835 #endif
2836
2837     /* If the verb is WARN, discard any user message from verification, because
2838     such messages are SMTP responses, not header additions. The latter come
2839     only from explicit "message" modifiers. However, put the user message into
2840     $acl_verify_message so it can be used in subsequent conditions or modifiers
2841     (until something changes it). */
2842
2843     case ACLC_VERIFY:
2844     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
2845     acl_verify_message = *user_msgptr;
2846     if (verb == ACL_WARN) *user_msgptr = NULL;
2847     break;
2848
2849     default:
2850     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
2851       "condition %d", cb->type);
2852     break;
2853     }
2854
2855   /* If a condition was negated, invert OK/FAIL. */
2856
2857   if (!cond_modifiers[cb->type] && cb->u.negated)
2858     {
2859     if (rc == OK) rc = FAIL;
2860       else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
2861     }
2862
2863   if (rc != OK) break;   /* Conditions loop */
2864   }
2865
2866
2867 /* If the result is the one for which "message" and/or "log_message" are used,
2868 handle the values of these options. Most verbs have but a single return for
2869 which the messages are relevant, but for "discard", it's useful to have the log
2870 message both when it succeeds and when it fails. Also, for an "accept" that
2871 appears in a QUIT ACL, we want to handle the user message. Since only "accept"
2872 and "warn" are permitted in that ACL, we don't need to test the verb.
2873
2874 These modifiers act in different ways:
2875
2876 "message" is a user message that will be included in an SMTP response. Unless
2877 it is empty, it overrides any previously set user message.
2878
2879 "log_message" is a non-user message, and it adds to any existing non-user
2880 message that is already set.
2881
2882 If there isn't a log message set, we make it the same as the user message. */
2883
2884 if (((rc == FAIL_DROP)? FAIL : rc) == msgcond[verb] ||
2885     (verb == ACL_DISCARD && rc == OK) ||
2886     (where == ACL_WHERE_QUIT))
2887   {
2888   uschar *expmessage;
2889
2890   /* If the verb is "warn", messages generated by conditions (verification or
2891   nested ACLs) are discarded. Only messages specified at this level are used.
2892   However, the value of an existing message is available in $acl_verify_message
2893   during expansions. */
2894
2895   uschar *old_user_msgptr = *user_msgptr;
2896   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
2897
2898   if (verb == ACL_WARN) *log_msgptr = *user_msgptr = NULL;
2899
2900   if (user_message != NULL)
2901     {
2902     acl_verify_message = old_user_msgptr;
2903     expmessage = expand_string(user_message);
2904     if (expmessage == NULL)
2905       {
2906       if (!expand_string_forcedfail)
2907         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
2908           user_message, expand_string_message);
2909       }
2910     else if (expmessage[0] != 0) *user_msgptr = expmessage;
2911     }
2912
2913   if (log_message != NULL)
2914     {
2915     acl_verify_message = old_log_msgptr;
2916     expmessage = expand_string(log_message);
2917     if (expmessage == NULL)
2918       {
2919       if (!expand_string_forcedfail)
2920         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
2921           log_message, expand_string_message);
2922       }
2923     else if (expmessage[0] != 0)
2924       {
2925       *log_msgptr = (*log_msgptr == NULL)? expmessage :
2926         string_sprintf("%s: %s", expmessage, *log_msgptr);
2927       }
2928     }
2929
2930   /* If no log message, default it to the user message */
2931
2932   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
2933   }
2934
2935 acl_verify_message = NULL;
2936 return rc;
2937 }
2938
2939
2940
2941
2942
2943 /*************************************************
2944 *        Get line from a literal ACL             *
2945 *************************************************/
2946
2947 /* This function is passed to acl_read() in order to extract individual lines
2948 of a literal ACL, which we access via static pointers. We can destroy the
2949 contents because this is called only once (the compiled ACL is remembered).
2950
2951 This code is intended to treat the data in the same way as lines in the main
2952 Exim configuration file. That is:
2953
2954   . Leading spaces are ignored.
2955
2956   . A \ at the end of a line is a continuation - trailing spaces after the \
2957     are permitted (this is because I don't believe in making invisible things
2958     significant). Leading spaces on the continued part of a line are ignored.
2959
2960   . Physical lines starting (significantly) with # are totally ignored, and
2961     may appear within a sequence of backslash-continued lines.
2962
2963   . Blank lines are ignored, but will end a sequence of continuations.
2964
2965 Arguments: none
2966 Returns:   a pointer to the next line
2967 */
2968
2969
2970 static uschar *acl_text;          /* Current pointer in the text */
2971 static uschar *acl_text_end;      /* Points one past the terminating '0' */
2972
2973
2974 static uschar *
2975 acl_getline(void)
2976 {
2977 uschar *yield;
2978
2979 /* This loop handles leading blank lines and comments. */
2980
2981 for(;;)
2982   {
2983   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
2984   if (*acl_text == 0) return NULL;         /* No more data */
2985   yield = acl_text;                        /* Potential data line */
2986
2987   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
2988
2989   /* If we hit the end before a newline, we have the whole logical line. If
2990   it's a comment, there's no more data to be given. Otherwise, yield it. */
2991
2992   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
2993
2994   /* After reaching a newline, end this loop if the physical line does not
2995   start with '#'. If it does, it's a comment, and the loop continues. */
2996
2997   if (*yield != '#') break;
2998   }
2999
3000 /* This loop handles continuations. We know we have some real data, ending in
3001 newline. See if there is a continuation marker at the end (ignoring trailing
3002 white space). We know that *yield is not white space, so no need to test for
3003 cont > yield in the backwards scanning loop. */
3004
3005 for(;;)
3006   {
3007   uschar *cont;
3008   for (cont = acl_text - 1; isspace(*cont); cont--);
3009
3010   /* If no continuation follows, we are done. Mark the end of the line and
3011   return it. */
3012
3013   if (*cont != '\\')
3014     {
3015     *acl_text++ = 0;
3016     return yield;
3017     }
3018
3019   /* We have encountered a continuation. Skip over whitespace at the start of
3020   the next line, and indeed the whole of the next line or lines if they are
3021   comment lines. */
3022
3023   for (;;)
3024     {
3025     while (*(++acl_text) == ' ' || *acl_text == '\t');
3026     if (*acl_text != '#') break;
3027     while (*(++acl_text) != 0 && *acl_text != '\n');
3028     }
3029
3030   /* We have the start of a continuation line. Move all the rest of the data
3031   to join onto the previous line, and then find its end. If the end is not a
3032   newline, we are done. Otherwise loop to look for another continuation. */
3033
3034   memmove(cont, acl_text, acl_text_end - acl_text);
3035   acl_text_end -= acl_text - cont;
3036   acl_text = cont;
3037   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3038   if (*acl_text == 0) return yield;
3039   }
3040
3041 /* Control does not reach here */
3042 }
3043
3044
3045
3046
3047
3048 /*************************************************
3049 *        Check access using an ACL               *
3050 *************************************************/
3051
3052 /* This function is called from address_check. It may recurse via
3053 acl_check_condition() - hence the use of a level to stop looping. The ACL is
3054 passed as a string which is expanded. A forced failure implies no access check
3055 is required. If the result is a single word, it is taken as the name of an ACL
3056 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
3057 text, complete with newlines, and parsed as such. In both cases, the ACL check
3058 is then run. This function uses an auxiliary function for acl_read() to call
3059 for reading individual lines of a literal ACL. This is acl_getline(), which
3060 appears immediately above.
3061
3062 Arguments:
3063   where        where called from
3064   addr         address item when called from RCPT; otherwise NULL
3065   s            the input string; NULL is the same as an empty ACL => DENY
3066   level        the nesting level
3067   user_msgptr  where to put a user error (for SMTP response)
3068   log_msgptr   where to put a logging message (not for SMTP response)
3069
3070 Returns:       OK         access is granted
3071                DISCARD    access is apparently granted...
3072                FAIL       access is denied
3073                FAIL_DROP  access is denied; drop the connection
3074                DEFER      can't tell at the moment
3075                ERROR      disaster
3076 */
3077
3078 static int
3079 acl_check_internal(int where, address_item *addr, uschar *s, int level,
3080   uschar **user_msgptr, uschar **log_msgptr)
3081 {
3082 int fd = -1;
3083 acl_block *acl = NULL;
3084 uschar *acl_name = US"inline ACL";
3085 uschar *ss;
3086
3087 /* Catch configuration loops */
3088
3089 if (level > 20)
3090   {
3091   *log_msgptr = US"ACL nested too deep: possible loop";
3092   return ERROR;
3093   }
3094
3095 if (s == NULL)
3096   {
3097   HDEBUG(D_acl) debug_printf("ACL is NULL: implicit DENY\n");
3098   return FAIL;
3099   }
3100
3101 /* At top level, we expand the incoming string. At lower levels, it has already
3102 been expanded as part of condition processing. */
3103
3104 if (level == 0)
3105   {
3106   ss = expand_string(s);
3107   if (ss == NULL)
3108     {
3109     if (expand_string_forcedfail) return OK;
3110     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
3111       expand_string_message);
3112     return ERROR;
3113     }
3114   }
3115 else ss = s;
3116
3117 while (isspace(*ss))ss++;
3118
3119 /* If we can't find a named ACL, the default is to parse it as an inline one.
3120 (Unless it begins with a slash; non-existent files give rise to an error.) */
3121
3122 acl_text = ss;
3123
3124 /* Handle the case of a string that does not contain any spaces. Look for a
3125 named ACL among those read from the configuration, or a previously read file.
3126 It is possible that the pointer to the ACL is NULL if the configuration
3127 contains a name with no data. If not found, and the text begins with '/',
3128 read an ACL from a file, and save it so it can be re-used. */
3129
3130 if (Ustrchr(ss, ' ') == NULL)
3131   {
3132   tree_node *t = tree_search(acl_anchor, ss);
3133   if (t != NULL)
3134     {
3135     acl = (acl_block *)(t->data.ptr);
3136     if (acl == NULL)
3137       {
3138       HDEBUG(D_acl) debug_printf("ACL \"%s\" is empty: implicit DENY\n", ss);
3139       return FAIL;
3140       }
3141     acl_name = string_sprintf("ACL \"%s\"", ss);
3142     HDEBUG(D_acl) debug_printf("using ACL \"%s\"\n", ss);
3143     }
3144
3145   else if (*ss == '/')
3146     {
3147     struct stat statbuf;
3148     fd = Uopen(ss, O_RDONLY, 0);
3149     if (fd < 0)
3150       {
3151       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
3152         strerror(errno));
3153       return ERROR;
3154       }
3155
3156     if (fstat(fd, &statbuf) != 0)
3157       {
3158       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
3159         strerror(errno));
3160       return ERROR;
3161       }
3162
3163     acl_text = store_get(statbuf.st_size + 1);
3164     acl_text_end = acl_text + statbuf.st_size + 1;
3165
3166     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
3167       {
3168       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
3169         ss, strerror(errno));
3170       return ERROR;
3171       }
3172     acl_text[statbuf.st_size] = 0;
3173     (void)close(fd);
3174
3175     acl_name = string_sprintf("ACL \"%s\"", ss);
3176     HDEBUG(D_acl) debug_printf("read ACL from file %s\n", ss);
3177     }
3178   }
3179
3180 /* Parse an ACL that is still in text form. If it came from a file, remember it
3181 in the ACL tree, having read it into the POOL_PERM store pool so that it
3182 persists between multiple messages. */
3183
3184 if (acl == NULL)
3185   {
3186   int old_pool = store_pool;
3187   if (fd >= 0) store_pool = POOL_PERM;
3188   acl = acl_read(acl_getline, log_msgptr);
3189   store_pool = old_pool;
3190   if (acl == NULL && *log_msgptr != NULL) return ERROR;
3191   if (fd >= 0)
3192     {
3193     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
3194     Ustrcpy(t->name, ss);
3195     t->data.ptr = acl;
3196     (void)tree_insertnode(&acl_anchor, t);
3197     }
3198   }
3199
3200 /* Now we have an ACL to use. It's possible it may be NULL. */
3201
3202 while (acl != NULL)
3203   {
3204   int cond;
3205   int basic_errno = 0;
3206   BOOL endpass_seen = FALSE;
3207
3208   *log_msgptr = *user_msgptr = NULL;
3209   acl_temp_details = FALSE;
3210
3211   if (where == ACL_WHERE_QUIT &&
3212       acl->verb != ACL_ACCEPT &&
3213       acl->verb != ACL_WARN)
3214     {
3215     *log_msgptr = string_sprintf("\"%s\" is not allowed in a QUIT ACL",
3216       verbs[acl->verb]);
3217     return ERROR;
3218     }
3219
3220   HDEBUG(D_acl) debug_printf("processing \"%s\"\n", verbs[acl->verb]);
3221
3222   /* Clear out any search error message from a previous check before testing
3223   this condition. */
3224
3225   search_error_message = NULL;
3226   cond = acl_check_condition(acl->verb, acl->condition, where, addr, level,
3227     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
3228
3229   /* Handle special returns: DEFER causes a return except on a WARN verb;
3230   ERROR always causes a return. */
3231
3232   switch (cond)
3233     {
3234     case DEFER:
3235     HDEBUG(D_acl) debug_printf("%s: condition test deferred\n", verbs[acl->verb]);
3236     if (basic_errno != ERRNO_CALLOUTDEFER)
3237       {
3238       if (search_error_message != NULL && *search_error_message != 0)
3239         *log_msgptr = search_error_message;
3240       if (smtp_return_error_details) acl_temp_details = TRUE;
3241       }
3242     else
3243       {
3244       acl_temp_details = TRUE;
3245       }
3246     if (acl->verb != ACL_WARN) return DEFER;
3247     break;
3248
3249     default:      /* Paranoia */
3250     case ERROR:
3251     HDEBUG(D_acl) debug_printf("%s: condition test error\n", verbs[acl->verb]);
3252     return ERROR;
3253
3254     case OK:
3255     HDEBUG(D_acl) debug_printf("%s: condition test succeeded\n",
3256       verbs[acl->verb]);
3257     break;
3258
3259     case FAIL:
3260     HDEBUG(D_acl) debug_printf("%s: condition test failed\n", verbs[acl->verb]);
3261     break;
3262
3263     /* DISCARD and DROP can happen only from a nested ACL condition, and
3264     DISCARD can happen only for an "accept" or "discard" verb. */
3265
3266     case DISCARD:
3267     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"discard\"\n",
3268       verbs[acl->verb]);
3269     break;
3270
3271     case FAIL_DROP:
3272     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"drop\"\n",
3273       verbs[acl->verb]);
3274     break;
3275     }
3276
3277   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
3278   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
3279   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
3280
3281   switch(acl->verb)
3282     {
3283     case ACL_ACCEPT:
3284     if (cond == OK || cond == DISCARD) return cond;
3285     if (endpass_seen)
3286       {
3287       HDEBUG(D_acl) debug_printf("accept: endpass encountered - denying access\n");
3288       return cond;
3289       }
3290     break;
3291
3292     case ACL_DEFER:
3293     if (cond == OK)
3294       {
3295       acl_temp_details = TRUE;
3296       return DEFER;
3297       }
3298     break;
3299
3300     case ACL_DENY:
3301     if (cond == OK) return FAIL;
3302     break;
3303
3304     case ACL_DISCARD:
3305     if (cond == OK || cond == DISCARD) return DISCARD;
3306     if (endpass_seen)
3307       {
3308       HDEBUG(D_acl) debug_printf("discard: endpass encountered - denying access\n");
3309       return cond;
3310       }
3311     break;
3312
3313     case ACL_DROP:
3314     if (cond == OK) return FAIL_DROP;
3315     break;
3316
3317     case ACL_REQUIRE:
3318     if (cond != OK) return cond;
3319     break;
3320
3321     case ACL_WARN:
3322     if (cond == OK)
3323       acl_warn(where, *user_msgptr, *log_msgptr);
3324     else if (cond == DEFER && (log_extra_selector & LX_acl_warn_skipped) != 0)
3325       log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
3326         "condition test deferred%s%s", host_and_ident(TRUE),
3327         (*log_msgptr == NULL)? US"" : US": ",
3328         (*log_msgptr == NULL)? US"" : *log_msgptr);
3329     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
3330     break;
3331
3332     default:
3333     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
3334       acl->verb);
3335     break;
3336     }
3337
3338   /* Pass to the next ACL item */
3339
3340   acl = acl->next;
3341   }
3342
3343 /* We have reached the end of the ACL. This is an implicit DENY. */
3344
3345 HDEBUG(D_acl) debug_printf("end of %s: implicit DENY\n", acl_name);
3346 return FAIL;
3347 }
3348
3349
3350 /*************************************************
3351 *        Check access using an ACL               *
3352 *************************************************/
3353
3354 /* This is the external interface for ACL checks. It sets up an address and the
3355 expansions for $domain and $local_part when called after RCPT, then calls
3356 acl_check_internal() to do the actual work.
3357
3358 Arguments:
3359   where        ACL_WHERE_xxxx indicating where called from
3360   recipient    RCPT address for RCPT check, else NULL
3361   s            the input string; NULL is the same as an empty ACL => DENY
3362   user_msgptr  where to put a user error (for SMTP response)
3363   log_msgptr   where to put a logging message (not for SMTP response)
3364
3365 Returns:       OK         access is granted by an ACCEPT verb
3366                DISCARD    access is granted by a DISCARD verb
3367                FAIL       access is denied
3368                FAIL_DROP  access is denied; drop the connection
3369                DEFER      can't tell at the moment
3370                ERROR      disaster
3371 */
3372
3373 int
3374 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
3375   uschar **log_msgptr)
3376 {
3377 int rc;
3378 address_item adb;
3379 address_item *addr = NULL;
3380
3381 *user_msgptr = *log_msgptr = NULL;
3382 sender_verified_failed = NULL;
3383 ratelimiters_cmd = NULL;
3384
3385 if (where == ACL_WHERE_RCPT)
3386   {
3387   adb = address_defaults;
3388   addr = &adb;
3389   addr->address = recipient;
3390   if (deliver_split_address(addr) == DEFER)
3391     {
3392     *log_msgptr = US"defer in percent_hack_domains check";
3393     return DEFER;
3394     }
3395   deliver_domain = addr->domain;
3396   deliver_localpart = addr->local_part;
3397   }
3398
3399 rc = acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
3400
3401 deliver_domain = deliver_localpart = deliver_address_data =
3402   sender_address_data = NULL;
3403
3404 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
3405 ACL, which is really in the middle of an SMTP command. */
3406
3407 if (rc == DISCARD)
3408   {
3409   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
3410     {
3411     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
3412       "ACL", acl_wherenames[where]);
3413     return ERROR;
3414     }
3415   return DISCARD;
3416   }
3417
3418 /* A DROP response is not permitted from MAILAUTH */
3419
3420 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
3421   {
3422   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
3423     "ACL", acl_wherenames[where]);
3424   return ERROR;
3425   }
3426
3427 /* Before giving an error response, take a look at the length of any user
3428 message, and split it up into multiple lines if possible. */
3429
3430 if (rc != OK && *user_msgptr != NULL && Ustrlen(*user_msgptr) > 75)
3431   {
3432   uschar *s = *user_msgptr = string_copy(*user_msgptr);
3433   uschar *ss = s;
3434
3435   for (;;)
3436     {
3437     int i = 0;
3438     while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
3439     if (*ss == 0) break;
3440     if (*ss == '\n')
3441       s = ++ss;
3442     else
3443       {
3444       uschar *t = ss + 1;
3445       uschar *tt = NULL;
3446       while (--t > s + 35)
3447         {
3448         if (*t == ' ')
3449           {
3450           if (t[-1] == ':') { tt = t; break; }
3451           if (tt == NULL) tt = t;
3452           }
3453         }
3454
3455       if (tt == NULL)          /* Can't split behind - try ahead */
3456         {
3457         t = ss + 1;
3458         while (*t != 0)
3459           {
3460           if (*t == ' ' || *t == '\n')
3461             { tt = t; break; }
3462           t++;
3463           }
3464         }
3465
3466       if (tt == NULL) break;   /* Can't find anywhere to split */
3467       *tt = '\n';
3468       s = ss = tt+1;
3469       }
3470     }
3471   }
3472
3473 return rc;
3474 }
3475
3476 /* End of acl.c */