src/src/acl.c

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