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