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