src/src/acl.c

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