src/src/acl.c

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