src/src/acl.c

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