src/src/acl.c

   1 /* $Cambridge: exim/src/src/acl.c,v 1.39 2005/06/10 19:27:05 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 found = domain;
1147 switch (dns_special_lookup(&dnsa, domain, T_CSA, &found))
1148   {
1149   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1150
1151   default:
1152   return t->data.val = CSA_DEFER_SRV;
1153
1154   /* If we found nothing, the client's authorization is unknown. */
1155
1156   case DNS_NOMATCH:
1157   case DNS_NODATA:
1158   return t->data.val = CSA_UNKNOWN;
1159
1160   /* We got something! Go on to look at the reply in more detail. */
1161
1162   case DNS_SUCCEED:
1163   break;
1164   }
1165
1166 /* Scan the reply for well-formed CSA SRV records. */
1167
1168 for (rr = dns_next_rr(&dnsa, &dnss, RESET_ANSWERS);
1169      rr != NULL;
1170      rr = dns_next_rr(&dnsa, &dnss, RESET_NEXT))
1171   {
1172   if (rr->type != T_SRV) continue;
1173
1174   /* Extract the numerical SRV fields (p is incremented) */
1175
1176   p = rr->data;
1177   GETSHORT(priority, p);
1178   GETSHORT(weight, p);
1179   GETSHORT(port, p);
1180
1181   DEBUG(D_acl)
1182     debug_printf("CSA priority=%d weight=%d port=%d\n", priority, weight, port);
1183
1184   /* Check the CSA version number */
1185
1186   if (priority != 1) continue;
1187
1188   /* If the domain does not have a CSA SRV record of its own (i.e. the domain
1189   found by dns_special_lookup() is a parent of the one we asked for), we check
1190   the subdomain assertions in the port field. At the moment there's only one
1191   assertion: legitimate SMTP clients are all explicitly authorized with CSA
1192   SRV records of their own. */
1193
1194   if (found != domain)
1195     {
1196     if (port & 1)
1197       return t->data.val = CSA_FAIL_EXPLICIT;
1198     else
1199       return t->data.val = CSA_UNKNOWN;
1200     }
1201
1202   /* This CSA SRV record refers directly to our domain, so we check the value
1203   in the weight field to work out the domain's authorization. 0 and 1 are
1204   unauthorized; 3 means the client is authorized but we can't check the IP
1205   address in order to authenticate it, so we treat it as unknown; values
1206   greater than 3 are undefined. */
1207
1208   if (weight < 2) return t->data.val = CSA_FAIL_DOMAIN;
1209
1210   if (weight > 2) continue;
1211
1212   /* Weight == 2, which means the domain is authorized. We must check that the
1213   client's IP address is listed as one of the SRV target addresses. Save the
1214   target hostname then break to scan the additional data for its addresses. */
1215
1216   (void)dn_expand(dnsa.answer, dnsa.answer + dnsa.answerlen, p,
1217     (DN_EXPAND_ARG4_TYPE)target, sizeof(target));
1218
1219   DEBUG(D_acl) debug_printf("CSA target is %s\n", target);
1220
1221   break;
1222   }
1223
1224 /* If we didn't break the loop then no appropriate records were found. */
1225
1226 if (rr == NULL) return t->data.val = CSA_UNKNOWN;
1227
1228 /* Do not check addresses if the target is ".", in accordance with RFC 2782.
1229 A target of "." indicates there are no valid addresses, so the client cannot
1230 be authorized. (This is an odd configuration because weight=2 target=. is
1231 equivalent to weight=1, but we check for it in order to keep load off the
1232 root name servers.) Note that dn_expand() turns "." into "". */
1233
1234 if (Ustrcmp(target, "") == 0) return t->data.val = CSA_FAIL_NOADDR;
1235
1236 /* Scan the additional section of the CSA SRV reply for addresses belonging
1237 to the target. If the name server didn't return any additional data (e.g.
1238 because it does not fully support SRV records), we need to do another lookup
1239 to obtain the target addresses; otherwise we have a definitive result. */
1240
1241 rc = acl_verify_csa_address(&dnsa, &dnss, RESET_ADDITIONAL, target);
1242 if (rc != CSA_FAIL_NOADDR) return t->data.val = rc;
1243
1244 /* The DNS lookup type corresponds to the IP version used by the client. */
1245
1246 #if HAVE_IPV6
1247 if (Ustrchr(sender_host_address, ':') != NULL)
1248   type = T_AAAA;
1249 else
1250 #endif /* HAVE_IPV6 */
1251   type = T_A;
1252
1253
1254 #if HAVE_IPV6 && defined(SUPPORT_A6)
1255 DNS_LOOKUP_AGAIN:
1256 #endif
1257
1258 switch (dns_lookup(&dnsa, target, type, NULL))
1259   {
1260   /* If something bad happened (most commonly DNS_AGAIN), defer. */
1261
1262   default:
1263   return t->data.val = CSA_DEFER_ADDR;
1264
1265   /* If the query succeeded, scan the addresses and return the result. */
1266
1267   case DNS_SUCCEED:
1268   rc = acl_verify_csa_address(&dnsa, &dnss, RESET_ANSWERS, target);
1269   if (rc != CSA_FAIL_NOADDR) return t->data.val = rc;
1270   /* else fall through */
1271
1272   /* If the target has no IP addresses, the client cannot have an authorized
1273   IP address. However, if the target site uses A6 records (not AAAA records)
1274   we have to do yet another lookup in order to check them. */
1275
1276   case DNS_NOMATCH:
1277   case DNS_NODATA:
1278
1279   #if HAVE_IPV6 && defined(SUPPORT_A6)
1280   if (type == T_AAAA) { type = T_A6; goto DNS_LOOKUP_AGAIN; }
1281   #endif
1282
1283   return t->data.val = CSA_FAIL_NOADDR;
1284   }
1285 }
1286
1287
1288
1289 /*************************************************
1290 *     Handle verification (address & other)      *
1291 *************************************************/
1292
1293 /* This function implements the "verify" condition. It is called when
1294 encountered in any ACL, because some tests are almost always permitted. Some
1295 just don't make sense, and always fail (for example, an attempt to test a host
1296 lookup for a non-TCP/IP message). Others are restricted to certain ACLs.
1297
1298 Arguments:
1299   where        where called from
1300   addr         the recipient address that the ACL is handling, or NULL
1301   arg          the argument of "verify"
1302   user_msgptr  pointer for user message
1303   log_msgptr   pointer for log message
1304   basic_errno  where to put verify errno
1305
1306 Returns:       OK        verification condition succeeded
1307                FAIL      verification failed
1308                DEFER     there was a problem verifying
1309                ERROR     syntax error
1310 */
1311
1312 static int
1313 acl_verify(int where, address_item *addr, uschar *arg,
1314   uschar **user_msgptr, uschar **log_msgptr, int *basic_errno)
1315 {
1316 int sep = '/';
1317 int callout = -1;
1318 int callout_overall = -1;
1319 int callout_connect = -1;
1320 int verify_options = 0;
1321 int rc;
1322 BOOL verify_header_sender = FALSE;
1323 BOOL defer_ok = FALSE;
1324 BOOL callout_defer_ok = FALSE;
1325 BOOL no_details = FALSE;
1326 address_item *sender_vaddr = NULL;
1327 uschar *verify_sender_address = NULL;
1328 uschar *pm_mailfrom = NULL;
1329 uschar *se_mailfrom = NULL;
1330
1331 /* Some of the verify items have slash-separated options; some do not. Diagnose
1332 an error if options are given for items that don't expect them. This code has
1333 now got very message. Refactoring to use a table would be a good idea one day.
1334 */
1335
1336 uschar *slash = Ustrchr(arg, '/');
1337 uschar *list = arg;
1338 uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
1339
1340 if (ss == NULL) goto BAD_VERIFY;
1341
1342 /* Handle name/address consistency verification in a separate function. */
1343
1344 if (strcmpic(ss, US"reverse_host_lookup") == 0)
1345   {
1346   if (slash != NULL) goto NO_OPTIONS;
1347   if (sender_host_address == NULL) return OK;
1348   return acl_verify_reverse(user_msgptr, log_msgptr);
1349   }
1350
1351 /* TLS certificate verification is done at STARTTLS time; here we just
1352 test whether it was successful or not. (This is for optional verification; for
1353 mandatory verification, the connection doesn't last this long.) */
1354
1355 if (strcmpic(ss, US"certificate") == 0)
1356   {
1357   if (slash != NULL) goto NO_OPTIONS;
1358   if (tls_certificate_verified) return OK;
1359   *user_msgptr = US"no verified certificate";
1360   return FAIL;
1361   }
1362
1363 /* We can test the result of optional HELO verification */
1364
1365 if (strcmpic(ss, US"helo") == 0)
1366   {
1367   if (slash != NULL) goto NO_OPTIONS;
1368   return helo_verified? OK : FAIL;
1369   }
1370
1371 /* Do Client SMTP Authorization checks in a separate function, and turn the
1372 result code into user-friendly strings. */
1373
1374 if (strcmpic(ss, US"csa") == 0)
1375   {
1376   rc = acl_verify_csa(list);
1377   *log_msgptr = *user_msgptr = string_sprintf("client SMTP authorization %s",
1378                                               csa_reason_string[rc]);
1379   csa_status = csa_status_string[rc];
1380   DEBUG(D_acl) debug_printf("CSA result %s\n", csa_status);
1381   return csa_return_code[rc];
1382   }
1383
1384 /* Check that all relevant header lines have the correct syntax. If there is
1385 a syntax error, we return details of the error to the sender if configured to
1386 send out full details. (But a "message" setting on the ACL can override, as
1387 always). */
1388
1389 if (strcmpic(ss, US"header_syntax") == 0)
1390   {
1391   if (slash != NULL) goto NO_OPTIONS;
1392   if (where != ACL_WHERE_DATA && where != ACL_WHERE_NOTSMTP)
1393     {
1394     *log_msgptr = string_sprintf("cannot check header contents in ACL for %s "
1395       "(only possible in ACL for DATA)", acl_wherenames[where]);
1396     return ERROR;
1397     }
1398   rc = verify_check_headers(log_msgptr);
1399   if (rc != OK && smtp_return_error_details && *log_msgptr != NULL)
1400     *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1401   return rc;
1402   }
1403
1404
1405 /* The remaining verification tests check recipient and sender addresses,
1406 either from the envelope or from the header. There are a number of
1407 slash-separated options that are common to all of them. */
1408
1409
1410 /* Check that there is at least one verifiable sender address in the relevant
1411 header lines. This can be followed by callout and defer options, just like
1412 sender and recipient. */
1413
1414 if (strcmpic(ss, US"header_sender") == 0)
1415   {
1416   if (where != ACL_WHERE_DATA && where != ACL_WHERE_NOTSMTP)
1417     {
1418     *log_msgptr = string_sprintf("cannot check header contents in ACL for %s "
1419       "(only possible in ACL for DATA)", acl_wherenames[where]);
1420     return ERROR;
1421     }
1422   verify_header_sender = TRUE;
1423   }
1424
1425 /* Otherwise, first item in verify argument must be "sender" or "recipient".
1426 In the case of a sender, this can optionally be followed by an address to use
1427 in place of the actual sender (rare special-case requirement). */
1428
1429 else if (strncmpic(ss, US"sender", 6) == 0)
1430   {
1431   uschar *s = ss + 6;
1432   if (where > ACL_WHERE_NOTSMTP)
1433     {
1434     *log_msgptr = string_sprintf("cannot verify sender in ACL for %s "
1435       "(only possible for MAIL, RCPT, PREDATA, or DATA)",
1436       acl_wherenames[where]);
1437     return ERROR;
1438     }
1439   if (*s == 0)
1440     verify_sender_address = sender_address;
1441   else
1442     {
1443     while (isspace(*s)) s++;
1444     if (*s++ != '=') goto BAD_VERIFY;
1445     while (isspace(*s)) s++;
1446     verify_sender_address = string_copy(s);
1447     }
1448   }
1449 else
1450   {
1451   if (strcmpic(ss, US"recipient") != 0) goto BAD_VERIFY;
1452   if (addr == NULL)
1453     {
1454     *log_msgptr = string_sprintf("cannot verify recipient in ACL for %s "
1455       "(only possible for RCPT)", acl_wherenames[where]);
1456     return ERROR;
1457     }
1458   }
1459
1460 /* Remaining items are optional; they apply to sender and recipient
1461 verification, including "header sender" verification. */
1462
1463 while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
1464       != NULL)
1465   {
1466   if (strcmpic(ss, US"defer_ok") == 0) defer_ok = TRUE;
1467   else if (strcmpic(ss, US"no_details") == 0) no_details = TRUE;
1468
1469   /* These two old options are left for backwards compatibility */
1470
1471   else if (strcmpic(ss, US"callout_defer_ok") == 0)
1472     {
1473     callout_defer_ok = TRUE;
1474     if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1475     }
1476
1477   else if (strcmpic(ss, US"check_postmaster") == 0)
1478      {
1479      pm_mailfrom = US"";
1480      if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
1481      }
1482
1483   /* The callout option has a number of sub-options, comma separated */
1484
1485   else if (strncmpic(ss, US"callout", 7) == 0)
1486     {
1487     callout = CALLOUT_TIMEOUT_DEFAULT;
1488     ss += 7;
1489     if (*ss != 0)
1490       {
1491       while (isspace(*ss)) ss++;
1492       if (*ss++ == '=')
1493         {
1494         int optsep = ',';
1495         uschar *opt;
1496         uschar buffer[256];
1497         while (isspace(*ss)) ss++;
1498
1499         /* This callout option handling code has become a mess as new options
1500         have been added in an ad hoc manner. It should be tidied up into some
1501         kind of table-driven thing. */
1502
1503         while ((opt = string_nextinlist(&ss, &optsep, buffer, sizeof(buffer)))
1504               != NULL)
1505           {
1506           if (strcmpic(opt, US"defer_ok") == 0) callout_defer_ok = TRUE;
1507           else if (strcmpic(opt, US"no_cache") == 0)
1508              verify_options |= vopt_callout_no_cache;
1509           else if (strcmpic(opt, US"random") == 0)
1510              verify_options |= vopt_callout_random;
1511           else if (strcmpic(opt, US"use_sender") == 0)
1512              verify_options |= vopt_callout_recipsender;
1513           else if (strcmpic(opt, US"use_postmaster") == 0)
1514              verify_options |= vopt_callout_recippmaster;
1515           else if (strcmpic(opt, US"postmaster") == 0) pm_mailfrom = US"";
1516           else if (strcmpic(opt, US"fullpostmaster") == 0)
1517             {
1518             pm_mailfrom = US"";
1519             verify_options |= vopt_callout_fullpm;
1520             }
1521
1522           else if (strncmpic(opt, US"mailfrom", 8) == 0)
1523             {
1524             if (!verify_header_sender)
1525               {
1526               *log_msgptr = string_sprintf("\"mailfrom\" is allowed as a "
1527                 "callout option only for verify=header_sender (detected in ACL "
1528                 "condition \"%s\")", arg);
1529               return ERROR;
1530               }
1531             opt += 8;
1532             while (isspace(*opt)) opt++;
1533             if (*opt++ != '=')
1534               {
1535               *log_msgptr = string_sprintf("'=' expected after "
1536                 "\"mailfrom\" in ACL condition \"%s\"", arg);
1537               return ERROR;
1538               }
1539             while (isspace(*opt)) opt++;
1540             se_mailfrom = string_copy(opt);
1541             }
1542
1543           else if (strncmpic(opt, US"postmaster_mailfrom", 19) == 0)
1544             {
1545             opt += 19;
1546             while (isspace(*opt)) opt++;
1547             if (*opt++ != '=')
1548               {
1549               *log_msgptr = string_sprintf("'=' expected after "
1550                 "\"postmaster_mailfrom\" in ACL condition \"%s\"", arg);
1551               return ERROR;
1552               }
1553             while (isspace(*opt)) opt++;
1554             pm_mailfrom = string_copy(opt);
1555             }
1556
1557           else if (strncmpic(opt, US"maxwait", 7) == 0)
1558             {
1559             opt += 7;
1560             while (isspace(*opt)) opt++;
1561             if (*opt++ != '=')
1562               {
1563               *log_msgptr = string_sprintf("'=' expected after \"maxwait\" in "
1564                 "ACL condition \"%s\"", arg);
1565               return ERROR;
1566               }
1567             while (isspace(*opt)) opt++;
1568             callout_overall = readconf_readtime(opt, 0, FALSE);
1569             if (callout_overall < 0)
1570               {
1571               *log_msgptr = string_sprintf("bad time value in ACL condition "
1572                 "\"verify %s\"", arg);
1573               return ERROR;
1574               }
1575             }
1576           else if (strncmpic(opt, US"connect", 7) == 0)
1577             {
1578             opt += 7;
1579             while (isspace(*opt)) opt++;
1580             if (*opt++ != '=')
1581               {
1582               *log_msgptr = string_sprintf("'=' expected after "
1583                 "\"callout_overaall\" in ACL condition \"%s\"", arg);
1584               return ERROR;
1585               }
1586             while (isspace(*opt)) opt++;
1587             callout_connect = readconf_readtime(opt, 0, FALSE);
1588             if (callout_connect < 0)
1589               {
1590               *log_msgptr = string_sprintf("bad time value in ACL condition "
1591                 "\"verify %s\"", arg);
1592               return ERROR;
1593               }
1594             }
1595           else    /* Plain time is callout connect/command timeout */
1596             {
1597             callout = readconf_readtime(opt, 0, FALSE);
1598             if (callout < 0)
1599               {
1600               *log_msgptr = string_sprintf("bad time value in ACL condition "
1601                 "\"verify %s\"", arg);
1602               return ERROR;
1603               }
1604             }
1605           }
1606         }
1607       else
1608         {
1609         *log_msgptr = string_sprintf("'=' expected after \"callout\" in "
1610           "ACL condition \"%s\"", arg);
1611         return ERROR;
1612         }
1613       }
1614     }
1615
1616   /* Option not recognized */
1617
1618   else
1619     {
1620     *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
1621       "condition \"verify %s\"", ss, arg);
1622     return ERROR;
1623     }
1624   }
1625
1626 if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)) ==
1627       (vopt_callout_recipsender|vopt_callout_recippmaster))
1628   {
1629   *log_msgptr = US"only one of use_sender and use_postmaster can be set "
1630     "for a recipient callout";
1631   return ERROR;
1632   }
1633
1634 /* Handle sender-in-header verification. Default the user message to the log
1635 message if giving out verification details. */
1636
1637 if (verify_header_sender)
1638   {
1639   int verrno;
1640   rc = verify_check_header_address(user_msgptr, log_msgptr, callout,
1641     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, verify_options,
1642     &verrno);
1643   if (rc != OK)
1644     {
1645     *basic_errno = verrno;
1646     if (smtp_return_error_details)
1647       {
1648       if (*user_msgptr == NULL && *log_msgptr != NULL)
1649         *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1650       if (rc == DEFER) acl_temp_details = TRUE;
1651       }
1652     }
1653   }
1654
1655 /* Handle a sender address. The default is to verify *the* sender address, but
1656 optionally a different address can be given, for special requirements. If the
1657 address is empty, we are dealing with a bounce message that has no sender, so
1658 we cannot do any checking. If the real sender address gets rewritten during
1659 verification (e.g. DNS widening), set the flag to stop it being rewritten again
1660 during message reception.
1661
1662 A list of verified "sender" addresses is kept to try to avoid doing to much
1663 work repetitively when there are multiple recipients in a message and they all
1664 require sender verification. However, when callouts are involved, it gets too
1665 complicated because different recipients may require different callout options.
1666 Therefore, we always do a full sender verify when any kind of callout is
1667 specified. Caching elsewhere, for instance in the DNS resolver and in the
1668 callout handling, should ensure that this is not terribly inefficient. */
1669
1670 else if (verify_sender_address != NULL)
1671   {
1672   if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster))
1673        != 0)
1674     {
1675     *log_msgptr = US"use_sender or use_postmaster cannot be used for a "
1676       "sender verify callout";
1677     return ERROR;
1678     }
1679
1680   sender_vaddr = verify_checked_sender(verify_sender_address);
1681   if (sender_vaddr != NULL &&               /* Previously checked */
1682       callout <= 0)                         /* No callout needed this time */
1683     {
1684     /* If the "routed" flag is set, it means that routing worked before, so
1685     this check can give OK (the saved return code value, if set, belongs to a
1686     callout that was done previously). If the "routed" flag is not set, routing
1687     must have failed, so we use the saved return code. */
1688
1689     if (testflag(sender_vaddr, af_verify_routed)) rc = OK; else
1690       {
1691       rc = sender_vaddr->special_action;
1692       *basic_errno = sender_vaddr->basic_errno;
1693       }
1694     HDEBUG(D_acl) debug_printf("using cached sender verify result\n");
1695     }
1696
1697   /* Do a new verification, and cache the result. The cache is used to avoid
1698   verifying the sender multiple times for multiple RCPTs when callouts are not
1699   specified (see comments above).
1700
1701   The cache is also used on failure to give details in response to the first
1702   RCPT that gets bounced for this reason. However, this can be suppressed by
1703   the no_details option, which sets the flag that says "this detail has already
1704   been sent". The cache normally contains just one address, but there may be
1705   more in esoteric circumstances. */
1706
1707   else
1708     {
1709     BOOL routed = TRUE;
1710     uschar *save_address_data = deliver_address_data;
1711
1712     sender_vaddr = deliver_make_addr(verify_sender_address, TRUE);
1713     if (no_details) setflag(sender_vaddr, af_sverify_told);
1714     if (verify_sender_address[0] != 0)
1715       {
1716       /* If this is the real sender address, save the unrewritten version
1717       for use later in receive. Otherwise, set a flag so that rewriting the
1718       sender in verify_address() does not update sender_address. */
1719
1720       if (verify_sender_address == sender_address)
1721         sender_address_unrewritten = sender_address;
1722       else
1723         verify_options |= vopt_fake_sender;
1724
1725       /* The recipient, qualify, and expn options are never set in
1726       verify_options. */
1727
1728       rc = verify_address(sender_vaddr, NULL, verify_options, callout,
1729         callout_overall, callout_connect, se_mailfrom, pm_mailfrom, &routed);
1730
1731       HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
1732
1733       if (rc == OK)
1734         {
1735         if (Ustrcmp(sender_vaddr->address, verify_sender_address) != 0)
1736           {
1737           DEBUG(D_acl) debug_printf("sender %s verified ok as %s\n",
1738             verify_sender_address, sender_vaddr->address);
1739           }
1740         else
1741           {
1742           DEBUG(D_acl) debug_printf("sender %s verified ok\n",
1743             verify_sender_address);
1744           }
1745         }
1746       else *basic_errno = sender_vaddr->basic_errno;
1747       }
1748     else rc = OK;  /* Null sender */
1749
1750     /* Cache the result code */
1751
1752     if (routed) setflag(sender_vaddr, af_verify_routed);
1753     if (callout > 0) setflag(sender_vaddr, af_verify_callout);
1754     sender_vaddr->special_action = rc;
1755     sender_vaddr->next = sender_verified_list;
1756     sender_verified_list = sender_vaddr;
1757
1758     /* Restore the recipient address data, which might have been clobbered by
1759     the sender verification. */
1760
1761     deliver_address_data = save_address_data;
1762     }
1763
1764   /* Put the sender address_data value into $sender_address_data */
1765
1766   sender_address_data = sender_vaddr->p.address_data;
1767   }
1768
1769 /* A recipient address just gets a straightforward verify; again we must handle
1770 the DEFER overrides. */
1771
1772 else
1773   {
1774   address_item addr2;
1775
1776   /* We must use a copy of the address for verification, because it might
1777   get rewritten. */
1778
1779   addr2 = *addr;
1780   rc = verify_address(&addr2, NULL, verify_options|vopt_is_recipient, callout,
1781     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, NULL);
1782   HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
1783
1784   *log_msgptr = addr2.message;
1785   *user_msgptr = (addr2.user_message != NULL)?
1786     addr2.user_message : addr2.message;
1787   *basic_errno = addr2.basic_errno;
1788
1789   /* Make $address_data visible */
1790   deliver_address_data = addr2.p.address_data;
1791   }
1792
1793 /* We have a result from the relevant test. Handle defer overrides first. */
1794
1795 if (rc == DEFER && (defer_ok ||
1796    (callout_defer_ok && *basic_errno == ERRNO_CALLOUTDEFER)))
1797   {
1798   HDEBUG(D_acl) debug_printf("verify defer overridden by %s\n",
1799     defer_ok? "defer_ok" : "callout_defer_ok");
1800   rc = OK;
1801   }
1802
1803 /* If we've failed a sender, set up a recipient message, and point
1804 sender_verified_failed to the address item that actually failed. */
1805
1806 if (rc != OK && verify_sender_address != NULL)
1807   {
1808   if (rc != DEFER)
1809     {
1810     *log_msgptr = *user_msgptr = US"Sender verify failed";
1811     }
1812   else if (*basic_errno != ERRNO_CALLOUTDEFER)
1813     {
1814     *log_msgptr = *user_msgptr = US"Could not complete sender verify";
1815     }
1816   else
1817     {
1818     *log_msgptr = US"Could not complete sender verify callout";
1819     *user_msgptr = smtp_return_error_details? sender_vaddr->user_message :
1820       *log_msgptr;
1821     }
1822
1823   sender_verified_failed = sender_vaddr;
1824   }
1825
1826 /* Verifying an address messes up the values of $domain and $local_part,
1827 so reset them before returning if this is a RCPT ACL. */
1828
1829 if (addr != NULL)
1830   {
1831   deliver_domain = addr->domain;
1832   deliver_localpart = addr->local_part;
1833   }
1834 return rc;
1835
1836 /* Syntax errors in the verify argument come here. */
1837
1838 BAD_VERIFY:
1839 *log_msgptr = string_sprintf("expected \"sender[=address]\", \"recipient\", "
1840   "\"helo\", \"header_syntax\", \"header_sender\" or "
1841   "\"reverse_host_lookup\" at start of ACL condition "
1842   "\"verify %s\"", arg);
1843 return ERROR;
1844
1845 /* Options supplied when not allowed come here */
1846
1847 NO_OPTIONS:
1848 *log_msgptr = string_sprintf("unexpected '/' found in \"%s\" "
1849   "(this verify item has no options)", arg);
1850 return ERROR;
1851 }
1852
1853
1854
1855
1856 /*************************************************
1857 *        Check argument for control= modifier    *
1858 *************************************************/
1859
1860 /* Called from acl_check_condition() below
1861
1862 Arguments:
1863   arg         the argument string for control=
1864   pptr        set to point to the terminating character
1865   where       which ACL we are in
1866   log_msgptr  for error messages
1867
1868 Returns:      CONTROL_xxx value
1869 */
1870
1871 static int
1872 decode_control(uschar *arg, uschar **pptr, int where, uschar **log_msgptr)
1873 {
1874 int len;
1875 control_def *d;
1876
1877 for (d = controls_list;
1878      d < controls_list + sizeof(controls_list)/sizeof(control_def);
1879      d++)
1880   {
1881   len = Ustrlen(d->name);
1882   if (Ustrncmp(d->name, arg, len) == 0) break;
1883   }
1884
1885 if (d >= controls_list + sizeof(controls_list)/sizeof(control_def) ||
1886    (arg[len] != 0 && (!d->has_option || arg[len] != '/')))
1887   {
1888   *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
1889   return CONTROL_ERROR;
1890   }
1891
1892 *pptr = arg + len;
1893 return d->value;
1894 }
1895
1896
1897
1898 /*************************************************
1899 *            Handle rate limiting                *
1900 *************************************************/
1901
1902 /* Called by acl_check_condition() below to calculate the result
1903 of the ACL ratelimit condition.
1904
1905 Note that the return value might be slightly unexpected: if the
1906 sender's rate is above the limit then the result is OK. This is
1907 similar to the dnslists condition, and is so that you can write
1908 ACL clauses like: defer ratelimit = 15 / 1h
1909
1910 Arguments:
1911   arg         the option string for ratelimit=
1912   log_msgptr  for error messages
1913
1914 Returns:       OK        - Sender's rate is above limit
1915                FAIL      - Sender's rate is below limit
1916                DEFER     - Problem opening ratelimit database
1917                ERROR     - Syntax error in options.
1918 */
1919
1920 static int
1921 acl_ratelimit(uschar *arg, uschar **log_msgptr)
1922 {
1923 double limit, period;
1924 uschar *ss, *key;
1925 int sep = '/';
1926 BOOL have_key = FALSE, leaky = FALSE, strict = FALSE;
1927 BOOL per_byte = FALSE, per_cmd = FALSE, per_conn = FALSE, per_mail = FALSE;
1928 int old_pool, rc;
1929 tree_node **anchor, *t;
1930 open_db dbblock, *dbm;
1931 dbdata_ratelimit *dbd;
1932 struct timeval tv;
1933
1934 /* Parse the first two options and record their values in expansion
1935 variables. These variables allow the configuration to have informative
1936 error messages based on rate limits obtained from a table lookup. */
1937
1938 /* First is the maximum number of messages per period and maximum burst
1939 size, which must be greater than or equal to zero. Zero is useful for
1940 rate measurement as opposed to rate limiting. */
1941
1942 sender_rate_limit = string_nextinlist(&arg, &sep, NULL, 0);
1943 if (sender_rate_limit == NULL)
1944   limit = -1.0;
1945 else
1946   {
1947   limit = Ustrtod(sender_rate_limit, &ss);
1948   if (tolower(*ss) == 'k') { limit *= 1024.0; ss++; }
1949   else if (tolower(*ss) == 'm') { limit *= 1024.0*1024.0; ss++; }
1950   else if (tolower(*ss) == 'g') { limit *= 1024.0*1024.0*1024.0; ss++; }
1951   }
1952 if (limit < 0.0 || *ss != 0)
1953   {
1954   *log_msgptr = string_sprintf("syntax error in argument for "
1955     "\"ratelimit\" condition: \"%s\" is not a positive number",
1956     sender_rate_limit);
1957   return ERROR;
1958   }
1959
1960 /* We use the rest of the argument list following the limit as the
1961 lookup key, because it doesn't make sense to use the same stored data
1962 if the period or options are different. */
1963
1964 key = arg;
1965
1966 /* Second is the rate measurement period and exponential smoothing time
1967 constant. This must be strictly greater than zero, because zero leads to
1968 run-time division errors. */
1969
1970 sender_rate_period = string_nextinlist(&arg, &sep, NULL, 0);
1971 if (sender_rate_period == NULL) period = -1.0;
1972 else period = readconf_readtime(sender_rate_period, 0, FALSE);
1973 if (period <= 0.0)
1974   {
1975   *log_msgptr = string_sprintf("syntax error in argument for "
1976     "\"ratelimit\" condition: \"%s\" is not a time value",
1977     sender_rate_period);
1978   return ERROR;
1979   }
1980
1981 /* Parse the other options. Should we check if the per_* options are being
1982 used in ACLs where they don't make sense, e.g. per_mail in the connect ACL? */
1983
1984 while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
1985        != NULL)
1986   {
1987   if (strcmpic(ss, US"leaky") == 0) leaky = TRUE;
1988   else if (strcmpic(ss, US"strict") == 0) strict = TRUE;
1989   else if (strcmpic(ss, US"per_byte") == 0) per_byte = TRUE;
1990   else if (strcmpic(ss, US"per_cmd") == 0) per_cmd = TRUE;
1991   else if (strcmpic(ss, US"per_conn") == 0) per_conn = TRUE;
1992   else if (strcmpic(ss, US"per_mail") == 0) per_mail = TRUE;
1993   else if (strcmpic(ss, US"per_rcpt") == 0) per_cmd = TRUE; /* alias */
1994   else have_key = TRUE;
1995   }
1996 if (leaky + strict > 1 || per_byte + per_cmd + per_conn + per_mail > 1)
1997   {
1998   *log_msgptr = US"conflicting options for \"ratelimit\" condition";
1999   return ERROR;
2000   }
2001
2002 /* Default option values */
2003 if (!strict) leaky = TRUE;
2004 if (!per_byte && !per_cmd && !per_conn) per_mail = TRUE;
2005
2006 /* If there is no explicit key, use the sender_host_address. If there is no
2007 sender_host_address (e.g. -bs or acl_not_smtp) then we simply omit it. */
2008
2009 if (!have_key && sender_host_address != NULL)
2010   key = string_sprintf("%s / %s", key, sender_host_address);
2011
2012 HDEBUG(D_acl) debug_printf("ratelimit condition limit=%.0f period=%.0f key=%s\n",
2013   limit, period, key);
2014
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 else if (per_mail || per_byte)
2028   anchor = &ratelimiters_mail;
2029 else if (per_cmd)
2030   anchor = &ratelimiters_cmd;
2031
2032 if (anchor != NULL && (t = tree_search(*anchor, key)) != NULL)
2033   {
2034   dbd = t->data.ptr;
2035   /* The following few lines duplicate some of the code below. */
2036   if (dbd->rate < limit) rc = FAIL;
2037     else rc = OK;
2038   store_pool = old_pool;
2039   sender_rate = string_sprintf("%.1f", dbd->rate);
2040   HDEBUG(D_acl)
2041     debug_printf("ratelimit found pre-computed rate %s\n", sender_rate);
2042   return rc;
2043   }
2044
2045 /* We aren't using a pre-computed rate, so get a previously recorded
2046 rate from the database, update it, and write it back. If there's no
2047 previous rate for this key, create one. */
2048
2049 dbm = dbfn_open(US"ratelimit", O_RDWR, &dbblock, TRUE);
2050 if (dbm == NULL)
2051   {
2052   store_pool = old_pool;
2053   sender_rate = NULL;
2054   HDEBUG(D_acl) debug_printf("ratelimit database not available\n");
2055   *log_msgptr = US"ratelimit database not available";
2056   return DEFER;
2057   }
2058 dbd = dbfn_read(dbm, key);
2059
2060 gettimeofday(&tv, NULL);
2061
2062 if (dbd == NULL)
2063   {
2064   HDEBUG(D_acl) debug_printf("ratelimit initializing new key's data\n");
2065   dbd = store_get(sizeof(dbdata_ratelimit));
2066   dbd->time_stamp = tv.tv_sec;
2067   dbd->time_usec = tv.tv_usec;
2068   dbd->rate = 0.0;
2069   }
2070 else
2071   {
2072   /* The smoothed rate is computed using an exponentially weighted moving
2073   average adjusted for variable sampling intervals. The standard EWMA for
2074   a fixed sampling interval is:  f'(t) = (1 - a) * f(t) + a * f'(t - 1)
2075   where f() is the measured value and f'() is the smoothed value.
2076
2077   Old data decays out of the smoothed value exponentially, such that data n
2078   samples old is multiplied by a^n. The exponential decay time constant p
2079   is defined such that data p samples old is multiplied by 1/e, which means
2080   that a = exp(-1/p). We can maintain the same time constant for a variable
2081   sampling interval i by using a = exp(-i/p).
2082
2083   The rate we are measuring is messages per period, suitable for directly
2084   comparing with the limit. The average rate between now and the previous
2085   message is period / interval, which we feed into the EWMA as the sample.
2086
2087   It turns out that the number of messages required for the smoothed rate
2088   to reach the limit when they are sent in a burst is equal to the limit.
2089   This can be seen by analysing the value of the smoothed rate after N
2090   messages sent at even intervals. Let k = (1 - a) * p/i
2091
2092     rate_1 = (1 - a) * p/i + a * rate_0
2093            = k + a * rate_0
2094     rate_2 = k + a * rate_1
2095            = k + a * k + a^2 * rate_0
2096     rate_3 = k + a * k + a^2 * k + a^3 * rate_0
2097     rate_N = rate_0 * a^N + k * SUM(x=0..N-1)(a^x)
2098            = rate_0 * a^N + k * (1 - a^N) / (1 - a)
2099            = rate_0 * a^N + p/i * (1 - a^N)
2100
2101   When N is large, a^N -> 0 so rate_N -> p/i as desired.
2102
2103     rate_N = p/i + (rate_0 - p/i) * a^N
2104     a^N = (rate_N - p/i) / (rate_0 - p/i)
2105     N * -i/p = log((rate_N - p/i) / (rate_0 - p/i))
2106     N = p/i * log((rate_0 - p/i) / (rate_N - p/i))
2107
2108   Numerical analysis of the above equation, setting the computed rate to
2109   increase from rate_0 = 0 to rate_N = limit, shows that for large sending
2110   rates, p/i, the number of messages N = limit. So limit serves as both the
2111   maximum rate measured in messages per period, and the maximum number of
2112   messages that can be sent in a fast burst. */
2113
2114   double this_time = (double)tv.tv_sec
2115                    + (double)tv.tv_usec / 1000000.0;
2116   double prev_time = (double)dbd->time_stamp
2117                    + (double)dbd->time_usec / 1000000.0;
2118   double interval = this_time - prev_time;
2119
2120   double i_over_p = interval / period;
2121   double a = exp(-i_over_p);
2122
2123   /* We must avoid division by zero, and deal gracefully with the clock going
2124   backwards. If we blunder ahead when time is in reverse then the computed
2125   rate will become bogusly huge. Clamp i/p to a very small number instead. */
2126
2127   if (i_over_p <= 0.0) i_over_p = 1e-9;
2128
2129   dbd->time_stamp = tv.tv_sec;
2130   dbd->time_usec = tv.tv_usec;
2131
2132   /* If we are measuring the rate in bytes per period, multiply the
2133   measured rate by the message size. If we don't know the message size
2134   then it's safe to just use a value of zero and let the recorded rate
2135   decay as if nothing happened. */
2136
2137   if (per_byte)
2138     dbd->rate = (message_size < 0 ? 0.0 : (double)message_size)
2139               * (1 - a) / i_over_p + a * dbd->rate;
2140   else
2141     dbd->rate = (1 - a) / i_over_p + a * dbd->rate;
2142   }
2143
2144 /* Clients sending at the limit are considered to be over the limit. This
2145 matters for edge cases such the first message sent by a client (which gets
2146 the initial rate of 0.0) when the rate limit is zero (i.e. the client should
2147 be completely blocked). */
2148
2149 if (dbd->rate < limit) rc = FAIL;
2150   else rc = OK;
2151
2152 /* Update the state if the rate is low or if we are being strict. If we
2153 are in leaky mode and the sender's rate is too high, we do not update
2154 the recorded rate in order to avoid an over-aggressive sender's retry
2155 rate preventing them from getting any email through. */
2156
2157 if (rc == FAIL || !leaky)
2158   dbfn_write(dbm, key, dbd, sizeof(dbdata_ratelimit));
2159 dbfn_close(dbm);
2160
2161 /* Store the result in the tree for future reference, if necessary. */
2162
2163 if (anchor != NULL)
2164   {
2165   t = store_get(sizeof(tree_node) + Ustrlen(key));
2166   t->data.ptr = dbd;
2167   Ustrcpy(t->name, key);
2168   (void)tree_insertnode(anchor, t);
2169   }
2170
2171 /* We create the formatted version of the sender's rate very late in
2172 order to ensure that it is done using the correct storage pool. */
2173
2174 store_pool = old_pool;
2175 sender_rate = string_sprintf("%.1f", dbd->rate);
2176
2177 HDEBUG(D_acl)
2178   debug_printf("ratelimit computed rate %s\n", sender_rate);
2179
2180 return rc;
2181 }
2182
2183
2184
2185 /*************************************************
2186 *   Handle conditions/modifiers on an ACL item   *
2187 *************************************************/
2188
2189 /* Called from acl_check() below.
2190
2191 Arguments:
2192   verb         ACL verb
2193   cb           ACL condition block - if NULL, result is OK
2194   where        where called from
2195   addr         the address being checked for RCPT, or NULL
2196   level        the nesting level
2197   epp          pointer to pass back TRUE if "endpass" encountered
2198                  (applies only to "accept" and "discard")
2199   user_msgptr  user message pointer
2200   log_msgptr   log message pointer
2201   basic_errno  pointer to where to put verify error
2202
2203 Returns:       OK        - all conditions are met
2204                DISCARD   - an "acl" condition returned DISCARD - only allowed
2205                              for "accept" or "discard" verbs
2206                FAIL      - at least one condition fails
2207                FAIL_DROP - an "acl" condition returned FAIL_DROP
2208                DEFER     - can't tell at the moment (typically, lookup defer,
2209                              but can be temporary callout problem)
2210                ERROR     - ERROR from nested ACL or expansion failure or other
2211                              error
2212 */
2213
2214 static int
2215 acl_check_condition(int verb, acl_condition_block *cb, int where,
2216   address_item *addr, int level, BOOL *epp, uschar **user_msgptr,
2217   uschar **log_msgptr, int *basic_errno)
2218 {
2219 uschar *user_message = NULL;
2220 uschar *log_message = NULL;
2221 uschar *p;
2222 int rc = OK;
2223 #ifdef WITH_CONTENT_SCAN
2224 int sep = '/';
2225 #endif
2226
2227 for (; cb != NULL; cb = cb->next)
2228   {
2229   uschar *arg;
2230   int control_type;
2231
2232   /* The message and log_message items set up messages to be used in
2233   case of rejection. They are expanded later. */
2234
2235   if (cb->type == ACLC_MESSAGE)
2236     {
2237     user_message = cb->arg;
2238     continue;
2239     }
2240
2241   if (cb->type == ACLC_LOG_MESSAGE)
2242     {
2243     log_message = cb->arg;
2244     continue;
2245     }
2246
2247   /* The endpass "condition" just sets a flag to show it occurred. This is
2248   checked at compile time to be on an "accept" or "discard" item. */
2249
2250   if (cb->type == ACLC_ENDPASS)
2251     {
2252     *epp = TRUE;
2253     continue;
2254     }
2255
2256   /* For other conditions and modifiers, the argument is expanded now for some
2257   of them, but not for all, because expansion happens down in some lower level
2258   checking functions in some cases. */
2259
2260   if (cond_expand_at_top[cb->type])
2261     {
2262     arg = expand_string(cb->arg);
2263     if (arg == NULL)
2264       {
2265       if (expand_string_forcedfail) continue;
2266       *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
2267         cb->arg, expand_string_message);
2268       return search_find_defer? DEFER : ERROR;
2269       }
2270     }
2271   else arg = cb->arg;
2272
2273   /* Show condition, and expanded condition if it's different */
2274
2275   HDEBUG(D_acl)
2276     {
2277     int lhswidth = 0;
2278     debug_printf("check %s%s %n",
2279       (!cond_modifiers[cb->type] && cb->u.negated)? "!":"",
2280       conditions[cb->type], &lhswidth);
2281
2282     if (cb->type == ACLC_SET)
2283       {
2284       int n = cb->u.varnumber;
2285       int t = (n < ACL_C_MAX)? 'c' : 'm';
2286       if (n >= ACL_C_MAX) n -= ACL_C_MAX;
2287       debug_printf("acl_%c%d ", t, n);
2288       lhswidth += 7;
2289       }
2290
2291     debug_printf("= %s\n", cb->arg);
2292
2293     if (arg != cb->arg)
2294       debug_printf("%.*s= %s\n", lhswidth,
2295       US"                             ", CS arg);
2296     }
2297
2298   /* Check that this condition makes sense at this time */
2299
2300   if ((cond_forbids[cb->type] & (1 << where)) != 0)
2301     {
2302     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
2303       cond_modifiers[cb->type]? "use" : "test",
2304       conditions[cb->type], acl_wherenames[where]);
2305     return ERROR;
2306     }
2307
2308   /* Run the appropriate test for each condition, or take the appropriate
2309   action for the remaining modifiers. */
2310
2311   switch(cb->type)
2312     {
2313     /* A nested ACL that returns "discard" makes sense only for an "accept" or
2314     "discard" verb. */
2315
2316     case ACLC_ACL:
2317     rc = acl_check_internal(where, addr, arg, level+1, user_msgptr, log_msgptr);
2318     if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
2319       {
2320       *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
2321         "\"%s\" command (only allowed with \"accept\" or \"discard\")",
2322         verbs[verb]);
2323       return ERROR;
2324       }
2325     break;
2326
2327     case ACLC_AUTHENTICATED:
2328     rc = (sender_host_authenticated == NULL)? FAIL :
2329       match_isinlist(sender_host_authenticated, &arg, 0, NULL, NULL, MCL_STRING,
2330         TRUE, NULL);
2331     break;
2332
2333 #ifdef EXPERIMENTAL_BRIGHTMAIL
2334     case ACLC_BMI_OPTIN:
2335       {
2336       int old_pool = store_pool;
2337       store_pool = POOL_PERM;
2338       bmi_current_optin = string_copy(arg);
2339       store_pool = old_pool;
2340       }
2341     break;
2342 #endif
2343
2344     case ACLC_CONDITION:
2345     if (Ustrspn(arg, "0123456789") == Ustrlen(arg))     /* Digits, or empty */
2346       rc = (Uatoi(arg) == 0)? FAIL : OK;
2347     else
2348       rc = (strcmpic(arg, US"no") == 0 ||
2349             strcmpic(arg, US"false") == 0)? FAIL :
2350            (strcmpic(arg, US"yes") == 0 ||
2351             strcmpic(arg, US"true") == 0)? OK : DEFER;
2352     if (rc == DEFER)
2353       *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
2354     break;
2355
2356     case ACLC_CONTROL:
2357     control_type = decode_control(arg, &p, where, log_msgptr);
2358
2359     /* Check if this control makes sense at this time */
2360
2361     if ((control_forbids[control_type] & (1 << where)) != 0)
2362       {
2363       *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
2364         controls[control_type], acl_wherenames[where]);
2365       return ERROR;
2366       }
2367
2368     switch(control_type)
2369       {
2370 #ifdef EXPERIMENTAL_BRIGHTMAIL
2371       case CONTROL_BMI_RUN:
2372       bmi_run = 1;
2373       break;
2374 #endif
2375 #ifdef EXPERIMENTAL_DOMAINKEYS
2376       case CONTROL_DK_VERIFY:
2377       dk_do_verify = 1;
2378       break;
2379 #endif
2380       case CONTROL_ERROR:
2381       return ERROR;
2382
2383       case CONTROL_CASEFUL_LOCAL_PART:
2384       deliver_localpart = addr->cc_local_part;
2385       break;
2386
2387       case CONTROL_CASELOWER_LOCAL_PART:
2388       deliver_localpart = addr->lc_local_part;
2389       break;
2390
2391       case CONTROL_ENFORCE_SYNC:
2392       smtp_enforce_sync = TRUE;
2393       break;
2394
2395       case CONTROL_NO_ENFORCE_SYNC:
2396       smtp_enforce_sync = FALSE;
2397       break;
2398
2399 #ifdef WITH_CONTENT_SCAN
2400       case CONTROL_NO_MBOX_UNSPOOL:
2401       no_mbox_unspool = TRUE;
2402       break;
2403 #endif
2404
2405       case CONTROL_NO_MULTILINE:
2406       no_multiline_responses = TRUE;
2407       break;
2408
2409       case CONTROL_FAKEDEFER:
2410       case CONTROL_FAKEREJECT:
2411       fake_response = (control_type == CONTROL_FAKEDEFER) ? DEFER : FAIL;
2412       if (*p == '/')
2413         {
2414         uschar *pp = p + 1;
2415         while (*pp != 0) pp++;
2416         fake_response_text = expand_string(string_copyn(p+1, pp-p-1));
2417         p = pp;
2418         }
2419        else
2420         {
2421         /* Explicitly reset to default string */
2422         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).";
2423         }
2424       break;
2425
2426       case CONTROL_FREEZE:
2427       deliver_freeze = TRUE;
2428       deliver_frozen_at = time(NULL);
2429       break;
2430
2431       case CONTROL_QUEUE_ONLY:
2432       queue_only_policy = TRUE;
2433       break;
2434
2435       case CONTROL_SUBMISSION:
2436       originator_name = US"";
2437       submission_mode = TRUE;
2438       while (*p == '/')
2439         {
2440         if (Ustrncmp(p, "/sender_retain", 14) == 0)
2441           {
2442           p += 14;
2443           active_local_sender_retain = TRUE;
2444           active_local_from_check = FALSE;
2445           }
2446         else if (Ustrncmp(p, "/domain=", 8) == 0)
2447           {
2448           uschar *pp = p + 8;
2449           while (*pp != 0 && *pp != '/') pp++;
2450           submission_domain = string_copyn(p+8, pp-p-8);
2451           p = pp;
2452           }
2453         else if (Ustrncmp(p, "/name=", 6) == 0)
2454           {
2455           uschar *pp = p + 6;
2456           while (*pp != 0 && *pp != '/') pp++;
2457           originator_name = string_copy(parse_fix_phrase(p+6, pp-p-6,
2458             big_buffer, big_buffer_size));
2459           p = pp;
2460           }
2461         else break;
2462         }
2463       if (*p != 0)
2464         {
2465         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
2466         return ERROR;
2467         }
2468       break;
2469       }
2470     break;
2471
2472 #ifdef WITH_CONTENT_SCAN
2473     case ACLC_DECODE:
2474     rc = mime_decode(&arg);
2475     break;
2476 #endif
2477
2478     case ACLC_DELAY:
2479       {
2480       int delay = readconf_readtime(arg, 0, FALSE);
2481       if (delay < 0)
2482         {
2483         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
2484           "modifier: \"%s\" is not a time value", arg);
2485         return ERROR;
2486         }
2487       else
2488         {
2489         HDEBUG(D_acl) debug_printf("delay modifier requests %d-second delay\n",
2490           delay);
2491         if (host_checking)
2492           {
2493           HDEBUG(D_acl)
2494             debug_printf("delay skipped in -bh checking mode\n");
2495           }
2496
2497         /* It appears to be impossible to detect that a TCP/IP connection has
2498         gone away without reading from it. This means that we cannot shorten
2499         the delay below if the client goes away, because we cannot discover
2500         that the client has closed its end of the connection. (The connection
2501         is actually in a half-closed state, waiting for the server to close its
2502         end.) It would be nice to be able to detect this state, so that the
2503         Exim process is not held up unnecessarily. However, it seems that we
2504         can't. The poll() function does not do the right thing, and in any case
2505         it is not always available.
2506
2507         NOTE: If ever this state of affairs changes, remember that we may be
2508         dealing with stdin/stdout here, in addition to TCP/IP connections.
2509         Whatever is done must work in both cases. To detected the stdin/stdout
2510         case, check for smtp_in or smtp_out being NULL. */
2511
2512         else
2513           {
2514           while (delay > 0) delay = sleep(delay);
2515           }
2516         }
2517       }
2518     break;
2519
2520 #ifdef WITH_OLD_DEMIME
2521     case ACLC_DEMIME:
2522       rc = demime(&arg);
2523     break;
2524 #endif
2525
2526 #ifdef EXPERIMENTAL_DOMAINKEYS
2527   case ACLC_DK_DOMAIN_SOURCE:
2528     if (dk_verify_block == NULL) { rc = FAIL; break; };
2529     /* check header source of domain against given string */
2530     switch (dk_verify_block->address_source) {
2531       case DK_EXIM_ADDRESS_FROM_FROM:
2532         rc = match_isinlist(US"from", &arg, 0, NULL,
2533                             NULL, MCL_STRING, TRUE, NULL);
2534       break;
2535       case DK_EXIM_ADDRESS_FROM_SENDER:
2536         rc = match_isinlist(US"sender", &arg, 0, NULL,
2537                             NULL, MCL_STRING, TRUE, NULL);
2538       break;
2539       case DK_EXIM_ADDRESS_NONE:
2540         rc = match_isinlist(US"none", &arg, 0, NULL,
2541                             NULL, MCL_STRING, TRUE, NULL);
2542       break;
2543     }
2544   break;
2545   case ACLC_DK_POLICY:
2546     if (dk_verify_block == NULL) { rc = FAIL; break; };
2547     /* check policy against given string, default FAIL */
2548     rc = FAIL;
2549     if (dk_verify_block->signsall)
2550       rc = match_isinlist(US"signsall", &arg, 0, NULL,
2551                           NULL, MCL_STRING, TRUE, NULL);
2552     if (dk_verify_block->testing)
2553       rc = match_isinlist(US"testing", &arg, 0, NULL,
2554                           NULL, MCL_STRING, TRUE, NULL);
2555   break;
2556   case ACLC_DK_SENDER_DOMAINS:
2557     if (dk_verify_block == NULL) { rc = FAIL; break; };
2558     if (dk_verify_block->domain != NULL)
2559       rc = match_isinlist(dk_verify_block->domain, &arg, 0, &domainlist_anchor,
2560                           NULL, MCL_DOMAIN, TRUE, NULL);
2561     else rc = FAIL;
2562   break;
2563   case ACLC_DK_SENDER_LOCAL_PARTS:
2564     if (dk_verify_block == NULL) { rc = FAIL; break; };
2565     if (dk_verify_block->local_part != NULL)
2566       rc = match_isinlist(dk_verify_block->local_part, &arg, 0, &localpartlist_anchor,
2567                           NULL, MCL_LOCALPART, TRUE, NULL);
2568     else rc = FAIL;
2569   break;
2570   case ACLC_DK_SENDERS:
2571     if (dk_verify_block == NULL) { rc = FAIL; break; };
2572     if (dk_verify_block->address != NULL)
2573       rc = match_address_list(dk_verify_block->address, TRUE, TRUE, &arg, NULL, -1, 0, NULL);
2574     else rc = FAIL;
2575   break;
2576   case ACLC_DK_STATUS:
2577     if (dk_verify_block == NULL) { rc = FAIL; break; };
2578     if (dk_verify_block->result > 0) {
2579       switch(dk_verify_block->result) {
2580         case DK_EXIM_RESULT_BAD_FORMAT:
2581           rc = match_isinlist(US"bad format", &arg, 0, NULL,
2582                               NULL, MCL_STRING, TRUE, NULL);
2583         break;
2584         case DK_EXIM_RESULT_NO_KEY:
2585           rc = match_isinlist(US"no key", &arg, 0, NULL,
2586                               NULL, MCL_STRING, TRUE, NULL);
2587         break;
2588         case DK_EXIM_RESULT_NO_SIGNATURE:
2589           rc = match_isinlist(US"no signature", &arg, 0, NULL,
2590                               NULL, MCL_STRING, TRUE, NULL);
2591         break;
2592         case DK_EXIM_RESULT_REVOKED:
2593           rc = match_isinlist(US"revoked", &arg, 0, NULL,
2594                               NULL, MCL_STRING, TRUE, NULL);
2595         break;
2596         case DK_EXIM_RESULT_NON_PARTICIPANT:
2597           rc = match_isinlist(US"non-participant", &arg, 0, NULL,
2598                               NULL, MCL_STRING, TRUE, NULL);
2599         break;
2600         case DK_EXIM_RESULT_GOOD:
2601           rc = match_isinlist(US"good", &arg, 0, NULL,
2602                               NULL, MCL_STRING, TRUE, NULL);
2603         break;
2604         case DK_EXIM_RESULT_BAD:
2605           rc = match_isinlist(US"bad", &arg, 0, NULL,
2606                               NULL, MCL_STRING, TRUE, NULL);
2607         break;
2608       }
2609     }
2610   break;
2611 #endif
2612
2613     case ACLC_DNSLISTS:
2614     rc = verify_check_dnsbl(&arg);
2615     break;
2616
2617     case ACLC_DOMAINS:
2618     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
2619       addr->domain_cache, MCL_DOMAIN, TRUE, &deliver_domain_data);
2620     break;
2621
2622     /* The value in tls_cipher is the full cipher name, for example,
2623     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
2624     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
2625     what may in practice come out of the SSL library - which at the time of
2626     writing is poorly documented. */
2627
2628     case ACLC_ENCRYPTED:
2629     if (tls_cipher == NULL) rc = FAIL; else
2630       {
2631       uschar *endcipher = NULL;
2632       uschar *cipher = Ustrchr(tls_cipher, ':');
2633       if (cipher == NULL) cipher = tls_cipher; else
2634         {
2635         endcipher = Ustrchr(++cipher, ':');
2636         if (endcipher != NULL) *endcipher = 0;
2637         }
2638       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
2639       if (endcipher != NULL) *endcipher = ':';
2640       }
2641     break;
2642
2643     /* Use verify_check_this_host() instead of verify_check_host() so that
2644     we can pass over &host_data to catch any looked up data. Once it has been
2645     set, it retains its value so that it's still there if another ACL verb
2646     comes through here and uses the cache. However, we must put it into
2647     permanent store in case it is also expected to be used in a subsequent
2648     message in the same SMTP connection. */
2649
2650     case ACLC_HOSTS:
2651     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
2652       (sender_host_address == NULL)? US"" : sender_host_address, &host_data);
2653     if (host_data != NULL) host_data = string_copy_malloc(host_data);
2654     break;
2655
2656     case ACLC_LOCAL_PARTS:
2657     rc = match_isinlist(addr->cc_local_part, &arg, 0,
2658       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
2659       &deliver_localpart_data);
2660     break;
2661
2662     case ACLC_LOGWRITE:
2663       {
2664       int logbits = 0;
2665       uschar *s = arg;
2666       if (*s == ':')
2667         {
2668         s++;
2669         while (*s != ':')
2670           {
2671           if (Ustrncmp(s, "main", 4) == 0)
2672             { logbits |= LOG_MAIN; s += 4; }
2673           else if (Ustrncmp(s, "panic", 5) == 0)
2674             { logbits |= LOG_PANIC; s += 5; }
2675           else if (Ustrncmp(s, "reject", 6) == 0)
2676             { logbits |= LOG_REJECT; s += 6; }
2677           else
2678             {
2679             logbits = LOG_MAIN|LOG_PANIC;
2680             s = string_sprintf(":unknown log name in \"%s\" in "
2681               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
2682             }
2683           if (*s == ',') s++;
2684           }
2685         s++;
2686         }
2687       while (isspace(*s)) s++;
2688       if (logbits == 0) logbits = LOG_MAIN;
2689       log_write(0, logbits, "%s", string_printing(s));
2690       }
2691     break;
2692
2693 #ifdef WITH_CONTENT_SCAN
2694     case ACLC_MALWARE:
2695       {
2696       /* Seperate the regular expression and any optional parameters. */
2697       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
2698       /* Run the malware backend. */
2699       rc = malware(&ss);
2700       /* Modify return code based upon the existance of options. */
2701       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
2702             != NULL) {
2703         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
2704           {
2705           /* FAIL so that the message is passed to the next ACL */
2706           rc = FAIL;
2707           }
2708         }
2709       }
2710     break;
2711
2712     case ACLC_MIME_REGEX:
2713       rc = mime_regex(&arg);
2714     break;
2715 #endif
2716
2717     case ACLC_RATELIMIT:
2718       rc = acl_ratelimit(arg, log_msgptr);
2719     break;
2720
2721     case ACLC_RECIPIENTS:
2722     rc = match_address_list(addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
2723       &recipient_data);
2724     break;
2725
2726 #ifdef WITH_CONTENT_SCAN
2727    case ACLC_REGEX:
2728       rc = regex(&arg);
2729     break;
2730 #endif
2731
2732     case ACLC_SENDER_DOMAINS:
2733       {
2734       uschar *sdomain;
2735       sdomain = Ustrrchr(sender_address, '@');
2736       sdomain = (sdomain == NULL)? US"" : sdomain + 1;
2737       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
2738         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
2739       }
2740     break;
2741
2742     case ACLC_SENDERS:
2743     rc = match_address_list(sender_address, TRUE, TRUE, &arg,
2744       sender_address_cache, -1, 0, &sender_data);
2745     break;
2746
2747     /* Connection variables must persist forever */
2748
2749     case ACLC_SET:
2750       {
2751       int old_pool = store_pool;
2752       if (cb->u.varnumber < ACL_C_MAX) store_pool = POOL_PERM;
2753       acl_var[cb->u.varnumber] = string_copy(arg);
2754       store_pool = old_pool;
2755       }
2756     break;
2757
2758 #ifdef WITH_CONTENT_SCAN
2759     case ACLC_SPAM:
2760       {
2761       /* Seperate the regular expression and any optional parameters. */
2762       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
2763       /* Run the spam backend. */
2764       rc = spam(&ss);
2765       /* Modify return code based upon the existance of options. */
2766       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
2767             != NULL) {
2768         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
2769           {
2770           /* FAIL so that the message is passed to the next ACL */
2771           rc = FAIL;
2772           }
2773         }
2774       }
2775     break;
2776 #endif
2777
2778 #ifdef EXPERIMENTAL_SPF
2779     case ACLC_SPF:
2780       rc = spf_process(&arg, sender_address);
2781     break;
2782 #endif
2783
2784     /* If the verb is WARN, discard any user message from verification, because
2785     such messages are SMTP responses, not header additions. The latter come
2786     only from explicit "message" modifiers. However, put the user message into
2787     $acl_verify_message so it can be used in subsequent conditions or modifiers
2788     (until something changes it). */
2789
2790     case ACLC_VERIFY:
2791     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
2792     acl_verify_message = *user_msgptr;
2793     if (verb == ACL_WARN) *user_msgptr = NULL;
2794     break;
2795
2796     default:
2797     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
2798       "condition %d", cb->type);
2799     break;
2800     }
2801
2802   /* If a condition was negated, invert OK/FAIL. */
2803
2804   if (!cond_modifiers[cb->type] && cb->u.negated)
2805     {
2806     if (rc == OK) rc = FAIL;
2807       else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
2808     }
2809
2810   if (rc != OK) break;   /* Conditions loop */
2811   }
2812
2813
2814 /* If the result is the one for which "message" and/or "log_message" are used,
2815 handle the values of these options. Most verbs have but a single return for
2816 which the messages are relevant, but for "discard", it's useful to have the log
2817 message both when it succeeds and when it fails. Also, for an "accept" that
2818 appears in a QUIT ACL, we want to handle the user message. Since only "accept"
2819 and "warn" are permitted in that ACL, we don't need to test the verb.
2820
2821 These modifiers act in different ways:
2822
2823 "message" is a user message that will be included in an SMTP response. Unless
2824 it is empty, it overrides any previously set user message.
2825
2826 "log_message" is a non-user message, and it adds to any existing non-user
2827 message that is already set.
2828
2829 If there isn't a log message set, we make it the same as the user message. */
2830
2831 if (((rc == FAIL_DROP)? FAIL : rc) == msgcond[verb] ||
2832     (verb == ACL_DISCARD && rc == OK) ||
2833     (where == ACL_WHERE_QUIT))
2834   {
2835   uschar *expmessage;
2836
2837   /* If the verb is "warn", messages generated by conditions (verification or
2838   nested ACLs) are discarded. Only messages specified at this level are used.
2839   However, the value of an existing message is available in $acl_verify_message
2840   during expansions. */
2841
2842   uschar *old_user_msgptr = *user_msgptr;
2843   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
2844
2845   if (verb == ACL_WARN) *log_msgptr = *user_msgptr = NULL;
2846
2847   if (user_message != NULL)
2848     {
2849     acl_verify_message = old_user_msgptr;
2850     expmessage = expand_string(user_message);
2851     if (expmessage == NULL)
2852       {
2853       if (!expand_string_forcedfail)
2854         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
2855           user_message, expand_string_message);
2856       }
2857     else if (expmessage[0] != 0) *user_msgptr = expmessage;
2858     }
2859
2860   if (log_message != NULL)
2861     {
2862     acl_verify_message = old_log_msgptr;
2863     expmessage = expand_string(log_message);
2864     if (expmessage == NULL)
2865       {
2866       if (!expand_string_forcedfail)
2867         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
2868           log_message, expand_string_message);
2869       }
2870     else if (expmessage[0] != 0)
2871       {
2872       *log_msgptr = (*log_msgptr == NULL)? expmessage :
2873         string_sprintf("%s: %s", expmessage, *log_msgptr);
2874       }
2875     }
2876
2877   /* If no log message, default it to the user message */
2878
2879   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
2880   }
2881
2882 acl_verify_message = NULL;
2883 return rc;
2884 }
2885
2886
2887
2888
2889
2890 /*************************************************
2891 *        Get line from a literal ACL             *
2892 *************************************************/
2893
2894 /* This function is passed to acl_read() in order to extract individual lines
2895 of a literal ACL, which we access via static pointers. We can destroy the
2896 contents because this is called only once (the compiled ACL is remembered).
2897
2898 This code is intended to treat the data in the same way as lines in the main
2899 Exim configuration file. That is:
2900
2901   . Leading spaces are ignored.
2902
2903   . A \ at the end of a line is a continuation - trailing spaces after the \
2904     are permitted (this is because I don't believe in making invisible things
2905     significant). Leading spaces on the continued part of a line are ignored.
2906
2907   . Physical lines starting (significantly) with # are totally ignored, and
2908     may appear within a sequence of backslash-continued lines.
2909
2910   . Blank lines are ignored, but will end a sequence of continuations.
2911
2912 Arguments: none
2913 Returns:   a pointer to the next line
2914 */
2915
2916
2917 static uschar *acl_text;          /* Current pointer in the text */
2918 static uschar *acl_text_end;      /* Points one past the terminating '0' */
2919
2920
2921 static uschar *
2922 acl_getline(void)
2923 {
2924 uschar *yield;
2925
2926 /* This loop handles leading blank lines and comments. */
2927
2928 for(;;)
2929   {
2930   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
2931   if (*acl_text == 0) return NULL;         /* No more data */
2932   yield = acl_text;                        /* Potential data line */
2933
2934   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
2935
2936   /* If we hit the end before a newline, we have the whole logical line. If
2937   it's a comment, there's no more data to be given. Otherwise, yield it. */
2938
2939   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
2940
2941   /* After reaching a newline, end this loop if the physical line does not
2942   start with '#'. If it does, it's a comment, and the loop continues. */
2943
2944   if (*yield != '#') break;
2945   }
2946
2947 /* This loop handles continuations. We know we have some real data, ending in
2948 newline. See if there is a continuation marker at the end (ignoring trailing
2949 white space). We know that *yield is not white space, so no need to test for
2950 cont > yield in the backwards scanning loop. */
2951
2952 for(;;)
2953   {
2954   uschar *cont;
2955   for (cont = acl_text - 1; isspace(*cont); cont--);
2956
2957   /* If no continuation follows, we are done. Mark the end of the line and
2958   return it. */
2959
2960   if (*cont != '\\')
2961     {
2962     *acl_text++ = 0;
2963     return yield;
2964     }
2965
2966   /* We have encountered a continuation. Skip over whitespace at the start of
2967   the next line, and indeed the whole of the next line or lines if they are
2968   comment lines. */
2969
2970   for (;;)
2971     {
2972     while (*(++acl_text) == ' ' || *acl_text == '\t');
2973     if (*acl_text != '#') break;
2974     while (*(++acl_text) != 0 && *acl_text != '\n');
2975     }
2976
2977   /* We have the start of a continuation line. Move all the rest of the data
2978   to join onto the previous line, and then find its end. If the end is not a
2979   newline, we are done. Otherwise loop to look for another continuation. */
2980
2981   memmove(cont, acl_text, acl_text_end - acl_text);
2982   acl_text_end -= acl_text - cont;
2983   acl_text = cont;
2984   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
2985   if (*acl_text == 0) return yield;
2986   }
2987
2988 /* Control does not reach here */
2989 }
2990
2991
2992
2993
2994
2995 /*************************************************
2996 *        Check access using an ACL               *
2997 *************************************************/
2998
2999 /* This function is called from address_check. It may recurse via
3000 acl_check_condition() - hence the use of a level to stop looping. The ACL is
3001 passed as a string which is expanded. A forced failure implies no access check
3002 is required. If the result is a single word, it is taken as the name of an ACL
3003 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
3004 text, complete with newlines, and parsed as such. In both cases, the ACL check
3005 is then run. This function uses an auxiliary function for acl_read() to call
3006 for reading individual lines of a literal ACL. This is acl_getline(), which
3007 appears immediately above.
3008
3009 Arguments:
3010   where        where called from
3011   addr         address item when called from RCPT; otherwise NULL
3012   s            the input string; NULL is the same as an empty ACL => DENY
3013   level        the nesting level
3014   user_msgptr  where to put a user error (for SMTP response)
3015   log_msgptr   where to put a logging message (not for SMTP response)
3016
3017 Returns:       OK         access is granted
3018                DISCARD    access is apparently granted...
3019                FAIL       access is denied
3020                FAIL_DROP  access is denied; drop the connection
3021                DEFER      can't tell at the moment
3022                ERROR      disaster
3023 */
3024
3025 static int
3026 acl_check_internal(int where, address_item *addr, uschar *s, int level,
3027   uschar **user_msgptr, uschar **log_msgptr)
3028 {
3029 int fd = -1;
3030 acl_block *acl = NULL;
3031 uschar *acl_name = US"inline ACL";
3032 uschar *ss;
3033
3034 /* Catch configuration loops */
3035
3036 if (level > 20)
3037   {
3038   *log_msgptr = US"ACL nested too deep: possible loop";
3039   return ERROR;
3040   }
3041
3042 if (s == NULL)
3043   {
3044   HDEBUG(D_acl) debug_printf("ACL is NULL: implicit DENY\n");
3045   return FAIL;
3046   }
3047
3048 /* At top level, we expand the incoming string. At lower levels, it has already
3049 been expanded as part of condition processing. */
3050
3051 if (level == 0)
3052   {
3053   ss = expand_string(s);
3054   if (ss == NULL)
3055     {
3056     if (expand_string_forcedfail) return OK;
3057     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
3058       expand_string_message);
3059     return ERROR;
3060     }
3061   }
3062 else ss = s;
3063
3064 while (isspace(*ss))ss++;
3065
3066 /* If we can't find a named ACL, the default is to parse it as an inline one.
3067 (Unless it begins with a slash; non-existent files give rise to an error.) */
3068
3069 acl_text = ss;
3070
3071 /* Handle the case of a string that does not contain any spaces. Look for a
3072 named ACL among those read from the configuration, or a previously read file.
3073 It is possible that the pointer to the ACL is NULL if the configuration
3074 contains a name with no data. If not found, and the text begins with '/',
3075 read an ACL from a file, and save it so it can be re-used. */
3076
3077 if (Ustrchr(ss, ' ') == NULL)
3078   {
3079   tree_node *t = tree_search(acl_anchor, ss);
3080   if (t != NULL)
3081     {
3082     acl = (acl_block *)(t->data.ptr);
3083     if (acl == NULL)
3084       {
3085       HDEBUG(D_acl) debug_printf("ACL \"%s\" is empty: implicit DENY\n", ss);
3086       return FAIL;
3087       }
3088     acl_name = string_sprintf("ACL \"%s\"", ss);
3089     HDEBUG(D_acl) debug_printf("using ACL \"%s\"\n", ss);
3090     }
3091
3092   else if (*ss == '/')
3093     {
3094     struct stat statbuf;
3095     fd = Uopen(ss, O_RDONLY, 0);
3096     if (fd < 0)
3097       {
3098       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
3099         strerror(errno));
3100       return ERROR;
3101       }
3102
3103     if (fstat(fd, &statbuf) != 0)
3104       {
3105       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
3106         strerror(errno));
3107       return ERROR;
3108       }
3109
3110     acl_text = store_get(statbuf.st_size + 1);
3111     acl_text_end = acl_text + statbuf.st_size + 1;
3112
3113     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
3114       {
3115       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
3116         ss, strerror(errno));
3117       return ERROR;
3118       }
3119     acl_text[statbuf.st_size] = 0;
3120     close(fd);
3121
3122     acl_name = string_sprintf("ACL \"%s\"", ss);
3123     HDEBUG(D_acl) debug_printf("read ACL from file %s\n", ss);
3124     }
3125   }
3126
3127 /* Parse an ACL that is still in text form. If it came from a file, remember it
3128 in the ACL tree, having read it into the POOL_PERM store pool so that it
3129 persists between multiple messages. */
3130
3131 if (acl == NULL)
3132   {
3133   int old_pool = store_pool;
3134   if (fd >= 0) store_pool = POOL_PERM;
3135   acl = acl_read(acl_getline, log_msgptr);
3136   store_pool = old_pool;
3137   if (acl == NULL && *log_msgptr != NULL) return ERROR;
3138   if (fd >= 0)
3139     {
3140     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
3141     Ustrcpy(t->name, ss);
3142     t->data.ptr = acl;
3143     (void)tree_insertnode(&acl_anchor, t);
3144     }
3145   }
3146
3147 /* Now we have an ACL to use. It's possible it may be NULL. */
3148
3149 while (acl != NULL)
3150   {
3151   int cond;
3152   int basic_errno = 0;
3153   BOOL endpass_seen = FALSE;
3154
3155   *log_msgptr = *user_msgptr = NULL;
3156   acl_temp_details = FALSE;
3157
3158   if (where == ACL_WHERE_QUIT &&
3159       acl->verb != ACL_ACCEPT &&
3160       acl->verb != ACL_WARN)
3161     {
3162     *log_msgptr = string_sprintf("\"%s\" is not allowed in a QUIT ACL",
3163       verbs[acl->verb]);
3164     return ERROR;
3165     }
3166
3167   HDEBUG(D_acl) debug_printf("processing \"%s\"\n", verbs[acl->verb]);
3168
3169   /* Clear out any search error message from a previous check before testing
3170   this condition. */
3171
3172   search_error_message = NULL;
3173   cond = acl_check_condition(acl->verb, acl->condition, where, addr, level,
3174     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
3175
3176   /* Handle special returns: DEFER causes a return except on a WARN verb;
3177   ERROR always causes a return. */
3178
3179   switch (cond)
3180     {
3181     case DEFER:
3182     HDEBUG(D_acl) debug_printf("%s: condition test deferred\n", verbs[acl->verb]);
3183     if (basic_errno != ERRNO_CALLOUTDEFER)
3184       {
3185       if (search_error_message != NULL && *search_error_message != 0)
3186         *log_msgptr = search_error_message;
3187       if (smtp_return_error_details) acl_temp_details = TRUE;
3188       }
3189     else
3190       {
3191       acl_temp_details = TRUE;
3192       }
3193     if (acl->verb != ACL_WARN) return DEFER;
3194     break;
3195
3196     default:      /* Paranoia */
3197     case ERROR:
3198     HDEBUG(D_acl) debug_printf("%s: condition test error\n", verbs[acl->verb]);
3199     return ERROR;
3200
3201     case OK:
3202     HDEBUG(D_acl) debug_printf("%s: condition test succeeded\n",
3203       verbs[acl->verb]);
3204     break;
3205
3206     case FAIL:
3207     HDEBUG(D_acl) debug_printf("%s: condition test failed\n", verbs[acl->verb]);
3208     break;
3209
3210     /* DISCARD and DROP can happen only from a nested ACL condition, and
3211     DISCARD can happen only for an "accept" or "discard" verb. */
3212
3213     case DISCARD:
3214     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"discard\"\n",
3215       verbs[acl->verb]);
3216     break;
3217
3218     case FAIL_DROP:
3219     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"drop\"\n",
3220       verbs[acl->verb]);
3221     break;
3222     }
3223
3224   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
3225   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
3226   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
3227
3228   switch(acl->verb)
3229     {
3230     case ACL_ACCEPT:
3231     if (cond == OK || cond == DISCARD) return cond;
3232     if (endpass_seen)
3233       {
3234       HDEBUG(D_acl) debug_printf("accept: endpass encountered - denying access\n");
3235       return cond;
3236       }
3237     break;
3238
3239     case ACL_DEFER:
3240     if (cond == OK)
3241       {
3242       acl_temp_details = TRUE;
3243       return DEFER;
3244       }
3245     break;
3246
3247     case ACL_DENY:
3248     if (cond == OK) return FAIL;
3249     break;
3250
3251     case ACL_DISCARD:
3252     if (cond == OK || cond == DISCARD) return DISCARD;
3253     if (endpass_seen)
3254       {
3255       HDEBUG(D_acl) debug_printf("discard: endpass encountered - denying access\n");
3256       return cond;
3257       }
3258     break;
3259
3260     case ACL_DROP:
3261     if (cond == OK) return FAIL_DROP;
3262     break;
3263
3264     case ACL_REQUIRE:
3265     if (cond != OK) return cond;
3266     break;
3267
3268     case ACL_WARN:
3269     if (cond == OK)
3270       acl_warn(where, *user_msgptr, *log_msgptr);
3271     else if (cond == DEFER)
3272       log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
3273         "condition test deferred%s%s", host_and_ident(TRUE),
3274         (*log_msgptr == NULL)? US"" : US": ",
3275         (*log_msgptr == NULL)? US"" : *log_msgptr);
3276     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
3277     break;
3278
3279     default:
3280     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
3281       acl->verb);
3282     break;
3283     }
3284
3285   /* Pass to the next ACL item */
3286
3287   acl = acl->next;
3288   }
3289
3290 /* We have reached the end of the ACL. This is an implicit DENY. */
3291
3292 HDEBUG(D_acl) debug_printf("end of %s: implicit DENY\n", acl_name);
3293 return FAIL;
3294 }
3295
3296
3297 /*************************************************
3298 *        Check access using an ACL               *
3299 *************************************************/
3300
3301 /* This is the external interface for ACL checks. It sets up an address and the
3302 expansions for $domain and $local_part when called after RCPT, then calls
3303 acl_check_internal() to do the actual work.
3304
3305 Arguments:
3306   where        ACL_WHERE_xxxx indicating where called from
3307   data_string  RCPT address, or SMTP command argument, or NULL
3308   s            the input string; NULL is the same as an empty ACL => DENY
3309   user_msgptr  where to put a user error (for SMTP response)
3310   log_msgptr   where to put a logging message (not for SMTP response)
3311
3312 Returns:       OK         access is granted by an ACCEPT verb
3313                DISCARD    access is granted by a DISCARD verb
3314                FAIL       access is denied
3315                FAIL_DROP  access is denied; drop the connection
3316                DEFER      can't tell at the moment
3317                ERROR      disaster
3318 */
3319
3320 int
3321 acl_check(int where, uschar *data_string, uschar *s, uschar **user_msgptr,
3322   uschar **log_msgptr)
3323 {
3324 int rc;
3325 address_item adb;
3326 address_item *addr;
3327
3328 *user_msgptr = *log_msgptr = NULL;
3329 sender_verified_failed = NULL;
3330 ratelimiters_cmd = NULL;
3331
3332 if (where == ACL_WHERE_RCPT)
3333   {
3334   adb = address_defaults;
3335   addr = &adb;
3336   addr->address = data_string;
3337   if (deliver_split_address(addr) == DEFER)
3338     {
3339     *log_msgptr = US"defer in percent_hack_domains check";
3340     return DEFER;
3341     }
3342   deliver_domain = addr->domain;
3343   deliver_localpart = addr->local_part;
3344   }
3345 else
3346   {
3347   addr = NULL;
3348   smtp_command_argument = data_string;
3349   }
3350
3351 rc = acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
3352
3353 smtp_command_argument = deliver_domain =
3354   deliver_localpart = deliver_address_data = sender_address_data = NULL;
3355
3356 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
3357 ACL, which is really in the middle of an SMTP command. */
3358
3359 if (rc == DISCARD)
3360   {
3361   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
3362     {
3363     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
3364       "ACL", acl_wherenames[where]);
3365     return ERROR;
3366     }
3367   return DISCARD;
3368   }
3369
3370 /* A DROP response is not permitted from MAILAUTH */
3371
3372 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
3373   {
3374   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
3375     "ACL", acl_wherenames[where]);
3376   return ERROR;
3377   }
3378
3379 /* Before giving an error response, take a look at the length of any user
3380 message, and split it up into multiple lines if possible. */
3381
3382 if (rc != OK && *user_msgptr != NULL && Ustrlen(*user_msgptr) > 75)
3383   {
3384   uschar *s = *user_msgptr = string_copy(*user_msgptr);
3385   uschar *ss = s;
3386
3387   for (;;)
3388     {
3389     int i = 0;
3390     while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
3391     if (*ss == 0) break;
3392     if (*ss == '\n')
3393       s = ++ss;
3394     else
3395       {
3396       uschar *t = ss + 1;
3397       uschar *tt = NULL;
3398       while (--t > s + 35)
3399         {
3400         if (*t == ' ')
3401           {
3402           if (t[-1] == ':') { tt = t; break; }
3403           if (tt == NULL) tt = t;
3404           }
3405         }
3406
3407       if (tt == NULL)          /* Can't split behind - try ahead */
3408         {
3409         t = ss + 1;
3410         while (*t != 0)
3411           {
3412           if (*t == ' ' || *t == '\n')
3413             { tt = t; break; }
3414           t++;
3415           }
3416         }
3417
3418       if (tt == NULL) break;   /* Can't find anywhere to split */
3419       *tt = '\n';
3420       s = ss = tt+1;
3421       }
3422     }
3423   }
3424
3425 return rc;
3426 }
3427
3428 /* End of acl.c */