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