src/src/acl.c

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