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 specifing 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 comand, 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-intialize 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     {
2843     arg = expand_string(cb->arg);
2844     if (arg == NULL)
2845       {
2846       if (expand_string_forcedfail) continue;
2847       *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
2848         cb->arg, expand_string_message);
2849       return search_find_defer? DEFER : ERROR;
2850       }
2851     }
2852   else arg = cb->arg;
2853
2854   /* Show condition, and expanded condition if it's different */
2855
2856   HDEBUG(D_acl)
2857     {
2858     int lhswidth = 0;
2859     debug_printf("check %s%s %n",
2860       (!conditions[cb->type].is_modifier && cb->u.negated)? "!":"",
2861       conditions[cb->type].name, &lhswidth);
2862
2863     if (cb->type == ACLC_SET)
2864       {
2865       debug_printf("acl_%s ", cb->u.varname);
2866       lhswidth += 5 + Ustrlen(cb->u.varname);
2867       }
2868
2869     debug_printf("= %s\n", cb->arg);
2870
2871     if (arg != cb->arg)
2872       debug_printf("%.*s= %s\n", lhswidth,
2873       US"                             ", CS arg);
2874     }
2875
2876   /* Check that this condition makes sense at this time */
2877
2878   if ((conditions[cb->type].forbids & (1 << where)) != 0)
2879     {
2880     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
2881       conditions[cb->type].is_modifier ? "use" : "test",
2882       conditions[cb->type].name, acl_wherenames[where]);
2883     return ERROR;
2884     }
2885
2886   /* Run the appropriate test for each condition, or take the appropriate
2887   action for the remaining modifiers. */
2888
2889   switch(cb->type)
2890     {
2891     case ACLC_ADD_HEADER:
2892     setup_header(arg);
2893     break;
2894
2895     /* A nested ACL that returns "discard" makes sense only for an "accept" or
2896     "discard" verb. */
2897
2898     case ACLC_ACL:
2899       rc = acl_check_wargs(where, addr, arg, level+1, user_msgptr, log_msgptr);
2900       if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
2901         {
2902         *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
2903           "\"%s\" command (only allowed with \"accept\" or \"discard\")",
2904           verbs[verb]);
2905         return ERROR;
2906         }
2907     break;
2908
2909     case ACLC_AUTHENTICATED:
2910     rc = (sender_host_authenticated == NULL)? FAIL :
2911       match_isinlist(sender_host_authenticated, &arg, 0, NULL, NULL, MCL_STRING,
2912         TRUE, NULL);
2913     break;
2914
2915     #ifdef EXPERIMENTAL_BRIGHTMAIL
2916     case ACLC_BMI_OPTIN:
2917       {
2918       int old_pool = store_pool;
2919       store_pool = POOL_PERM;
2920       bmi_current_optin = string_copy(arg);
2921       store_pool = old_pool;
2922       }
2923     break;
2924     #endif
2925
2926     case ACLC_CONDITION:
2927     /* The true/false parsing here should be kept in sync with that used in
2928     expand.c when dealing with ECOND_BOOL so that we don't have too many
2929     different definitions of what can be a boolean. */
2930     if (*arg == '-'
2931         ? Ustrspn(arg+1, "0123456789") == Ustrlen(arg+1)    /* Negative number */
2932         : Ustrspn(arg,   "0123456789") == Ustrlen(arg))     /* Digits, or empty */
2933       rc = (Uatoi(arg) == 0)? FAIL : OK;
2934     else
2935       rc = (strcmpic(arg, US"no") == 0 ||
2936             strcmpic(arg, US"false") == 0)? FAIL :
2937            (strcmpic(arg, US"yes") == 0 ||
2938             strcmpic(arg, US"true") == 0)? OK : DEFER;
2939     if (rc == DEFER)
2940       *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
2941     break;
2942
2943     case ACLC_CONTINUE:    /* Always succeeds */
2944     break;
2945
2946     case ACLC_CONTROL:
2947       {
2948       const uschar *p = NULL;
2949       control_type = decode_control(arg, &p, where, log_msgptr);
2950
2951       /* Check if this control makes sense at this time */
2952
2953       if (controls_list[control_type].forbids & (1 << where))
2954         {
2955         *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
2956           controls_list[control_type].name, acl_wherenames[where]);
2957         return ERROR;
2958         }
2959
2960       switch(control_type)
2961         {
2962         case CONTROL_AUTH_UNADVERTISED:
2963         allow_auth_unadvertised = TRUE;
2964         break;
2965
2966         #ifdef EXPERIMENTAL_BRIGHTMAIL
2967         case CONTROL_BMI_RUN:
2968         bmi_run = 1;
2969         break;
2970         #endif
2971
2972         #ifndef DISABLE_DKIM
2973         case CONTROL_DKIM_VERIFY:
2974         dkim_disable_verify = TRUE;
2975         #ifdef EXPERIMENTAL_DMARC
2976         /* Since DKIM was blocked, skip DMARC too */
2977         dmarc_disable_verify = TRUE;
2978         dmarc_enable_forensic = FALSE;
2979         #endif
2980         break;
2981         #endif
2982
2983         #ifdef EXPERIMENTAL_DMARC
2984         case CONTROL_DMARC_VERIFY:
2985         dmarc_disable_verify = TRUE;
2986         break;
2987
2988         case CONTROL_DMARC_FORENSIC:
2989         dmarc_enable_forensic = TRUE;
2990         break;
2991         #endif
2992
2993         case CONTROL_DSCP:
2994         if (*p == '/')
2995           {
2996           int fd, af, level, optname, value;
2997           /* If we are acting on stdin, the setsockopt may fail if stdin is not
2998           a socket; we can accept that, we'll just debug-log failures anyway. */
2999           fd = fileno(smtp_in);
3000           af = ip_get_address_family(fd);
3001           if (af < 0)
3002             {
3003             HDEBUG(D_acl)
3004               debug_printf("smtp input is probably not a socket [%s], not setting DSCP\n",
3005                   strerror(errno));
3006             break;
3007             }
3008           if (dscp_lookup(p+1, af, &level, &optname, &value))
3009             {
3010             if (setsockopt(fd, level, optname, &value, sizeof(value)) < 0)
3011               {
3012               HDEBUG(D_acl) debug_printf("failed to set input DSCP[%s]: %s\n",
3013                   p+1, strerror(errno));
3014               }
3015             else
3016               {
3017               HDEBUG(D_acl) debug_printf("set input DSCP to \"%s\"\n", p+1);
3018               }
3019             }
3020           else
3021             {
3022             *log_msgptr = string_sprintf("unrecognised DSCP value in \"control=%s\"", arg);
3023             return ERROR;
3024             }
3025           }
3026         else
3027           {
3028           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3029           return ERROR;
3030           }
3031         break;
3032
3033         case CONTROL_ERROR:
3034         return ERROR;
3035
3036         case CONTROL_CASEFUL_LOCAL_PART:
3037         deliver_localpart = addr->cc_local_part;
3038         break;
3039
3040         case CONTROL_CASELOWER_LOCAL_PART:
3041         deliver_localpart = addr->lc_local_part;
3042         break;
3043
3044         case CONTROL_ENFORCE_SYNC:
3045         smtp_enforce_sync = TRUE;
3046         break;
3047
3048         case CONTROL_NO_ENFORCE_SYNC:
3049         smtp_enforce_sync = FALSE;
3050         break;
3051
3052         #ifdef WITH_CONTENT_SCAN
3053         case CONTROL_NO_MBOX_UNSPOOL:
3054         no_mbox_unspool = TRUE;
3055         break;
3056         #endif
3057
3058         case CONTROL_NO_MULTILINE:
3059         no_multiline_responses = TRUE;
3060         break;
3061
3062         case CONTROL_NO_PIPELINING:
3063         pipelining_enable = FALSE;
3064         break;
3065
3066         case CONTROL_NO_DELAY_FLUSH:
3067         disable_delay_flush = TRUE;
3068         break;
3069
3070         case CONTROL_NO_CALLOUT_FLUSH:
3071         disable_callout_flush = TRUE;
3072         break;
3073
3074         case CONTROL_FAKEREJECT:
3075         cancel_cutthrough_connection("fakereject");
3076         case CONTROL_FAKEDEFER:
3077         fake_response = (control_type == CONTROL_FAKEDEFER) ? DEFER : FAIL;
3078         if (*p == '/')
3079           {
3080           const uschar *pp = p + 1;
3081           while (*pp != 0) pp++;
3082           fake_response_text = expand_string(string_copyn(p+1, pp-p-1));
3083           p = pp;
3084           }
3085          else
3086           {
3087           /* Explicitly reset to default string */
3088           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).";
3089           }
3090         break;
3091
3092         case CONTROL_FREEZE:
3093         deliver_freeze = TRUE;
3094         deliver_frozen_at = time(NULL);
3095         freeze_tell = freeze_tell_config;       /* Reset to configured value */
3096         if (Ustrncmp(p, "/no_tell", 8) == 0)
3097           {
3098           p += 8;
3099           freeze_tell = NULL;
3100           }
3101         if (*p != 0)
3102           {
3103           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3104           return ERROR;
3105           }
3106         cancel_cutthrough_connection("item frozen");
3107         break;
3108
3109         case CONTROL_QUEUE_ONLY:
3110         queue_only_policy = TRUE;
3111         cancel_cutthrough_connection("queueing forced");
3112         break;
3113
3114         case CONTROL_SUBMISSION:
3115         originator_name = US"";
3116         submission_mode = TRUE;
3117         while (*p == '/')
3118           {
3119           if (Ustrncmp(p, "/sender_retain", 14) == 0)
3120             {
3121             p += 14;
3122             active_local_sender_retain = TRUE;
3123             active_local_from_check = FALSE;
3124             }
3125           else if (Ustrncmp(p, "/domain=", 8) == 0)
3126             {
3127             const uschar *pp = p + 8;
3128             while (*pp != 0 && *pp != '/') pp++;
3129             submission_domain = string_copyn(p+8, pp-p-8);
3130             p = pp;
3131             }
3132           /* The name= option must be last, because it swallows the rest of
3133           the string. */
3134           else if (Ustrncmp(p, "/name=", 6) == 0)
3135             {
3136             const uschar *pp = p + 6;
3137             while (*pp != 0) pp++;
3138             submission_name = string_copy(parse_fix_phrase(p+6, pp-p-6,
3139               big_buffer, big_buffer_size));
3140             p = pp;
3141             }
3142           else break;
3143           }
3144         if (*p != 0)
3145           {
3146           *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
3147           return ERROR;
3148           }
3149         break;
3150
3151         case CONTROL_DEBUG:
3152           {
3153           uschar * debug_tag = NULL;
3154           uschar * debug_opts = NULL;
3155           BOOL kill = FALSE;
3156
3157           while (*p == '/')
3158             {
3159             const uschar * pp = p+1;
3160             if (Ustrncmp(pp, "tag=", 4) == 0)
3161               {
3162               for (pp += 4; *pp && *pp != '/';) pp++;
3163               debug_tag = string_copyn(p+5, pp-p-5);
3164               }
3165             else if (Ustrncmp(pp, "opts=", 5) == 0)
3166               {
3167               for (pp += 5; *pp && *pp != '/';) pp++;
3168               debug_opts = string_copyn(p+6, pp-p-6);
3169               }
3170             else if (Ustrncmp(pp, "kill", 4) == 0)
3171               {
3172               for (pp += 4; *pp && *pp != '/';) pp++;
3173               kill = TRUE;
3174               }
3175             else
3176               while (*pp && *pp != '/') pp++;
3177             p = pp;
3178             }
3179
3180             if (kill)
3181               debug_logging_stop();
3182             else
3183               debug_logging_activate(debug_tag, debug_opts);
3184           }
3185         break;
3186
3187         case CONTROL_SUPPRESS_LOCAL_FIXUPS:
3188         suppress_local_fixups = TRUE;
3189         break;
3190
3191         case CONTROL_CUTTHROUGH_DELIVERY:
3192 #ifndef DISABLE_PRDR
3193         if (prdr_requested)
3194 #else
3195         if (0)
3196 #endif
3197           /* Too hard to think about for now.  We might in future cutthrough
3198           the case where both sides handle prdr and this-node prdr acl
3199           is "accept" */
3200           *log_msgptr = string_sprintf("PRDR on %s reception\n", arg);
3201         else
3202           {
3203           if (deliver_freeze)
3204             *log_msgptr = US"frozen";
3205           else if (queue_only_policy)
3206             *log_msgptr = US"queue-only";
3207           else if (fake_response == FAIL)
3208             *log_msgptr = US"fakereject";
3209           else
3210             {
3211             if (rcpt_count == 1)
3212               {
3213               cutthrough.delivery = TRUE;
3214               while (*p == '/')
3215                 {
3216                 const uschar * pp = p+1;
3217                 if (Ustrncmp(pp, "defer=", 6) == 0)
3218                   {
3219                   pp += 6;
3220                   if (Ustrncmp(pp, "pass", 4) == 0) cutthrough.defer_pass = TRUE;
3221                   /* else if (Ustrncmp(pp, "spool") == 0) ;     default */
3222                   }
3223                 else
3224                   while (*pp && *pp != '/') pp++;
3225                 p = pp;
3226                 }
3227               }
3228             break;
3229             }
3230           *log_msgptr = string_sprintf("\"control=%s\" on %s item",
3231                                         arg, *log_msgptr);
3232           }
3233         return ERROR;
3234
3235 #ifdef SUPPORT_I18N
3236         case CONTROL_UTF8_DOWNCONVERT:
3237         if (*p == '/')
3238           {
3239           if (p[1] == '1')
3240             {
3241             message_utf8_downconvert = 1;
3242             addr->prop.utf8_downcvt = TRUE;
3243             addr->prop.utf8_downcvt_maybe = FALSE;
3244             p += 2;
3245             break;
3246             }
3247           if (p[1] == '0')
3248             {
3249             message_utf8_downconvert = 0;
3250             addr->prop.utf8_downcvt = FALSE;
3251             addr->prop.utf8_downcvt_maybe = FALSE;
3252             p += 2;
3253             break;
3254             }
3255           if (p[1] == '-' && p[2] == '1')
3256             {
3257             message_utf8_downconvert = -1;
3258             addr->prop.utf8_downcvt = FALSE;
3259             addr->prop.utf8_downcvt_maybe = TRUE;
3260             p += 3;
3261             break;
3262             }
3263           *log_msgptr = US"bad option value for control=utf8_downconvert";
3264           }
3265         else
3266           {
3267           message_utf8_downconvert = 1;
3268           addr->prop.utf8_downcvt = TRUE;
3269           addr->prop.utf8_downcvt_maybe = FALSE;
3270           break;
3271           }
3272         return ERROR;
3273 #endif
3274
3275         }
3276       break;
3277       }
3278
3279     #ifdef EXPERIMENTAL_DCC
3280     case ACLC_DCC:
3281       {
3282       /* Seperate the regular expression and any optional parameters. */
3283       const uschar * list = arg;
3284       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3285       /* Run the dcc backend. */
3286       rc = dcc_process(&ss);
3287       /* Modify return code based upon the existance of options. */
3288       while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size)))
3289         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3290           rc = FAIL;   /* FAIL so that the message is passed to the next ACL */
3291       }
3292     break;
3293     #endif
3294
3295     #ifdef WITH_CONTENT_SCAN
3296     case ACLC_DECODE:
3297     rc = mime_decode(&arg);
3298     break;
3299     #endif
3300
3301     case ACLC_DELAY:
3302       {
3303       int delay = readconf_readtime(arg, 0, FALSE);
3304       if (delay < 0)
3305         {
3306         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
3307           "modifier: \"%s\" is not a time value", arg);
3308         return ERROR;
3309         }
3310       else
3311         {
3312         HDEBUG(D_acl) debug_printf("delay modifier requests %d-second delay\n",
3313           delay);
3314         if (host_checking)
3315           {
3316           HDEBUG(D_acl)
3317             debug_printf("delay skipped in -bh checking mode\n");
3318           }
3319
3320         /* NOTE 1: Remember that we may be
3321         dealing with stdin/stdout here, in addition to TCP/IP connections.
3322         Also, delays may be specified for non-SMTP input, where smtp_out and
3323         smtp_in will be NULL. Whatever is done must work in all cases.
3324
3325         NOTE 2: The added feature of flushing the output before a delay must
3326         apply only to SMTP input. Hence the test for smtp_out being non-NULL.
3327         */
3328
3329         else
3330           {
3331           if (smtp_out != NULL && !disable_delay_flush)
3332             mac_smtp_fflush();
3333
3334 #if !defined(NO_POLL_H) && defined (POLLRDHUP)
3335             {
3336             struct pollfd p;
3337             nfds_t n = 0;
3338             if (smtp_out)
3339               {
3340               p.fd = fileno(smtp_out);
3341               p.events = POLLRDHUP;
3342               n = 1;
3343               }
3344             if (poll(&p, n, delay*1000) > 0)
3345               HDEBUG(D_acl) debug_printf("delay cancelled by peer close\n");
3346             }
3347 #else
3348         /* It appears to be impossible to detect that a TCP/IP connection has
3349         gone away without reading from it. This means that we cannot shorten
3350         the delay below if the client goes away, because we cannot discover
3351         that the client has closed its end of the connection. (The connection
3352         is actually in a half-closed state, waiting for the server to close its
3353         end.) It would be nice to be able to detect this state, so that the
3354         Exim process is not held up unnecessarily. However, it seems that we
3355         can't. The poll() function does not do the right thing, and in any case
3356         it is not always available.
3357         */
3358
3359           while (delay > 0) delay = sleep(delay);
3360 #endif
3361           }
3362         }
3363       }
3364     break;
3365
3366     #ifndef DISABLE_DKIM
3367     case ACLC_DKIM_SIGNER:
3368     if (dkim_cur_signer != NULL)
3369       rc = match_isinlist(dkim_cur_signer,
3370                           &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3371     else
3372       rc = FAIL;
3373     break;
3374
3375     case ACLC_DKIM_STATUS:
3376     rc = match_isinlist(dkim_exim_expand_query(DKIM_VERIFY_STATUS),
3377                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3378     break;
3379     #endif
3380
3381     #ifdef EXPERIMENTAL_DMARC
3382     case ACLC_DMARC_STATUS:
3383     if (!dmarc_has_been_checked)
3384       dmarc_process();
3385     dmarc_has_been_checked = TRUE;
3386     /* used long way of dmarc_exim_expand_query() in case we need more
3387      * view into the process in the future. */
3388     rc = match_isinlist(dmarc_exim_expand_query(DMARC_VERIFY_STATUS),
3389                         &arg,0,NULL,NULL,MCL_STRING,TRUE,NULL);
3390     break;
3391     #endif
3392
3393     case ACLC_DNSLISTS:
3394     rc = verify_check_dnsbl(where, &arg, log_msgptr);
3395     break;
3396
3397     case ACLC_DOMAINS:
3398     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
3399       addr->domain_cache, MCL_DOMAIN, TRUE, CUSS &deliver_domain_data);
3400     break;
3401
3402     /* The value in tls_cipher is the full cipher name, for example,
3403     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
3404     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
3405     what may in practice come out of the SSL library - which at the time of
3406     writing is poorly documented. */
3407
3408     case ACLC_ENCRYPTED:
3409     if (tls_in.cipher == NULL) rc = FAIL; else
3410       {
3411       uschar *endcipher = NULL;
3412       uschar *cipher = Ustrchr(tls_in.cipher, ':');
3413       if (cipher == NULL) cipher = tls_in.cipher; else
3414         {
3415         endcipher = Ustrchr(++cipher, ':');
3416         if (endcipher != NULL) *endcipher = 0;
3417         }
3418       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
3419       if (endcipher != NULL) *endcipher = ':';
3420       }
3421     break;
3422
3423     /* Use verify_check_this_host() instead of verify_check_host() so that
3424     we can pass over &host_data to catch any looked up data. Once it has been
3425     set, it retains its value so that it's still there if another ACL verb
3426     comes through here and uses the cache. However, we must put it into
3427     permanent store in case it is also expected to be used in a subsequent
3428     message in the same SMTP connection. */
3429
3430     case ACLC_HOSTS:
3431     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
3432       (sender_host_address == NULL)? US"" : sender_host_address,
3433       CUSS &host_data);
3434     if (rc == DEFER) *log_msgptr = search_error_message;
3435     if (host_data) host_data = string_copy_malloc(host_data);
3436     break;
3437
3438     case ACLC_LOCAL_PARTS:
3439     rc = match_isinlist(addr->cc_local_part, &arg, 0,
3440       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
3441       CUSS &deliver_localpart_data);
3442     break;
3443
3444     case ACLC_LOG_REJECT_TARGET:
3445       {
3446       int logbits = 0;
3447       int sep = 0;
3448       const uschar *s = arg;
3449       uschar *ss;
3450       while ((ss = string_nextinlist(&s, &sep, big_buffer, big_buffer_size)))
3451         {
3452         if (Ustrcmp(ss, "main") == 0) logbits |= LOG_MAIN;
3453         else if (Ustrcmp(ss, "panic") == 0) logbits |= LOG_PANIC;
3454         else if (Ustrcmp(ss, "reject") == 0) logbits |= LOG_REJECT;
3455         else
3456           {
3457           logbits |= LOG_MAIN|LOG_REJECT;
3458           log_write(0, LOG_MAIN|LOG_PANIC, "unknown log name \"%s\" in "
3459             "\"log_reject_target\" in %s ACL", ss, acl_wherenames[where]);
3460           }
3461         }
3462       log_reject_target = logbits;
3463       }
3464     break;
3465
3466     case ACLC_LOGWRITE:
3467       {
3468       int logbits = 0;
3469       const uschar *s = arg;
3470       if (*s == ':')
3471         {
3472         s++;
3473         while (*s != ':')
3474           {
3475           if (Ustrncmp(s, "main", 4) == 0)
3476             { logbits |= LOG_MAIN; s += 4; }
3477           else if (Ustrncmp(s, "panic", 5) == 0)
3478             { logbits |= LOG_PANIC; s += 5; }
3479           else if (Ustrncmp(s, "reject", 6) == 0)
3480             { logbits |= LOG_REJECT; s += 6; }
3481           else
3482             {
3483             logbits = LOG_MAIN|LOG_PANIC;
3484             s = string_sprintf(":unknown log name in \"%s\" in "
3485               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
3486             }
3487           if (*s == ',') s++;
3488           }
3489         s++;
3490         }
3491       while (isspace(*s)) s++;
3492
3493
3494       if (logbits == 0) logbits = LOG_MAIN;
3495       log_write(0, logbits, "%s", string_printing(s));
3496       }
3497     break;
3498
3499     #ifdef WITH_CONTENT_SCAN
3500     case ACLC_MALWARE:                  /* Run the malware backend. */
3501       {
3502       /* Separate the regular expression and any optional parameters. */
3503       const uschar * list = arg;
3504       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3505       uschar *opt;
3506       BOOL defer_ok = FALSE;
3507       int timeout = 0;
3508
3509       while ((opt = string_nextinlist(&list, &sep, NULL, 0)))
3510         if (strcmpic(opt, US"defer_ok") == 0)
3511           defer_ok = TRUE;
3512         else if (  strncmpic(opt, US"tmo=", 4) == 0
3513                 && (timeout = readconf_readtime(opt+4, '\0', FALSE)) < 0
3514                 )
3515           {
3516           *log_msgptr = string_sprintf("bad timeout value in '%s'", opt);
3517           return ERROR;
3518           }
3519
3520       rc = malware(ss, timeout);
3521       if (rc == DEFER && defer_ok)
3522         rc = FAIL;      /* FAIL so that the message is passed to the next ACL */
3523       }
3524     break;
3525
3526     case ACLC_MIME_REGEX:
3527     rc = mime_regex(&arg);
3528     break;
3529     #endif
3530
3531     case ACLC_QUEUE:
3532     queue_name = string_copy_malloc(arg);
3533     break;
3534
3535     case ACLC_RATELIMIT:
3536     rc = acl_ratelimit(arg, where, log_msgptr);
3537     break;
3538
3539     case ACLC_RECIPIENTS:
3540     rc = match_address_list((const uschar *)addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
3541       CUSS &recipient_data);
3542     break;
3543
3544     #ifdef WITH_CONTENT_SCAN
3545     case ACLC_REGEX:
3546     rc = regex(&arg);
3547     break;
3548     #endif
3549
3550     case ACLC_REMOVE_HEADER:
3551     setup_remove_header(arg);
3552     break;
3553
3554     case ACLC_SENDER_DOMAINS:
3555       {
3556       uschar *sdomain;
3557       sdomain = Ustrrchr(sender_address, '@');
3558       sdomain = (sdomain == NULL)? US"" : sdomain + 1;
3559       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
3560         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
3561       }
3562     break;
3563
3564     case ACLC_SENDERS:
3565     rc = match_address_list((const uschar *)sender_address, TRUE, TRUE, &arg,
3566       sender_address_cache, -1, 0, CUSS &sender_data);
3567     break;
3568
3569     /* Connection variables must persist forever */
3570
3571     case ACLC_SET:
3572       {
3573       int old_pool = store_pool;
3574       if (  cb->u.varname[0] == 'c'
3575 #ifndef DISABLE_EVENT
3576          || event_name          /* An event is being delivered */
3577 #endif
3578          )
3579         store_pool = POOL_PERM;
3580       acl_var_create(cb->u.varname)->data.ptr = string_copy(arg);
3581       store_pool = old_pool;
3582       }
3583     break;
3584
3585     #ifdef WITH_CONTENT_SCAN
3586     case ACLC_SPAM:
3587       {
3588       /* Seperate the regular expression and any optional parameters. */
3589       const uschar * list = arg;
3590       uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
3591       /* Run the spam backend. */
3592       rc = spam(CUSS &ss);
3593       /* Modify return code based upon the existance of options. */
3594       while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
3595             != NULL) {
3596         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
3597           {
3598           /* FAIL so that the message is passed to the next ACL */
3599           rc = FAIL;
3600           }
3601         }
3602       }
3603     break;
3604     #endif
3605
3606     #ifdef EXPERIMENTAL_SPF
3607     case ACLC_SPF:
3608       rc = spf_process(&arg, sender_address, SPF_PROCESS_NORMAL);
3609     break;
3610     case ACLC_SPF_GUESS:
3611       rc = spf_process(&arg, sender_address, SPF_PROCESS_GUESS);
3612     break;
3613     #endif
3614
3615     case ACLC_UDPSEND:
3616     rc = acl_udpsend(arg, log_msgptr);
3617     break;
3618
3619     /* If the verb is WARN, discard any user message from verification, because
3620     such messages are SMTP responses, not header additions. The latter come
3621     only from explicit "message" modifiers. However, put the user message into
3622     $acl_verify_message so it can be used in subsequent conditions or modifiers
3623     (until something changes it). */
3624
3625     case ACLC_VERIFY:
3626     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
3627     if (*user_msgptr)
3628       acl_verify_message = *user_msgptr;
3629     if (verb == ACL_WARN) *user_msgptr = NULL;
3630     break;
3631
3632     default:
3633     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
3634       "condition %d", cb->type);
3635     break;
3636     }
3637
3638   /* If a condition was negated, invert OK/FAIL. */
3639
3640   if (!conditions[cb->type].is_modifier && cb->u.negated)
3641     if (rc == OK) rc = FAIL;
3642     else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
3643
3644   if (rc != OK) break;   /* Conditions loop */
3645   }
3646
3647
3648 /* If the result is the one for which "message" and/or "log_message" are used,
3649 handle the values of these modifiers. If there isn't a log message set, we make
3650 it the same as the user message.
3651
3652 "message" is a user message that will be included in an SMTP response. Unless
3653 it is empty, it overrides any previously set user message.
3654
3655 "log_message" is a non-user message, and it adds to any existing non-user
3656 message that is already set.
3657
3658 Most verbs have but a single return for which the messages are relevant, but
3659 for "discard", it's useful to have the log message both when it succeeds and
3660 when it fails. For "accept", the message is used in the OK case if there is no
3661 "endpass", but (for backwards compatibility) in the FAIL case if "endpass" is
3662 present. */
3663
3664 if (*epp && rc == OK) user_message = NULL;
3665
3666 if (((1<<rc) & msgcond[verb]) != 0)
3667   {
3668   uschar *expmessage;
3669   uschar *old_user_msgptr = *user_msgptr;
3670   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
3671
3672   /* If the verb is "warn", messages generated by conditions (verification or
3673   nested ACLs) are always discarded. This also happens for acceptance verbs
3674   when they actually do accept. Only messages specified at this level are used.
3675   However, the value of an existing message is available in $acl_verify_message
3676   during expansions. */
3677
3678   if (verb == ACL_WARN ||
3679       (rc == OK && (verb == ACL_ACCEPT || verb == ACL_DISCARD)))
3680     *log_msgptr = *user_msgptr = NULL;
3681
3682   if (user_message != NULL)
3683     {
3684     acl_verify_message = old_user_msgptr;
3685     expmessage = expand_string(user_message);
3686     if (expmessage == NULL)
3687       {
3688       if (!expand_string_forcedfail)
3689         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3690           user_message, expand_string_message);
3691       }
3692     else if (expmessage[0] != 0) *user_msgptr = expmessage;
3693     }
3694
3695   if (log_message != NULL)
3696     {
3697     acl_verify_message = old_log_msgptr;
3698     expmessage = expand_string(log_message);
3699     if (expmessage == NULL)
3700       {
3701       if (!expand_string_forcedfail)
3702         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
3703           log_message, expand_string_message);
3704       }
3705     else if (expmessage[0] != 0)
3706       {
3707       *log_msgptr = (*log_msgptr == NULL)? expmessage :
3708         string_sprintf("%s: %s", expmessage, *log_msgptr);
3709       }
3710     }
3711
3712   /* If no log message, default it to the user message */
3713
3714   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
3715   }
3716
3717 acl_verify_message = NULL;
3718 return rc;
3719 }
3720
3721
3722
3723
3724
3725 /*************************************************
3726 *        Get line from a literal ACL             *
3727 *************************************************/
3728
3729 /* This function is passed to acl_read() in order to extract individual lines
3730 of a literal ACL, which we access via static pointers. We can destroy the
3731 contents because this is called only once (the compiled ACL is remembered).
3732
3733 This code is intended to treat the data in the same way as lines in the main
3734 Exim configuration file. That is:
3735
3736   . Leading spaces are ignored.
3737
3738   . A \ at the end of a line is a continuation - trailing spaces after the \
3739     are permitted (this is because I don't believe in making invisible things
3740     significant). Leading spaces on the continued part of a line are ignored.
3741
3742   . Physical lines starting (significantly) with # are totally ignored, and
3743     may appear within a sequence of backslash-continued lines.
3744
3745   . Blank lines are ignored, but will end a sequence of continuations.
3746
3747 Arguments: none
3748 Returns:   a pointer to the next line
3749 */
3750
3751
3752 static uschar *acl_text;          /* Current pointer in the text */
3753 static uschar *acl_text_end;      /* Points one past the terminating '0' */
3754
3755
3756 static uschar *
3757 acl_getline(void)
3758 {
3759 uschar *yield;
3760
3761 /* This loop handles leading blank lines and comments. */
3762
3763 for(;;)
3764   {
3765   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
3766   if (*acl_text == 0) return NULL;         /* No more data */
3767   yield = acl_text;                        /* Potential data line */
3768
3769   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3770
3771   /* If we hit the end before a newline, we have the whole logical line. If
3772   it's a comment, there's no more data to be given. Otherwise, yield it. */
3773
3774   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
3775
3776   /* After reaching a newline, end this loop if the physical line does not
3777   start with '#'. If it does, it's a comment, and the loop continues. */
3778
3779   if (*yield != '#') break;
3780   }
3781
3782 /* This loop handles continuations. We know we have some real data, ending in
3783 newline. See if there is a continuation marker at the end (ignoring trailing
3784 white space). We know that *yield is not white space, so no need to test for
3785 cont > yield in the backwards scanning loop. */
3786
3787 for(;;)
3788   {
3789   uschar *cont;
3790   for (cont = acl_text - 1; isspace(*cont); cont--);
3791
3792   /* If no continuation follows, we are done. Mark the end of the line and
3793   return it. */
3794
3795   if (*cont != '\\')
3796     {
3797     *acl_text++ = 0;
3798     return yield;
3799     }
3800
3801   /* We have encountered a continuation. Skip over whitespace at the start of
3802   the next line, and indeed the whole of the next line or lines if they are
3803   comment lines. */
3804
3805   for (;;)
3806     {
3807     while (*(++acl_text) == ' ' || *acl_text == '\t');
3808     if (*acl_text != '#') break;
3809     while (*(++acl_text) != 0 && *acl_text != '\n');
3810     }
3811
3812   /* We have the start of a continuation line. Move all the rest of the data
3813   to join onto the previous line, and then find its end. If the end is not a
3814   newline, we are done. Otherwise loop to look for another continuation. */
3815
3816   memmove(cont, acl_text, acl_text_end - acl_text);
3817   acl_text_end -= acl_text - cont;
3818   acl_text = cont;
3819   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
3820   if (*acl_text == 0) return yield;
3821   }
3822
3823 /* Control does not reach here */
3824 }
3825
3826
3827
3828
3829
3830 /*************************************************
3831 *        Check access using an ACL               *
3832 *************************************************/
3833
3834 /* This function is called from address_check. It may recurse via
3835 acl_check_condition() - hence the use of a level to stop looping. The ACL is
3836 passed as a string which is expanded. A forced failure implies no access check
3837 is required. If the result is a single word, it is taken as the name of an ACL
3838 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
3839 text, complete with newlines, and parsed as such. In both cases, the ACL check
3840 is then run. This function uses an auxiliary function for acl_read() to call
3841 for reading individual lines of a literal ACL. This is acl_getline(), which
3842 appears immediately above.
3843
3844 Arguments:
3845   where        where called from
3846   addr         address item when called from RCPT; otherwise NULL
3847   s            the input string; NULL is the same as an empty ACL => DENY
3848   level        the nesting level
3849   user_msgptr  where to put a user error (for SMTP response)
3850   log_msgptr   where to put a logging message (not for SMTP response)
3851
3852 Returns:       OK         access is granted
3853                DISCARD    access is apparently granted...
3854                FAIL       access is denied
3855                FAIL_DROP  access is denied; drop the connection
3856                DEFER      can't tell at the moment
3857                ERROR      disaster
3858 */
3859
3860 static int
3861 acl_check_internal(int where, address_item *addr, uschar *s, int level,
3862   uschar **user_msgptr, uschar **log_msgptr)
3863 {
3864 int fd = -1;
3865 acl_block *acl = NULL;
3866 uschar *acl_name = US"inline ACL";
3867 uschar *ss;
3868
3869 /* Catch configuration loops */
3870
3871 if (level > 20)
3872   {
3873   *log_msgptr = US"ACL nested too deep: possible loop";
3874   return ERROR;
3875   }
3876
3877 if (s == NULL)
3878   {
3879   HDEBUG(D_acl) debug_printf("ACL is NULL: implicit DENY\n");
3880   return FAIL;
3881   }
3882
3883 /* At top level, we expand the incoming string. At lower levels, it has already
3884 been expanded as part of condition processing. */
3885
3886 if (level == 0)
3887   {
3888   ss = expand_string(s);
3889   if (ss == NULL)
3890     {
3891     if (expand_string_forcedfail) return OK;
3892     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
3893       expand_string_message);
3894     return ERROR;
3895     }
3896   }
3897 else ss = s;
3898
3899 while (isspace(*ss))ss++;
3900
3901 /* If we can't find a named ACL, the default is to parse it as an inline one.
3902 (Unless it begins with a slash; non-existent files give rise to an error.) */
3903
3904 acl_text = ss;
3905
3906 /* Handle the case of a string that does not contain any spaces. Look for a
3907 named ACL among those read from the configuration, or a previously read file.
3908 It is possible that the pointer to the ACL is NULL if the configuration
3909 contains a name with no data. If not found, and the text begins with '/',
3910 read an ACL from a file, and save it so it can be re-used. */
3911
3912 if (Ustrchr(ss, ' ') == NULL)
3913   {
3914   tree_node *t = tree_search(acl_anchor, ss);
3915   if (t != NULL)
3916     {
3917     acl = (acl_block *)(t->data.ptr);
3918     if (acl == NULL)
3919       {
3920       HDEBUG(D_acl) debug_printf("ACL \"%s\" is empty: implicit DENY\n", ss);
3921       return FAIL;
3922       }
3923     acl_name = string_sprintf("ACL \"%s\"", ss);
3924     HDEBUG(D_acl) debug_printf("using ACL \"%s\"\n", ss);
3925     }
3926
3927   else if (*ss == '/')
3928     {
3929     struct stat statbuf;
3930     fd = Uopen(ss, O_RDONLY, 0);
3931     if (fd < 0)
3932       {
3933       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
3934         strerror(errno));
3935       return ERROR;
3936       }
3937
3938     if (fstat(fd, &statbuf) != 0)
3939       {
3940       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
3941         strerror(errno));
3942       return ERROR;
3943       }
3944
3945     acl_text = store_get(statbuf.st_size + 1);
3946     acl_text_end = acl_text + statbuf.st_size + 1;
3947
3948     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
3949       {
3950       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
3951         ss, strerror(errno));
3952       return ERROR;
3953       }
3954     acl_text[statbuf.st_size] = 0;
3955     (void)close(fd);
3956
3957     acl_name = string_sprintf("ACL \"%s\"", ss);
3958     HDEBUG(D_acl) debug_printf("read ACL from file %s\n", ss);
3959     }
3960   }
3961
3962 /* Parse an ACL that is still in text form. If it came from a file, remember it
3963 in the ACL tree, having read it into the POOL_PERM store pool so that it
3964 persists between multiple messages. */
3965
3966 if (acl == NULL)
3967   {
3968   int old_pool = store_pool;
3969   if (fd >= 0) store_pool = POOL_PERM;
3970   acl = acl_read(acl_getline, log_msgptr);
3971   store_pool = old_pool;
3972   if (acl == NULL && *log_msgptr != NULL) return ERROR;
3973   if (fd >= 0)
3974     {
3975     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
3976     Ustrcpy(t->name, ss);
3977     t->data.ptr = acl;
3978     (void)tree_insertnode(&acl_anchor, t);
3979     }
3980   }
3981
3982 /* Now we have an ACL to use. It's possible it may be NULL. */
3983
3984 while (acl != NULL)
3985   {
3986   int cond;
3987   int basic_errno = 0;
3988   BOOL endpass_seen = FALSE;
3989   BOOL acl_quit_check = level == 0
3990     && (where == ACL_WHERE_QUIT || where == ACL_WHERE_NOTQUIT);
3991
3992   *log_msgptr = *user_msgptr = NULL;
3993   acl_temp_details = FALSE;
3994
3995   HDEBUG(D_acl) debug_printf("processing \"%s\"\n", verbs[acl->verb]);
3996
3997   /* Clear out any search error message from a previous check before testing
3998   this condition. */
3999
4000   search_error_message = NULL;
4001   cond = acl_check_condition(acl->verb, acl->condition, where, addr, level,
4002     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
4003
4004   /* Handle special returns: DEFER causes a return except on a WARN verb;
4005   ERROR always causes a return. */
4006
4007   switch (cond)
4008     {
4009     case DEFER:
4010     HDEBUG(D_acl) debug_printf("%s: condition test deferred in %s\n", verbs[acl->verb], acl_name);
4011     if (basic_errno != ERRNO_CALLOUTDEFER)
4012       {
4013       if (search_error_message != NULL && *search_error_message != 0)
4014         *log_msgptr = search_error_message;
4015       if (smtp_return_error_details) acl_temp_details = TRUE;
4016       }
4017     else
4018       {
4019       acl_temp_details = TRUE;
4020       }
4021     if (acl->verb != ACL_WARN) return DEFER;
4022     break;
4023
4024     default:      /* Paranoia */
4025     case ERROR:
4026     HDEBUG(D_acl) debug_printf("%s: condition test error in %s\n", verbs[acl->verb], acl_name);
4027     return ERROR;
4028
4029     case OK:
4030     HDEBUG(D_acl) debug_printf("%s: condition test succeeded in %s\n",
4031       verbs[acl->verb], acl_name);
4032     break;
4033
4034     case FAIL:
4035     HDEBUG(D_acl) debug_printf("%s: condition test failed in %s\n", verbs[acl->verb], acl_name);
4036     break;
4037
4038     /* DISCARD and DROP can happen only from a nested ACL condition, and
4039     DISCARD can happen only for an "accept" or "discard" verb. */
4040
4041     case DISCARD:
4042     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"discard\" in %s\n",
4043       verbs[acl->verb], acl_name);
4044     break;
4045
4046     case FAIL_DROP:
4047     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"drop\" in %s\n",
4048       verbs[acl->verb], acl_name);
4049     break;
4050     }
4051
4052   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
4053   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
4054   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
4055
4056   switch(acl->verb)
4057     {
4058     case ACL_ACCEPT:
4059     if (cond == OK || cond == DISCARD)
4060       {
4061       HDEBUG(D_acl) debug_printf("end of %s: ACCEPT\n", acl_name);
4062       return cond;
4063       }
4064     if (endpass_seen)
4065       {
4066       HDEBUG(D_acl) debug_printf("accept: endpass encountered - denying access\n");
4067       return cond;
4068       }
4069     break;
4070
4071     case ACL_DEFER:
4072     if (cond == OK)
4073       {
4074       HDEBUG(D_acl) debug_printf("end of %s: DEFER\n", acl_name);
4075       if (acl_quit_check) goto badquit;
4076       acl_temp_details = TRUE;
4077       return DEFER;
4078       }
4079     break;
4080
4081     case ACL_DENY:
4082     if (cond == OK)
4083       {
4084       HDEBUG(D_acl) debug_printf("end of %s: DENY\n", acl_name);
4085       if (acl_quit_check) goto badquit;
4086       return FAIL;
4087       }
4088     break;
4089
4090     case ACL_DISCARD:
4091     if (cond == OK || cond == DISCARD)
4092       {
4093       HDEBUG(D_acl) debug_printf("end of %s: DISCARD\n", acl_name);
4094       if (acl_quit_check) goto badquit;
4095       return DISCARD;
4096       }
4097     if (endpass_seen)
4098       {
4099       HDEBUG(D_acl) debug_printf("discard: endpass encountered - denying access\n");
4100       return cond;
4101       }
4102     break;
4103
4104     case ACL_DROP:
4105     if (cond == OK)
4106       {
4107       HDEBUG(D_acl) debug_printf("end of %s: DROP\n", acl_name);
4108       if (acl_quit_check) goto badquit;
4109       return FAIL_DROP;
4110       }
4111     break;
4112
4113     case ACL_REQUIRE:
4114     if (cond != OK)
4115       {
4116       HDEBUG(D_acl) debug_printf("end of %s: not OK\n", acl_name);
4117       if (acl_quit_check) goto badquit;
4118       return cond;
4119       }
4120     break;
4121
4122     case ACL_WARN:
4123     if (cond == OK)
4124       acl_warn(where, *user_msgptr, *log_msgptr);
4125     else if (cond == DEFER && LOGGING(acl_warn_skipped))
4126       log_write(0, LOG_MAIN, "%s Warning: ACL \"warn\" statement skipped: "
4127         "condition test deferred%s%s", host_and_ident(TRUE),
4128         (*log_msgptr == NULL)? US"" : US": ",
4129         (*log_msgptr == NULL)? US"" : *log_msgptr);
4130     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
4131     break;
4132
4133     default:
4134     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
4135       acl->verb);
4136     break;
4137     }
4138
4139   /* Pass to the next ACL item */
4140
4141   acl = acl->next;
4142   }
4143
4144 /* We have reached the end of the ACL. This is an implicit DENY. */
4145
4146 HDEBUG(D_acl) debug_printf("end of %s: implicit DENY\n", acl_name);
4147 return FAIL;
4148
4149 badquit:
4150   *log_msgptr = string_sprintf("QUIT or not-QUIT teplevel ACL may not fail "
4151     "('%s' verb used incorrectly)", verbs[acl->verb]);
4152   return ERROR;
4153 }
4154
4155
4156
4157
4158 /* Same args as acl_check_internal() above, but the string s is
4159 the name of an ACL followed optionally by up to 9 space-separated arguments.
4160 The name and args are separately expanded.  Args go into $acl_arg globals. */
4161 static int
4162 acl_check_wargs(int where, address_item *addr, const uschar *s, int level,
4163   uschar **user_msgptr, uschar **log_msgptr)
4164 {
4165 uschar * tmp;
4166 uschar * tmp_arg[9];    /* must match acl_arg[] */
4167 uschar * sav_arg[9];    /* must match acl_arg[] */
4168 int sav_narg;
4169 uschar * name;
4170 int i;
4171 int ret;
4172
4173 if (!(tmp = string_dequote(&s)) || !(name = expand_string(tmp)))
4174   goto bad;
4175
4176 for (i = 0; i < 9; i++)
4177   {
4178   while (*s && isspace(*s)) s++;
4179   if (!*s) break;
4180   if (!(tmp = string_dequote(&s)) || !(tmp_arg[i] = expand_string(tmp)))
4181     {
4182     tmp = name;
4183     goto bad;
4184     }
4185   }
4186
4187 sav_narg = acl_narg;
4188 acl_narg = i;
4189 for (i = 0; i < acl_narg; i++)
4190   {
4191   sav_arg[i] = acl_arg[i];
4192   acl_arg[i] = tmp_arg[i];
4193   }
4194 while (i < 9)
4195   {
4196   sav_arg[i] = acl_arg[i];
4197   acl_arg[i++] = NULL;
4198   }
4199
4200 ret = acl_check_internal(where, addr, name, level, user_msgptr, log_msgptr);
4201
4202 acl_narg = sav_narg;
4203 for (i = 0; i < 9; i++) acl_arg[i] = sav_arg[i];
4204 return ret;
4205
4206 bad:
4207 if (expand_string_forcedfail) return ERROR;
4208 *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
4209   tmp, expand_string_message);
4210 return search_find_defer?DEFER:ERROR;
4211 }
4212
4213
4214
4215 /*************************************************
4216 *        Check access using an ACL               *
4217 *************************************************/
4218
4219 /* Alternate interface for ACL, used by expansions */
4220 int
4221 acl_eval(int where, uschar *s, uschar **user_msgptr, uschar **log_msgptr)
4222 {
4223 address_item adb;
4224 address_item *addr = NULL;
4225
4226 *user_msgptr = *log_msgptr = NULL;
4227 sender_verified_failed = NULL;
4228 ratelimiters_cmd = NULL;
4229 log_reject_target = LOG_MAIN|LOG_REJECT;
4230
4231 if (where == ACL_WHERE_RCPT)
4232   {
4233   adb = address_defaults;
4234   addr = &adb;
4235   addr->address = expand_string(US"$local_part@$domain");
4236   addr->domain = deliver_domain;
4237   addr->local_part = deliver_localpart;
4238   addr->cc_local_part = deliver_localpart;
4239   addr->lc_local_part = deliver_localpart;
4240   }
4241
4242 return acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
4243 }
4244
4245
4246
4247 /* This is the external interface for ACL checks. It sets up an address and the
4248 expansions for $domain and $local_part when called after RCPT, then calls
4249 acl_check_internal() to do the actual work.
4250
4251 Arguments:
4252   where        ACL_WHERE_xxxx indicating where called from
4253   recipient    RCPT address for RCPT check, else NULL
4254   s            the input string; NULL is the same as an empty ACL => DENY
4255   user_msgptr  where to put a user error (for SMTP response)
4256   log_msgptr   where to put a logging message (not for SMTP response)
4257
4258 Returns:       OK         access is granted by an ACCEPT verb
4259                DISCARD    access is granted by a DISCARD verb
4260                FAIL       access is denied
4261                FAIL_DROP  access is denied; drop the connection
4262                DEFER      can't tell at the moment
4263                ERROR      disaster
4264 */
4265 int acl_where = ACL_WHERE_UNKNOWN;
4266
4267 int
4268 acl_check(int where, uschar *recipient, uschar *s, uschar **user_msgptr,
4269   uschar **log_msgptr)
4270 {
4271 int rc;
4272 address_item adb;
4273 address_item *addr = NULL;
4274
4275 *user_msgptr = *log_msgptr = NULL;
4276 sender_verified_failed = NULL;
4277 ratelimiters_cmd = NULL;
4278 log_reject_target = LOG_MAIN|LOG_REJECT;
4279
4280 #ifndef DISABLE_PRDR
4281 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY || where==ACL_WHERE_PRDR)
4282 #else
4283 if (where==ACL_WHERE_RCPT || where==ACL_WHERE_VRFY)
4284 #endif
4285   {
4286   adb = address_defaults;
4287   addr = &adb;
4288   addr->address = recipient;
4289   if (deliver_split_address(addr) == DEFER)
4290     {
4291     *log_msgptr = US"defer in percent_hack_domains check";
4292     return DEFER;
4293     }
4294 #ifdef SUPPORT_I18N
4295   if ((addr->prop.utf8_msg = message_smtputf8))
4296     {
4297     addr->prop.utf8_downcvt =       message_utf8_downconvert == 1;
4298     addr->prop.utf8_downcvt_maybe = message_utf8_downconvert == -1;
4299     }
4300 #endif
4301   deliver_domain = addr->domain;
4302   deliver_localpart = addr->local_part;
4303   }
4304
4305 acl_where = where;
4306 rc = acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
4307 acl_where = ACL_WHERE_UNKNOWN;
4308
4309 /* Cutthrough - if requested,
4310 and WHERE_RCPT and not yet opened conn as result of recipient-verify,
4311 and rcpt acl returned accept,
4312 and first recipient (cancel on any subsequents)
4313 open one now and run it up to RCPT acceptance.
4314 A failed verify should cancel cutthrough request,
4315 and will pass the fail to the originator.
4316 Initial implementation:  dual-write to spool.
4317 Assume the rxd datastream is now being copied byte-for-byte to an open cutthrough connection.
4318
4319 Cease cutthrough copy on rxd final dot; do not send one.
4320
4321 On a data acl, if not accept and a cutthrough conn is open, hard-close it (no SMTP niceness).
4322
4323 On data acl accept, terminate the dataphase on an open cutthrough conn.  If accepted or
4324 perm-rejected, reflect that to the original sender - and dump the spooled copy.
4325 If temp-reject, close the conn (and keep the spooled copy).
4326 If conn-failure, no action (and keep the spooled copy).
4327 */
4328 switch (where)
4329   {
4330   case ACL_WHERE_RCPT:
4331 #ifndef DISABLE_PRDR
4332   case ACL_WHERE_PRDR:
4333 #endif
4334     if (host_checking_callout)  /* -bhc mode */
4335       cancel_cutthrough_connection("host-checking mode");
4336
4337     else if (  rc == OK
4338             && cutthrough.delivery
4339             && rcpt_count > cutthrough.nrcpt
4340             && (rc = open_cutthrough_connection(addr)) == DEFER
4341             )
4342       if (cutthrough.defer_pass)
4343         {
4344         uschar * s = addr->message;
4345         /* Horrid kludge to recover target's SMTP message */
4346         while (*s) s++;
4347         do --s; while (!isdigit(*s));
4348         if (*--s && isdigit(*s) && *--s && isdigit(*s)) *user_msgptr = s;
4349         acl_temp_details = TRUE;
4350         }
4351         else
4352         {
4353         HDEBUG(D_acl) debug_printf("cutthrough defer; will spool\n");
4354         rc = OK;
4355         }
4356     break;
4357
4358   case ACL_WHERE_PREDATA:
4359     if (rc == OK)
4360       cutthrough_predata();
4361     else
4362       cancel_cutthrough_connection("predata acl not ok");
4363     break;
4364
4365   case ACL_WHERE_QUIT:
4366   case ACL_WHERE_NOTQUIT:
4367     cancel_cutthrough_connection("quit or notquit");
4368     break;
4369
4370   default:
4371     break;
4372   }
4373
4374 deliver_domain = deliver_localpart = deliver_address_data =
4375   sender_address_data = NULL;
4376
4377 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
4378 ACL, which is really in the middle of an SMTP command. */
4379
4380 if (rc == DISCARD)
4381   {
4382   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
4383     {
4384     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
4385       "ACL", acl_wherenames[where]);
4386     return ERROR;
4387     }
4388   return DISCARD;
4389   }
4390
4391 /* A DROP response is not permitted from MAILAUTH */
4392
4393 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
4394   {
4395   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
4396     "ACL", acl_wherenames[where]);
4397   return ERROR;
4398   }
4399
4400 /* Before giving a response, take a look at the length of any user message, and
4401 split it up into multiple lines if possible. */
4402
4403 *user_msgptr = string_split_message(*user_msgptr);
4404 if (fake_response != OK)
4405   fake_response_text = string_split_message(fake_response_text);
4406
4407 return rc;
4408 }
4409
4410
4411 /*************************************************
4412 *             Create ACL variable                *
4413 *************************************************/
4414
4415 /* Create an ACL variable or reuse an existing one. ACL variables are in a
4416 binary tree (see tree.c) with acl_var_c and acl_var_m as root nodes.
4417
4418 Argument:
4419   name    pointer to the variable's name, starting with c or m
4420
4421 Returns   the pointer to variable's tree node
4422 */
4423
4424 tree_node *
4425 acl_var_create(uschar *name)
4426 {
4427 tree_node *node, **root;
4428 root = (name[0] == 'c')? &acl_var_c : &acl_var_m;
4429 node = tree_search(*root, name);
4430 if (node == NULL)
4431   {
4432   node = store_get(sizeof(tree_node) + Ustrlen(name));
4433   Ustrcpy(node->name, name);
4434   (void)tree_insertnode(root, node);
4435   }
4436 node->data.ptr = NULL;
4437 return node;
4438 }
4439
4440
4441
4442 /*************************************************
4443 *       Write an ACL variable in spool format    *
4444 *************************************************/
4445
4446 /* This function is used as a callback for tree_walk when writing variables to
4447 the spool file. To retain spool file compatibility, what is written is -aclc or
4448 -aclm followed by the rest of the name and the data length, space separated,
4449 then the value itself, starting on a new line, and terminated by an additional
4450 newline. When we had only numbered ACL variables, the first line might look
4451 like this: "-aclc 5 20". Now it might be "-aclc foo 20" for the variable called
4452 acl_cfoo.
4453
4454 Arguments:
4455   name    of the variable
4456   value   of the variable
4457   ctx     FILE pointer (as a void pointer)
4458
4459 Returns:  nothing
4460 */
4461
4462 void
4463 acl_var_write(uschar *name, uschar *value, void *ctx)
4464 {
4465 FILE *f = (FILE *)ctx;
4466 fprintf(f, "-acl%c %s %d\n%s\n", name[0], name+1, Ustrlen(value), value);
4467 }
4468
4469 /* vi: aw ai sw=2
4470 */
4471 /* End of acl.c */