src/src/acl.c

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