src/src/acl.c

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