src/src/acl.c

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