src/src/acl.c

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