src/src/acl.c

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