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