Exiscan inclusion - ACL hooks
[users/jgh/exim.git] / src / src / acl.c
1 /* $Cambridge: exim/src/src/acl.c,v 1.5.2.1 2004/11/25 15:33:55 tom Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2004 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10 /* Code for handling Access Control Lists (ACLs) */
11
12 #include "exim.h"
13
14
15 /* Default callout timeout */
16
17 #define CALLOUT_TIMEOUT_DEFAULT 30
18
19 /* ACL verb codes - keep in step with the table of verbs that follows */
20
21 enum { ACL_ACCEPT, ACL_DEFER, ACL_DENY, ACL_DISCARD, ACL_DROP, ACL_REQUIRE,
22        ACL_WARN };
23
24 /* ACL verbs */
25
26 static uschar *verbs[] =
27   { US"accept", US"defer", US"deny", US"discard", US"drop", US"require",
28     US"warn" };
29
30 /* For each verb, the condition for which "message" is used */
31
32 static int msgcond[] = { FAIL, OK, OK, FAIL, OK, FAIL, OK };
33
34 /* ACL condition and modifier codes - keep in step with the table that
35 follows. */
36
37 enum { ACLC_ACL, ACLC_AUTHENTICATED, ACLC_CONDITION, ACLC_CONTROL,
38 #ifdef WITH_CONTENT_SCAN
39        ACLC_DECODE,
40 #endif
41        ACLC_DELAY, ACLC_DNSLISTS, ACLC_DOMAINS, ACLC_ENCRYPTED, ACLC_ENDPASS,
42        ACLC_HOSTS, ACLC_LOCAL_PARTS, ACLC_LOG_MESSAGE, ACLC_LOGWRITE,
43 #ifdef WITH_CONTENT_SCAN
44        ACLC_MALWARE,
45 #endif
46        ACLC_MESSAGE,
47 #ifdef WITH_CONTENT_SCAN
48        ACLC_MIME_REGEX,
49 #endif
50        ACLC_RECIPIENTS,
51 #ifdef WITH_CONTENT_SCAN
52        ACLC_REGEX
53 #endif
54        ACLC_SENDER_DOMAINS, ACLC_SENDERS, ACLC_SET,
55 #ifdef WITH_CONTENT_SCAN
56        ACLC_SPAM,       
57 #endif
58        ACLC_VERIFY };
59
60 /* ACL conditions/modifiers: "delay", "control", "endpass", "message",
61 "log_message", "logwrite", and "set" are modifiers that look like conditions
62 but always return TRUE. They are used for their side effects. */
63
64 static uschar *conditions[] = { US"acl", US"authenticated", US"condition",
65   US"control", 
66 #ifdef WITH_CONTENT_SCAN
67   US"decode",
68 #endif
69   US"delay", US"dnslists", US"domains", US"encrypted",
70   US"endpass", US"hosts", US"local_parts", US"log_message", US"logwrite",
71 #ifdef WITH_CONTENT_SCAN
72   US"malware",
73 #endif
74   US"message",
75 #ifdef WITH_CONTENT_SCAN
76   US"mime_regex",
77 #endif
78   US"recipients",
79 #ifdef WITH_CONTENT_SCAN
80   US"regex",
81 #endif
82   US"sender_domains", US"senders", US"set",
83 #ifdef WITH_CONTENT_SCAN
84   US"spam",
85 #endif
86   US"verify" };
87   
88 /* ACL control names */
89
90 static uschar *controls[] = { US"error", US"caseful_local_part",
91   US"caselower_local_part", US"enforce_sync", US"no_enforce_sync", US"freeze",
92   US"queue_only", US"submission", US"no_multiline"}; 
93
94 /* Flags to indicate for which conditions /modifiers a string expansion is done
95 at the outer level. In the other cases, expansion already occurs in the
96 checking functions. */
97
98 static uschar cond_expand_at_top[] = {
99   TRUE,    /* acl */
100   FALSE,   /* authenticated */
101   TRUE,    /* condition */
102   TRUE,    /* control */
103 #ifdef WITH_CONTENT_SCAN
104   TRUE,    /* decode */
105 #endif
106   TRUE,    /* delay */
107   TRUE,    /* dnslists */
108   FALSE,   /* domains */
109   FALSE,   /* encrypted */
110   TRUE,    /* endpass */
111   FALSE,   /* hosts */
112   FALSE,   /* local_parts */
113   TRUE,    /* log_message */
114   TRUE,    /* logwrite */
115 #ifdef WITH_CONTENT_SCAN
116   TRUE,    /* malware */
117 #endif
118   TRUE,    /* message */
119 #ifdef WITH_CONTENT_SCAN
120   TRUE,    /* mime_regex */
121 #endif
122   FALSE,   /* recipients */
123 #ifdef WITH_CONTENT_SCAN
124   TRUE,    /* regex */
125 #endif
126   FALSE,   /* sender_domains */
127   FALSE,   /* senders */
128   TRUE,    /* set */
129 #ifdef WITH_CONTENT_SCAN
130   TRUE,    /* spam */
131 #endif
132   TRUE     /* verify */
133 };
134
135 /* Flags to identify the modifiers */
136
137 static uschar cond_modifiers[] = {
138   FALSE,   /* acl */
139   FALSE,   /* authenticated */
140   FALSE,   /* condition */
141   TRUE,    /* control */
142 #ifdef WITH_CONTENT_SCAN
143   FALSE,   /* decode */
144 #endif
145   TRUE,    /* delay */
146   FALSE,   /* dnslists */
147   FALSE,   /* domains */
148   FALSE,   /* encrypted */
149   TRUE,    /* endpass */
150   FALSE,   /* hosts */
151   FALSE,   /* local_parts */
152   TRUE,    /* log_message */
153   TRUE,    /* logwrite */
154 #ifdef WITH_CONTENT_SCAN
155   FALSE,   /* malware */
156 #endif
157   TRUE,    /* message */
158 #ifdef WITH_CONTENT_SCAN
159   FALSE,   /* mime_regex */
160 #endif
161   FALSE,   /* recipients */
162 #ifdef WITH_CONTENT_SCAN
163   FALSE,   /* regex */
164 #endif
165   FALSE,   /* sender_domains */
166   FALSE,   /* senders */
167   TRUE,    /* set */
168 #ifdef WITH_CONTENT_SCAN
169   FALSE,   /* spam */
170 #endif
171   FALSE    /* verify */
172 };
173
174 /* Bit map vector of which conditions are not allowed at certain times. For
175 each condition, there's a bitmap of dis-allowed times. */
176
177 static unsigned int cond_forbids[] = {
178   0,                                               /* acl */
179   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_CONNECT)|   /* authenticated */
180     (1<<ACL_WHERE_HELO),
181   0,                                               /* condition */
182
183   /* Certain types of control are always allowed, so we let it through
184   always and check in the control processing itself */
185
186   0,                                               /* control */
187
188 #ifdef WITH_CONTENT_SCAN
189   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* decode */
190     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
191     (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_PREDATA)|
192     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
193     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
194     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
195     (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_RCPT),
196 #endif
197
198   0,                                               /* delay */
199   (1<<ACL_WHERE_NOTSMTP),                          /* dnslists */
200
201   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* domains */
202     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
203     (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_PREDATA)|
204     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
205     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
206     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
207     (1<<ACL_WHERE_VRFY),
208
209   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_CONNECT)|   /* encrypted */
210     (1<<ACL_WHERE_HELO),
211   0,                                               /* endpass */
212   (1<<ACL_WHERE_NOTSMTP),                          /* hosts */
213
214   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* local_parts */
215     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
216     (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_PREDATA)|
217     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
218     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
219     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
220     (1<<ACL_WHERE_VRFY),
221
222   0,                                               /* log_message */
223   0,                                               /* logwrite */
224   
225 #ifdef WITH_CONTENT_SCAN
226   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* malware */
227     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
228     (1<<ACL_WHERE_RCPT)|(1<<ACL_WHERE_PREDATA)|
229     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
230     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
231     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
232     (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_MIME),
233 #endif
234
235   0,                                               /* message */
236
237 #ifdef WITH_CONTENT_SCAN
238   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* mime_regex */
239     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
240     (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_PREDATA)|
241     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
242     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
243     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
244     (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_RCPT),
245 #endif
246
247   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* recipients */
248     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
249     (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_PREDATA)|
250     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
251     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
252     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
253     (1<<ACL_WHERE_VRFY),
254
255 #ifdef WITH_CONTENT_SCAN
256   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* regex */
257     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
258     (1<<ACL_WHERE_RCPT)|(1<<ACL_WHERE_PREDATA)|
259     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
260     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
261     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
262     (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_MIME),
263 #endif
264
265   (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|      /* sender_domains */
266     (1<<ACL_WHERE_HELO)|
267     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
268     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
269     (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
270
271   (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|      /* senders */
272     (1<<ACL_WHERE_HELO)|
273     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
274     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
275     (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
276
277   0,                                               /* set */
278
279 #ifdef WITH_CONTENT_SCAN
280   (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_AUTH)|      /* spam */
281     (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
282     (1<<ACL_WHERE_RCPT)|(1<<ACL_WHERE_PREDATA)|
283     (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
284     (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
285     (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
286     (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_MIME),
287 #endif
288
289   /* Certain types of verify are always allowed, so we let it through
290   always and check in the verify function itself */
291
292   0                                                /* verify */
293 };
294
295
296 /* Return values from decode_control() */
297
298 enum { CONTROL_ERROR, CONTROL_CASEFUL_LOCAL_PART, CONTROL_CASELOWER_LOCAL_PART,
299   CONTROL_ENFORCE_SYNC, CONTROL_NO_ENFORCE_SYNC, CONTROL_FREEZE,
300   CONTROL_QUEUE_ONLY, CONTROL_SUBMISSION,
301 #ifdef WITH_CONTENT_SCAN
302   CONTROL_NO_MBOX_UNSPOOL, CONTROL_FAKEREJECT,
303 #endif
304   CONTROL_NO_MULTILINE };
305
306 /* Bit map vector of which controls are not allowed at certain times. For
307 each control, there's a bitmap of dis-allowed times. For some, it is easier to
308 specify the negation of a small number of allowed times. */
309
310 static unsigned int control_forbids[] = {
311   0,                                               /* error */
312   ~(1<<ACL_WHERE_RCPT),                            /* caseful_local_part */
313   ~(1<<ACL_WHERE_RCPT),                            /* caselower_local_part */
314   (1<<ACL_WHERE_NOTSMTP),                          /* enforce_sync */
315   (1<<ACL_WHERE_NOTSMTP),                          /* no_enforce_sync */
316    
317   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* freeze */
318     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
319     (1<<ACL_WHERE_NOTSMTP)),
320      
321   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* queue_only */
322     (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
323     (1<<ACL_WHERE_NOTSMTP)),
324      
325   ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|       /* submission */
326     (1<<ACL_WHERE_PREDATA)),                       
327
328 #ifdef WITH_CONTENT_SCAN
329   (1<<ACL_WHERE_NOTSMTP),                          /* no_mbox_unspool */
330   (1<<ACL_WHERE_NOTSMTP),                          /* fakereject */
331 #endif
332
333   (1<<ACL_WHERE_NOTSMTP)                           /* no_multiline */
334 };
335
336 /* Structure listing various control arguments, with their characteristics. */
337
338 typedef struct control_def {
339   uschar *name;
340   int    value;                  /* CONTROL_xxx value */
341   BOOL   has_option;             /* Has /option(s) following */
342 } control_def;
343
344 static control_def controls_list[] = {
345   { US"caseful_local_part",     CONTROL_CASEFUL_LOCAL_PART, FALSE},
346   { US"caselower_local_part",   CONTROL_CASELOWER_LOCAL_PART, FALSE},
347   { US"enforce_sync",           CONTROL_ENFORCE_SYNC, FALSE},
348   { US"freeze",                 CONTROL_FREEZE, FALSE},
349   { US"no_enforce_sync",        CONTROL_NO_ENFORCE_SYNC, FALSE},
350   { US"no_multiline_responses", CONTROL_NO_MULTILINE, FALSE},
351   { US"queue_only",             CONTROL_QUEUE_ONLY, FALSE},
352 #ifdef WITH_CONTENT_SCAN
353   { US"no_mbox_unspool",        CONTROL_NO_MBOX_UNSPOOL, FALSE},
354   { US"fakereject",             CONTROL_FAKEREJECT, TRUE},
355 #endif
356   { US"submission",             CONTROL_SUBMISSION, TRUE}
357   };
358
359 /* Enable recursion between acl_check_internal() and acl_check_condition() */
360
361 static int acl_check_internal(int, address_item *, uschar *, int, uschar **,
362          uschar **);
363
364
365 /*************************************************
366 *         Pick out name from list                *
367 *************************************************/
368
369 /* Use a binary chop method
370
371 Arguments:
372   name        name to find
373   list        list of names
374   end         size of list
375
376 Returns:      offset in list, or -1 if not found
377 */
378
379 static int
380 acl_checkname(uschar *name, uschar **list, int end)
381 {
382 int start = 0;
383
384 while (start < end)
385   {
386   int mid = (start + end)/2;
387   int c = Ustrcmp(name, list[mid]);
388   if (c == 0) return mid;
389   if (c < 0) end = mid; else start = mid + 1;
390   }
391
392 return -1;
393 }
394
395
396 /*************************************************
397 *            Read and parse one ACL              *
398 *************************************************/
399
400 /* This function is called both from readconf in order to parse the ACLs in the
401 configuration file, and also when an ACL is encountered dynamically (e.g. as
402 the result of an expansion). It is given a function to call in order to
403 retrieve the lines of the ACL. This function handles skipping comments and
404 blank lines (where relevant).
405
406 Arguments:
407   func        function to get next line of ACL
408   error       where to put an error message
409
410 Returns:      pointer to ACL, or NULL
411               NULL can be legal (empty ACL); in this case error will be NULL
412 */
413
414 acl_block *
415 acl_read(uschar *(*func)(void), uschar **error)
416 {
417 acl_block *yield = NULL;
418 acl_block **lastp = &yield;
419 acl_block *this = NULL;
420 acl_condition_block *cond;
421 acl_condition_block **condp = NULL;
422 uschar *s;
423
424 *error = NULL;
425
426 while ((s = (*func)()) != NULL)
427   {
428   int v, c;
429   BOOL negated = FALSE;
430   uschar *saveline = s;
431   uschar name[64];
432
433   /* Conditions (but not verbs) are allowed to be negated by an initial
434   exclamation mark. */
435
436   while (isspace(*s)) s++;
437   if (*s == '!')
438     {
439     negated = TRUE;
440     s++;
441     }
442
443   /* Read the name of a verb or a condition, or the start of a new ACL */
444
445   s = readconf_readname(name, sizeof(name), s);
446   if (*s == ':')
447     {
448     if (negated || name[0] == 0)
449       {
450       *error = string_sprintf("malformed ACL name in \"%s\"", saveline);
451       return NULL;
452       }
453     break;
454     }
455
456   /* If a verb is unrecognized, it may be another condition or modifier that
457   continues the previous verb. */
458
459   v = acl_checkname(name, verbs, sizeof(verbs)/sizeof(char *));
460   if (v < 0)
461     {
462     if (this == NULL)
463       {
464       *error = string_sprintf("unknown ACL verb in \"%s\"", saveline);
465       return NULL;
466       }
467     }
468
469   /* New verb */
470
471   else
472     {
473     if (negated)
474       {
475       *error = string_sprintf("malformed ACL line \"%s\"", saveline);
476       return NULL;
477       }
478     this = store_get(sizeof(acl_block));
479     *lastp = this;
480     lastp = &(this->next);
481     this->next = NULL;
482     this->verb = v;
483     this->condition = NULL;
484     condp = &(this->condition);
485     if (*s == 0) continue;               /* No condition on this line */
486     if (*s == '!')
487       {
488       negated = TRUE;
489       s++;
490       }
491     s = readconf_readname(name, sizeof(name), s);  /* Condition name */
492     }
493
494   /* Handle a condition or modifier. */
495
496   c = acl_checkname(name, conditions, sizeof(conditions)/sizeof(char *));
497   if (c < 0)
498     {
499     *error = string_sprintf("unknown ACL condition/modifier in \"%s\"",
500       saveline);
501     return NULL;
502     }
503
504   /* The modifiers may not be negated */
505
506   if (negated && cond_modifiers[c])
507     {
508     *error = string_sprintf("ACL error: negation is not allowed with "
509       "\"%s\"", conditions[c]);
510     return NULL;
511     }
512
513   /* ENDPASS may occur only with ACCEPT or DISCARD. */
514
515   if (c == ACLC_ENDPASS &&
516       this->verb != ACL_ACCEPT &&
517       this->verb != ACL_DISCARD)
518     {
519     *error = string_sprintf("ACL error: \"%s\" is not allowed with \"%s\"",
520       conditions[c], verbs[this->verb]);
521     return NULL;
522     }
523
524   cond = store_get(sizeof(acl_condition_block));
525   cond->next = NULL;
526   cond->type = c;
527   cond->u.negated = negated;
528
529   *condp = cond;
530   condp = &(cond->next);
531
532   /* The "set" modifier is different in that its argument is "name=value"
533   rather than just a value, and we can check the validity of the name, which
534   gives us a variable number to insert into the data block. */
535
536   if (c == ACLC_SET)
537     {
538     if (Ustrncmp(s, "acl_", 4) != 0 || (s[4] != 'c' && s[4] != 'm') ||
539         !isdigit(s[5]) || (!isspace(s[6]) && s[6] != '='))
540       {
541       *error = string_sprintf("unrecognized name after \"set\" in ACL "
542         "modifier \"set %s\"", s);
543       return NULL;
544       }
545
546     cond->u.varnumber = s[5] - '0';
547     if (s[4] == 'm') cond->u.varnumber += ACL_C_MAX;
548     s += 6;
549     while (isspace(*s)) s++;
550     }
551
552   /* For "set", we are now positioned for the data. For the others, only
553   "endpass" has no data */
554
555   if (c != ACLC_ENDPASS)
556     {
557     if (*s++ != '=')
558       {
559       *error = string_sprintf("\"=\" missing after ACL \"%s\" %s", name,
560         cond_modifiers[c]? US"modifier" : US"condition");
561       return NULL;
562       }
563     while (isspace(*s)) s++;
564     cond->arg = string_copy(s);
565     }
566   }
567
568 return yield;
569 }
570
571
572
573 /*************************************************
574 *               Handle warnings                  *
575 *************************************************/
576
577 /* This function is called when a WARN verb's conditions are true. It adds to
578 the message's headers, and/or writes information to the log. In each case, this
579 only happens once (per message for headers, per connection for log).
580
581 Arguments:
582   where          ACL_WHERE_xxxx indicating which ACL this is
583   user_message   message for adding to headers
584   log_message    message for logging, if different
585
586 Returns:         nothing
587 */
588
589 static void
590 acl_warn(int where, uschar *user_message, uschar *log_message)
591 {
592 int hlen;
593
594 if (log_message != NULL && log_message != user_message)
595   {
596   uschar *text;
597   string_item *logged;
598
599   text = string_sprintf("%s Warning: %s",  host_and_ident(TRUE),
600     string_printing(log_message));
601
602   /* If a sender verification has failed, and the log message is "sender verify
603   failed", add the failure message. */
604
605   if (sender_verified_failed != NULL &&
606       sender_verified_failed->message != NULL &&
607       strcmpic(log_message, US"sender verify failed") == 0)
608     text = string_sprintf("%s: %s", text, sender_verified_failed->message);
609
610   /* Search previously logged warnings. They are kept in malloc store so they
611   can be freed at the start of a new message. */
612
613   for (logged = acl_warn_logged; logged != NULL; logged = logged->next)
614     if (Ustrcmp(logged->text, text) == 0) break;
615
616   if (logged == NULL)
617     {
618     int length = Ustrlen(text) + 1;
619     log_write(0, LOG_MAIN, "%s", text);
620     logged = store_malloc(sizeof(string_item) + length);
621     logged->text = (uschar *)logged + sizeof(string_item);
622     memcpy(logged->text, text, length);
623     logged->next = acl_warn_logged;
624     acl_warn_logged = logged;
625     }
626   }
627
628 /* If there's no user message, we are done. */
629
630 if (user_message == NULL) return;
631
632 /* If this isn't a message ACL, we can't do anything with a user message.
633 Log an error. */
634
635 if (where > ACL_WHERE_NOTSMTP)
636   {
637   log_write(0, LOG_MAIN|LOG_PANIC, "ACL \"warn\" with \"message\" setting "
638     "found in a non-message (%s) ACL: cannot specify header lines here: "
639     "message ignored", acl_wherenames[where]);
640   return;
641   }
642
643 /* Treat the user message as a sequence of one or more header lines. */
644
645 hlen = Ustrlen(user_message);
646 if (hlen > 0)
647   {
648   uschar *text, *p, *q;
649
650   /* Add a final newline if not present */
651
652   text = ((user_message)[hlen-1] == '\n')? user_message :
653     string_sprintf("%s\n", user_message);
654
655   /* Loop for multiple header lines, taking care about continuations */
656
657   for (p = q = text; *p != 0; )
658     {
659     uschar *s;
660     int newtype = htype_add_bot;
661     header_line **hptr = &acl_warn_headers;
662
663     /* Find next header line within the string */
664
665     for (;;)
666       {
667       q = Ustrchr(q, '\n');
668       if (*(++q) != ' ' && *q != '\t') break;
669       }
670
671     /* If the line starts with a colon, interpret the instruction for where to
672     add it. This temporarily sets up a new type. */
673
674     if (*p == ':')
675       {
676       if (strncmpic(p, US":after_received:", 16) == 0)
677         {
678         newtype = htype_add_rec;
679         p += 16;
680         }
681       else if (strncmpic(p, US":at_start:", 10) == 0)
682         {
683         newtype = htype_add_top;
684         p += 10;
685         }
686       else if (strncmpic(p, US":at_end:", 8) == 0)
687         {
688         newtype = htype_add_bot;
689         p += 8;
690         }
691       while (*p == ' ' || *p == '\t') p++;
692       }
693
694     /* See if this line starts with a header name, and if not, add X-ACL-Warn:
695     to the front of it. */
696
697     for (s = p; s < q - 1; s++)
698       {
699       if (*s == ':' || !isgraph(*s)) break;
700       }
701
702     s = string_sprintf("%s%.*s", (*s == ':')? "" : "X-ACL-Warn: ", q - p, p);
703     hlen = Ustrlen(s);
704
705     /* See if this line has already been added */
706
707     while (*hptr != NULL)
708       {
709       if (Ustrncmp((*hptr)->text, s, hlen) == 0) break;
710       hptr = &((*hptr)->next);
711       }
712
713     /* Add if not previously present */
714
715     if (*hptr == NULL)
716       {
717       header_line *h = store_get(sizeof(header_line));
718       h->text = s;
719       h->next = NULL;
720       h->type = newtype;
721       h->slen = hlen;
722       *hptr = h;
723       hptr = &(h->next);
724       }
725
726     /* Advance for next header line within the string */
727
728     p = q;
729     }
730   }
731 }
732
733
734
735 /*************************************************
736 *         Verify and check reverse DNS           *
737 *************************************************/
738
739 /* Called from acl_verify() below. We look up the host name(s) of the client IP
740 address if this has not yet been done. The host_name_lookup() function checks
741 that one of these names resolves to an address list that contains the client IP
742 address, so we don't actually have to do the check here.
743
744 Arguments:
745   user_msgptr  pointer for user message
746   log_msgptr   pointer for log message
747
748 Returns:       OK        verification condition succeeded
749                FAIL      verification failed
750                DEFER     there was a problem verifying
751 */
752
753 static int
754 acl_verify_reverse(uschar **user_msgptr, uschar **log_msgptr)
755 {
756 int rc;
757
758 user_msgptr = user_msgptr;  /* stop compiler warning */
759
760 /* Previous success */
761
762 if (sender_host_name != NULL) return OK;
763
764 /* Previous failure */
765
766 if (host_lookup_failed)
767   {
768   *log_msgptr = string_sprintf("host lookup failed%s", host_lookup_msg);
769   return FAIL;
770   }
771
772 /* Need to do a lookup */
773
774 HDEBUG(D_acl)
775   debug_printf("looking up host name to force name/address consistency check\n");
776
777 if ((rc = host_name_lookup()) != OK)
778   {
779   *log_msgptr = (rc == DEFER)?
780     US"host lookup deferred for reverse lookup check"
781     :
782     string_sprintf("host lookup failed for reverse lookup check%s",
783       host_lookup_msg);
784   return rc;    /* DEFER or FAIL */
785   }
786
787 host_build_sender_fullhost();
788 return OK;
789 }
790
791
792
793 /*************************************************
794 *     Handle verification (address & other)      *
795 *************************************************/
796
797 /* This function implements the "verify" condition. It is called when
798 encountered in any ACL, because some tests are almost always permitted. Some
799 just don't make sense, and always fail (for example, an attempt to test a host
800 lookup for a non-TCP/IP message). Others are restricted to certain ACLs.
801
802 Arguments:
803   where        where called from
804   addr         the recipient address that the ACL is handling, or NULL
805   arg          the argument of "verify"
806   user_msgptr  pointer for user message
807   log_msgptr   pointer for log message
808   basic_errno  where to put verify errno
809
810 Returns:       OK        verification condition succeeded
811                FAIL      verification failed
812                DEFER     there was a problem verifying
813                ERROR     syntax error
814 */
815
816 static int
817 acl_verify(int where, address_item *addr, uschar *arg,
818   uschar **user_msgptr, uschar **log_msgptr, int *basic_errno)
819 {
820 int sep = '/';
821 int callout = -1;
822 int callout_overall = -1;
823 int callout_connect = -1;
824 int verify_options = 0;
825 int rc;
826 BOOL verify_header_sender = FALSE;
827 BOOL defer_ok = FALSE;
828 BOOL callout_defer_ok = FALSE;
829 BOOL no_details = FALSE;
830 address_item *sender_vaddr = NULL;
831 uschar *verify_sender_address = NULL;
832 uschar *pm_mailfrom = NULL;
833 uschar *se_mailfrom = NULL;
834 uschar *list = arg;
835 uschar *ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size);
836
837 if (ss == NULL) goto BAD_VERIFY;
838
839 /* Handle name/address consistency verification in a separate function. */
840
841 if (strcmpic(ss, US"reverse_host_lookup") == 0)
842   {
843   if (sender_host_address == NULL) return OK;
844   return acl_verify_reverse(user_msgptr, log_msgptr);
845   }
846
847 /* TLS certificate verification is done at STARTTLS time; here we just
848 test whether it was successful or not. (This is for optional verification; for
849 mandatory verification, the connection doesn't last this long.) */
850
851 if (strcmpic(ss, US"certificate") == 0)
852   {
853   if (tls_certificate_verified) return OK;
854   *user_msgptr = US"no verified certificate";
855   return FAIL;
856   }
857
858 /* We can test the result of optional HELO verification */
859
860 if (strcmpic(ss, US"helo") == 0) return helo_verified? OK : FAIL;
861
862 /* Handle header verification options - permitted only after DATA or a non-SMTP
863 message. */
864
865 if (strncmpic(ss, US"header_", 7) == 0)
866   {
867   if (where != ACL_WHERE_DATA && where != ACL_WHERE_NOTSMTP)
868     {
869     *log_msgptr = string_sprintf("cannot check header contents in ACL for %s "
870       "(only possible in ACL for DATA)", acl_wherenames[where]);
871     return ERROR;
872     }
873
874   /* Check that all relevant header lines have the correct syntax. If there is
875   a syntax error, we return details of the error to the sender if configured to
876   send out full details. (But a "message" setting on the ACL can override, as
877   always). */
878
879   if (strcmpic(ss+7, US"syntax") == 0)
880     {
881     int rc = verify_check_headers(log_msgptr);
882     if (rc != OK && smtp_return_error_details && *log_msgptr != NULL)
883       *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
884     return rc;
885     }
886
887   /* Check that there is at least one verifiable sender address in the relevant
888   header lines. This can be followed by callout and defer options, just like
889   sender and recipient. */
890
891   else if (strcmpic(ss+7, US"sender") == 0) verify_header_sender = TRUE;
892
893   /* Unknown verify argument starting with "header_" */
894
895   else goto BAD_VERIFY;
896   }
897
898 /* Otherwise, first item in verify argument must be "sender" or "recipient".
899 In the case of a sender, this can optionally be followed by an address to use
900 in place of the actual sender (rare special-case requirement). */
901
902 else if (strncmpic(ss, US"sender", 6) == 0)
903   {
904   uschar *s = ss + 6;
905   if (where > ACL_WHERE_NOTSMTP)
906     {
907     *log_msgptr = string_sprintf("cannot verify sender in ACL for %s "
908       "(only possible for MAIL, RCPT, PREDATA, or DATA)",
909       acl_wherenames[where]);
910     return ERROR;
911     }
912   if (*s == 0)
913     verify_sender_address = sender_address;
914   else
915     {
916     while (isspace(*s)) s++;
917     if (*s++ != '=') goto BAD_VERIFY;
918     while (isspace(*s)) s++;
919     verify_sender_address = string_copy(s);
920     }
921   }
922 else
923   {
924   if (strcmpic(ss, US"recipient") != 0) goto BAD_VERIFY;
925   if (addr == NULL)
926     {
927     *log_msgptr = string_sprintf("cannot verify recipient in ACL for %s "
928       "(only possible for RCPT)", acl_wherenames[where]);
929     return ERROR;
930     }
931   }
932
933 /* Remaining items are optional */
934
935 while ((ss = string_nextinlist(&list, &sep, big_buffer, big_buffer_size))
936       != NULL)
937   {
938   if (strcmpic(ss, US"defer_ok") == 0) defer_ok = TRUE;
939   else if (strcmpic(ss, US"no_details") == 0) no_details = TRUE;
940
941   /* These two old options are left for backwards compatibility */
942
943   else if (strcmpic(ss, US"callout_defer_ok") == 0)
944     {
945     callout_defer_ok = TRUE;
946     if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
947     }
948
949   else if (strcmpic(ss, US"check_postmaster") == 0)
950      {
951      pm_mailfrom = US"";
952      if (callout == -1) callout = CALLOUT_TIMEOUT_DEFAULT;
953      }
954
955   /* The callout option has a number of sub-options, comma separated */
956
957   else if (strncmpic(ss, US"callout", 7) == 0)
958     {
959     callout = CALLOUT_TIMEOUT_DEFAULT;
960     ss += 7;
961     if (*ss != 0)
962       {
963       while (isspace(*ss)) ss++;
964       if (*ss++ == '=')
965         {
966         int optsep = ',';
967         uschar *opt;
968         uschar buffer[256];
969         while (isspace(*ss)) ss++;
970         
971         /* This callout option handling code has become a mess as new options 
972         have been added in an ad hoc manner. It should be tidied up into some 
973         kind of table-driven thing. */
974  
975         while ((opt = string_nextinlist(&ss, &optsep, buffer, sizeof(buffer)))
976               != NULL)
977           {
978           if (strcmpic(opt, US"defer_ok") == 0) callout_defer_ok = TRUE;
979           else if (strcmpic(opt, US"no_cache") == 0)
980              verify_options |= vopt_callout_no_cache;
981           else if (strcmpic(opt, US"random") == 0)
982              verify_options |= vopt_callout_random;
983           else if (strcmpic(opt, US"use_sender") == 0)
984              verify_options |= vopt_callout_recipsender;
985           else if (strcmpic(opt, US"use_postmaster") == 0)
986              verify_options |= vopt_callout_recippmaster;
987           else if (strcmpic(opt, US"postmaster") == 0) pm_mailfrom = US"";
988
989           else if (strncmpic(opt, US"mailfrom", 8) == 0)
990             {
991             if (!verify_header_sender)
992               {
993               *log_msgptr = string_sprintf("\"mailfrom\" is allowed as a "
994                 "callout option only for verify=header_sender (detected in ACL "
995                 "condition \"%s\")", arg);
996               return ERROR;
997               }
998             opt += 8;
999             while (isspace(*opt)) opt++;
1000             if (*opt++ != '=')
1001               {
1002               *log_msgptr = string_sprintf("'=' expected after "
1003                 "\"mailfrom\" in ACL condition \"%s\"", arg);
1004               return ERROR;
1005               }
1006             while (isspace(*opt)) opt++;
1007             se_mailfrom = string_copy(opt);
1008             }
1009
1010           else if (strncmpic(opt, US"postmaster_mailfrom", 19) == 0)
1011             {
1012             opt += 19;
1013             while (isspace(*opt)) opt++;
1014             if (*opt++ != '=')
1015               {
1016               *log_msgptr = string_sprintf("'=' expected after "
1017                 "\"postmaster_mailfrom\" in ACL condition \"%s\"", arg);
1018               return ERROR;
1019               }
1020             while (isspace(*opt)) opt++;
1021             pm_mailfrom = string_copy(opt);
1022             }
1023
1024           else if (strncmpic(opt, US"maxwait", 7) == 0)
1025             {
1026             opt += 7;
1027             while (isspace(*opt)) opt++;
1028             if (*opt++ != '=')
1029               {
1030               *log_msgptr = string_sprintf("'=' expected after \"maxwait\" in "
1031                 "ACL condition \"%s\"", arg);
1032               return ERROR;
1033               }
1034             while (isspace(*opt)) opt++;
1035             callout_overall = readconf_readtime(opt, 0, FALSE);
1036             if (callout_overall < 0)
1037               {
1038               *log_msgptr = string_sprintf("bad time value in ACL condition "
1039                 "\"verify %s\"", arg);
1040               return ERROR;
1041               }
1042             }
1043           else if (strncmpic(opt, US"connect", 7) == 0)
1044             {
1045             opt += 7;
1046             while (isspace(*opt)) opt++;
1047             if (*opt++ != '=')
1048               {
1049               *log_msgptr = string_sprintf("'=' expected after "
1050                 "\"callout_overaall\" in ACL condition \"%s\"", arg);
1051               return ERROR;
1052               }
1053             while (isspace(*opt)) opt++;
1054             callout_connect = readconf_readtime(opt, 0, FALSE);
1055             if (callout_connect < 0)
1056               {
1057               *log_msgptr = string_sprintf("bad time value in ACL condition "
1058                 "\"verify %s\"", arg);
1059               return ERROR;
1060               }
1061             }
1062           else    /* Plain time is callout connect/command timeout */
1063             {
1064             callout = readconf_readtime(opt, 0, FALSE);
1065             if (callout < 0)
1066               {
1067               *log_msgptr = string_sprintf("bad time value in ACL condition "
1068                 "\"verify %s\"", arg);
1069               return ERROR;
1070               }
1071             }
1072           }
1073         }
1074       else
1075         {
1076         *log_msgptr = string_sprintf("'=' expected after \"callout\" in "
1077           "ACL condition \"%s\"", arg);
1078         return ERROR;
1079         }
1080       }
1081     }
1082
1083   /* Option not recognized */
1084
1085   else
1086     {
1087     *log_msgptr = string_sprintf("unknown option \"%s\" in ACL "
1088       "condition \"verify %s\"", ss, arg);
1089     return ERROR;
1090     }
1091   }
1092
1093 if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster)) ==
1094       (vopt_callout_recipsender|vopt_callout_recippmaster))
1095   {
1096   *log_msgptr = US"only one of use_sender and use_postmaster can be set "
1097     "for a recipient callout";
1098   return ERROR;
1099   }
1100
1101 /* Handle sender-in-header verification. Default the user message to the log
1102 message if giving out verification details. */
1103
1104 if (verify_header_sender)
1105   {
1106   rc = verify_check_header_address(user_msgptr, log_msgptr, callout,
1107     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, verify_options);
1108   if (smtp_return_error_details)
1109     {
1110     if (*user_msgptr == NULL && *log_msgptr != NULL)
1111       *user_msgptr = string_sprintf("Rejected after DATA: %s", *log_msgptr);
1112     if (rc == DEFER) acl_temp_details = TRUE;
1113     }
1114   }
1115
1116 /* Handle a sender address. The default is to verify *the* sender address, but
1117 optionally a different address can be given, for special requirements. If the
1118 address is empty, we are dealing with a bounce message that has no sender, so
1119 we cannot do any checking. If the real sender address gets rewritten during
1120 verification (e.g. DNS widening), set the flag to stop it being rewritten again
1121 during message reception.
1122
1123 A list of verified "sender" addresses is kept to try to avoid doing to much
1124 work repetitively when there are multiple recipients in a message and they all
1125 require sender verification. However, when callouts are involved, it gets too
1126 complicated because different recipients may require different callout options.
1127 Therefore, we always do a full sender verify when any kind of callout is
1128 specified. Caching elsewhere, for instance in the DNS resolver and in the
1129 callout handling, should ensure that this is not terribly inefficient. */
1130
1131 else if (verify_sender_address != NULL)
1132   {
1133   if ((verify_options & (vopt_callout_recipsender|vopt_callout_recippmaster))
1134        != 0)
1135     {
1136     *log_msgptr = US"use_sender or use_postmaster cannot be used for a "
1137       "sender verify callout";
1138     return ERROR;
1139     }
1140
1141   sender_vaddr = verify_checked_sender(verify_sender_address);
1142   if (sender_vaddr != NULL &&               /* Previously checked */
1143       callout <= 0)                         /* No callout needed this time */
1144     {
1145     /* If the "routed" flag is set, it means that routing worked before, so
1146     this check can give OK (the saved return code value, if set, belongs to a
1147     callout that was done previously). If the "routed" flag is not set, routing
1148     must have failed, so we use the saved return code. */
1149
1150     if (testflag(sender_vaddr, af_verify_routed)) rc = OK; else
1151       {
1152       rc = sender_vaddr->special_action;
1153       *basic_errno = sender_vaddr->basic_errno;
1154       }
1155     HDEBUG(D_acl) debug_printf("using cached sender verify result\n");
1156     }
1157
1158   /* Do a new verification, and cache the result. The cache is used to avoid
1159   verifying the sender multiple times for multiple RCPTs when callouts are not
1160   specified (see comments above).
1161
1162   The cache is also used on failure to give details in response to the first
1163   RCPT that gets bounced for this reason. However, this can be suppressed by
1164   the no_details option, which sets the flag that says "this detail has already
1165   been sent". The cache normally contains just one address, but there may be
1166   more in esoteric circumstances. */
1167
1168   else
1169     {
1170     BOOL routed = TRUE;
1171     uschar *save_address_data = deliver_address_data;
1172       
1173     sender_vaddr = deliver_make_addr(verify_sender_address, TRUE);
1174     if (no_details) setflag(sender_vaddr, af_sverify_told);
1175     if (verify_sender_address[0] != 0)
1176       {
1177       /* If this is the real sender address, save the unrewritten version
1178       for use later in receive. Otherwise, set a flag so that rewriting the
1179       sender in verify_address() does not update sender_address. */
1180
1181       if (verify_sender_address == sender_address)
1182         sender_address_unrewritten = sender_address;
1183       else
1184         verify_options |= vopt_fake_sender;
1185
1186       /* The recipient, qualify, and expn options are never set in
1187       verify_options. */
1188
1189       rc = verify_address(sender_vaddr, NULL, verify_options, callout,
1190         callout_overall, callout_connect, se_mailfrom, pm_mailfrom, &routed);
1191
1192       HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
1193
1194       if (rc == OK)
1195         {
1196         if (Ustrcmp(sender_vaddr->address, verify_sender_address) != 0)
1197           {
1198           DEBUG(D_acl) debug_printf("sender %s verified ok as %s\n",
1199             verify_sender_address, sender_vaddr->address);
1200           }
1201         else
1202           {
1203           DEBUG(D_acl) debug_printf("sender %s verified ok\n",
1204             verify_sender_address);
1205           }
1206         }
1207       else *basic_errno = sender_vaddr->basic_errno;
1208       }
1209     else rc = OK;  /* Null sender */
1210
1211     /* Cache the result code */
1212
1213     if (routed) setflag(sender_vaddr, af_verify_routed);
1214     if (callout > 0) setflag(sender_vaddr, af_verify_callout);
1215     sender_vaddr->special_action = rc;
1216     sender_vaddr->next = sender_verified_list;
1217     sender_verified_list = sender_vaddr;
1218     
1219     /* Restore the recipient address data, which might have been clobbered by 
1220     the sender verification. */
1221   
1222     deliver_address_data = save_address_data;
1223     }
1224     
1225   /* Put the sender address_data value into $sender_address_data */
1226
1227   sender_address_data = sender_vaddr->p.address_data; 
1228   }
1229
1230 /* A recipient address just gets a straightforward verify; again we must handle
1231 the DEFER overrides. */
1232
1233 else
1234   {
1235   address_item addr2;
1236
1237   /* We must use a copy of the address for verification, because it might
1238   get rewritten. */
1239
1240   addr2 = *addr;
1241   rc = verify_address(&addr2, NULL, verify_options|vopt_is_recipient, callout,
1242     callout_overall, callout_connect, se_mailfrom, pm_mailfrom, NULL);
1243   HDEBUG(D_acl) debug_printf("----------- end verify ------------\n");
1244   *log_msgptr = addr2.message;
1245   *user_msgptr = addr2.user_message;
1246   *basic_errno = addr2.basic_errno;
1247
1248   /* Make $address_data visible */
1249   deliver_address_data = addr2.p.address_data;
1250   }
1251
1252 /* We have a result from the relevant test. Handle defer overrides first. */
1253
1254 if (rc == DEFER && (defer_ok ||
1255    (callout_defer_ok && *basic_errno == ERRNO_CALLOUTDEFER)))
1256   {
1257   HDEBUG(D_acl) debug_printf("verify defer overridden by %s\n",
1258     defer_ok? "defer_ok" : "callout_defer_ok");
1259   rc = OK;
1260   }
1261
1262 /* If we've failed a sender, set up a recipient message, and point
1263 sender_verified_failed to the address item that actually failed. */
1264
1265 if (rc != OK && verify_sender_address != NULL)
1266   {
1267   if (rc != DEFER)
1268     {
1269     *log_msgptr = *user_msgptr = US"Sender verify failed";
1270     }
1271   else if (*basic_errno != ERRNO_CALLOUTDEFER)
1272     {
1273     *log_msgptr = *user_msgptr = US"Could not complete sender verify";
1274     }
1275   else
1276     {
1277     *log_msgptr = US"Could not complete sender verify callout";
1278     *user_msgptr = smtp_return_error_details? sender_vaddr->user_message :
1279       *log_msgptr;
1280     }
1281
1282   sender_verified_failed = sender_vaddr;
1283   }
1284
1285 /* Verifying an address messes up the values of $domain and $local_part,
1286 so reset them before returning if this is a RCPT ACL. */
1287
1288 if (addr != NULL)
1289   {
1290   deliver_domain = addr->domain;
1291   deliver_localpart = addr->local_part;
1292   }
1293 return rc;
1294
1295 /* Syntax errors in the verify argument come here. */
1296
1297 BAD_VERIFY:
1298 *log_msgptr = string_sprintf("expected \"sender[=address]\", \"recipient\", "
1299   "\"header_syntax\" or \"header_sender\" at start of ACL condition "
1300   "\"verify %s\"", arg);
1301 return ERROR;
1302 }
1303
1304
1305
1306
1307 /*************************************************
1308 *        Check argument for control= modifier    *
1309 *************************************************/
1310
1311 /* Called from acl_check_condition() below
1312
1313 Arguments:
1314   arg         the argument string for control=
1315   pptr        set to point to the terminating character
1316   where       which ACL we are in
1317   log_msgptr  for error messages
1318
1319 Returns:      CONTROL_xxx value
1320 */
1321
1322 static int
1323 decode_control(uschar *arg, uschar **pptr, int where, uschar **log_msgptr)
1324 {
1325 int len;
1326 control_def *d;
1327
1328 for (d = controls_list;
1329      d < controls_list + sizeof(controls_list)/sizeof(control_def);
1330      d++)
1331   {
1332   len = Ustrlen(d->name);
1333   if (Ustrncmp(d->name, arg, len) == 0) break;
1334   }
1335
1336 if (d >= controls_list + sizeof(controls_list)/sizeof(control_def) ||
1337    (arg[len] != 0 && (!d->has_option || arg[len] != '/')))
1338   {
1339   *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
1340   return CONTROL_ERROR;
1341   }
1342
1343 *pptr = arg + len;
1344 return d->value;
1345 }
1346
1347
1348
1349 /*************************************************
1350 *   Handle conditions/modifiers on an ACL item   *
1351 *************************************************/
1352
1353 /* Called from acl_check() below.
1354
1355 Arguments:
1356   verb         ACL verb
1357   cb           ACL condition block - if NULL, result is OK
1358   where        where called from
1359   addr         the address being checked for RCPT, or NULL
1360   level        the nesting level
1361   epp          pointer to pass back TRUE if "endpass" encountered
1362                  (applies only to "accept" and "discard")
1363   user_msgptr  user message pointer
1364   log_msgptr   log message pointer
1365   basic_errno  pointer to where to put verify error
1366
1367 Returns:       OK        - all conditions are met
1368                DISCARD   - an "acl" condition returned DISCARD - only allowed
1369                              for "accept" or "discard" verbs
1370                FAIL      - at least one condition fails
1371                FAIL_DROP - an "acl" condition returned FAIL_DROP
1372                DEFER     - can't tell at the moment (typically, lookup defer,
1373                              but can be temporary callout problem)
1374                ERROR     - ERROR from nested ACL or expansion failure or other
1375                              error
1376 */
1377
1378 static int
1379 acl_check_condition(int verb, acl_condition_block *cb, int where,
1380   address_item *addr, int level, BOOL *epp, uschar **user_msgptr,
1381   uschar **log_msgptr, int *basic_errno)
1382 {
1383 uschar *user_message = NULL;
1384 uschar *log_message = NULL;
1385 uschar *p;
1386 int rc = OK;
1387
1388 for (; cb != NULL; cb = cb->next)
1389   {
1390   uschar *arg;
1391   int control_type; 
1392
1393   /* The message and log_message items set up messages to be used in
1394   case of rejection. They are expanded later. */
1395
1396   if (cb->type == ACLC_MESSAGE)
1397     {
1398     user_message = cb->arg;
1399     continue;
1400     }
1401
1402   if (cb->type == ACLC_LOG_MESSAGE)
1403     {
1404     log_message = cb->arg;
1405     continue;
1406     }
1407
1408   /* The endpass "condition" just sets a flag to show it occurred. This is
1409   checked at compile time to be on an "accept" or "discard" item. */
1410
1411   if (cb->type == ACLC_ENDPASS)
1412     {
1413     *epp = TRUE;
1414     continue;
1415     }
1416
1417   /* For other conditions and modifiers, the argument is expanded now for some
1418   of them, but not for all, because expansion happens down in some lower level
1419   checking functions in some cases. */
1420
1421   if (cond_expand_at_top[cb->type])
1422     {
1423     arg = expand_string(cb->arg);
1424     if (arg == NULL)
1425       {
1426       if (expand_string_forcedfail) continue;
1427       *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s",
1428         cb->arg, expand_string_message);
1429       return search_find_defer? DEFER : ERROR;
1430       }
1431     }
1432   else arg = cb->arg;
1433
1434   /* Show condition, and expanded condition if it's different */
1435
1436   HDEBUG(D_acl)
1437     {
1438     int lhswidth = 0;
1439     debug_printf("check %s%s %n",
1440       (!cond_modifiers[cb->type] && cb->u.negated)? "!":"",
1441       conditions[cb->type], &lhswidth);
1442
1443     if (cb->type == ACLC_SET)
1444       {
1445       int n = cb->u.varnumber;
1446       int t = (n < ACL_C_MAX)? 'c' : 'm';
1447       if (n >= ACL_C_MAX) n -= ACL_C_MAX;
1448       debug_printf("acl_%c%d ", t, n);
1449       lhswidth += 7;
1450       }
1451
1452     debug_printf("= %s\n", cb->arg);
1453
1454     if (arg != cb->arg)
1455       debug_printf("%.*s= %s\n", lhswidth,
1456       US"                             ", CS arg);
1457     }
1458
1459   /* Check that this condition makes sense at this time */
1460
1461   if ((cond_forbids[cb->type] & (1 << where)) != 0)
1462     {
1463     *log_msgptr = string_sprintf("cannot %s %s condition in %s ACL",
1464       cond_modifiers[cb->type]? "use" : "test",
1465       conditions[cb->type], acl_wherenames[where]);
1466     return ERROR;
1467     }
1468
1469   /* Run the appropriate test for each condition, or take the appropriate
1470   action for the remaining modifiers. */
1471
1472   switch(cb->type)
1473     {
1474     /* A nested ACL that returns "discard" makes sense only for an "accept" or
1475     "discard" verb. */
1476
1477     case ACLC_ACL:
1478     rc = acl_check_internal(where, addr, arg, level+1, user_msgptr, log_msgptr);
1479     if (rc == DISCARD && verb != ACL_ACCEPT && verb != ACL_DISCARD)
1480       {
1481       *log_msgptr = string_sprintf("nested ACL returned \"discard\" for "
1482         "\"%s\" command (only allowed with \"accept\" or \"discard\")",
1483         verbs[verb]);
1484       return ERROR;
1485       }
1486     break;
1487
1488     case ACLC_AUTHENTICATED:
1489     rc = (sender_host_authenticated == NULL)? FAIL :
1490       match_isinlist(sender_host_authenticated, &arg, 0, NULL, NULL, MCL_STRING,
1491         TRUE, NULL);
1492     break;
1493
1494     case ACLC_CONDITION:
1495     if (Ustrspn(arg, "0123456789") == Ustrlen(arg))     /* Digits, or empty */
1496       rc = (Uatoi(arg) == 0)? FAIL : OK;
1497     else
1498       rc = (strcmpic(arg, US"no") == 0 ||
1499             strcmpic(arg, US"false") == 0)? FAIL :
1500            (strcmpic(arg, US"yes") == 0 ||
1501             strcmpic(arg, US"true") == 0)? OK : DEFER;
1502     if (rc == DEFER)
1503       *log_msgptr = string_sprintf("invalid \"condition\" value \"%s\"", arg);
1504     break;
1505
1506     case ACLC_CONTROL:
1507     control_type = decode_control(arg, &p, where, log_msgptr);
1508
1509     /* Check this control makes sense at this time */
1510
1511     if ((control_forbids[control_type] & (1 << where)) != 0)
1512       {
1513       *log_msgptr = string_sprintf("cannot use \"control=%s\" in %s ACL",
1514         controls[control_type], acl_wherenames[where]);
1515       return ERROR;
1516       }                                                     
1517
1518     switch(control_type)
1519       {
1520       case CONTROL_ERROR:
1521       return ERROR;
1522
1523       case CONTROL_CASEFUL_LOCAL_PART:
1524       deliver_localpart = addr->cc_local_part;
1525       break;
1526
1527       case CONTROL_CASELOWER_LOCAL_PART:
1528       deliver_localpart = addr->lc_local_part;
1529       break;
1530
1531       case CONTROL_ENFORCE_SYNC:
1532       smtp_enforce_sync = TRUE;
1533       break;
1534
1535       case CONTROL_NO_ENFORCE_SYNC:
1536       smtp_enforce_sync = FALSE;
1537       break;
1538
1539 #ifdef WITH_CONTENT_SCAN
1540       case CONTROL_NO_MBOX_UNSPOOL:
1541       no_mbox_unspool = TRUE;
1542       break;
1543 #endif
1544
1545       case CONTROL_NO_MULTILINE:
1546       no_multiline_responses = TRUE;
1547       break;
1548
1549 #ifdef WITH_CONTENT_SCAN
1550       case CONTROL_FAKEREJECT:
1551       fake_reject = TRUE;
1552       break;
1553 #endif
1554
1555       case CONTROL_FREEZE:
1556       deliver_freeze = TRUE;
1557       deliver_frozen_at = time(NULL);
1558       break;
1559
1560       case CONTROL_QUEUE_ONLY:
1561       queue_only_policy = TRUE;
1562       break;
1563
1564       case CONTROL_SUBMISSION:
1565       submission_mode = TRUE;
1566       while (*p == '/')
1567         { 
1568         if (Ustrncmp(p, "/sender_retain", 14) == 0)
1569           {
1570           p += 14;
1571           active_local_sender_retain = TRUE;
1572           active_local_from_check = FALSE;   
1573           }  
1574         else if (Ustrncmp(p, "/domain=", 8) == 0)
1575           {
1576           uschar *pp = p + 8;
1577           while (*pp != 0 && *pp != '/') pp++; 
1578           submission_domain = string_copyn(p+8, pp-p);
1579           p = pp; 
1580           }
1581         else break;   
1582         }   
1583       if (*p != 0)
1584         {
1585         *log_msgptr = string_sprintf("syntax error in \"control=%s\"", arg);
1586         return ERROR;
1587         }
1588       break;
1589       }
1590     break;
1591
1592 #ifdef WITH_CONTENT_SCAN
1593     case ACLC_DECODE:
1594     rc = mime_decode(&arg);
1595     break;
1596 #endif
1597
1598     case ACLC_DELAY:
1599       {
1600       int delay = readconf_readtime(arg, 0, FALSE);
1601       if (delay < 0)
1602         {
1603         *log_msgptr = string_sprintf("syntax error in argument for \"delay\" "
1604           "modifier: \"%s\" is not a time value", arg);
1605         return ERROR;
1606         }
1607       else
1608         {
1609         HDEBUG(D_acl) debug_printf("delay modifier requests %d-second delay\n",
1610           delay);
1611         if (host_checking)
1612           {
1613           HDEBUG(D_acl)
1614             debug_printf("delay skipped in -bh checking mode\n");
1615           }
1616         else sleep(delay);
1617         }
1618       }
1619     break;
1620
1621     case ACLC_DNSLISTS:
1622     rc = verify_check_dnsbl(&arg);
1623     break;
1624
1625     case ACLC_DOMAINS:
1626     rc = match_isinlist(addr->domain, &arg, 0, &domainlist_anchor,
1627       addr->domain_cache, MCL_DOMAIN, TRUE, &deliver_domain_data);
1628     break;
1629
1630     /* The value in tls_cipher is the full cipher name, for example,
1631     TLSv1:DES-CBC3-SHA:168, whereas the values to test for are just the
1632     cipher names such as DES-CBC3-SHA. But program defensively. We don't know
1633     what may in practice come out of the SSL library - which at the time of
1634     writing is poorly documented. */
1635
1636     case ACLC_ENCRYPTED:
1637     if (tls_cipher == NULL) rc = FAIL; else
1638       {
1639       uschar *endcipher = NULL;
1640       uschar *cipher = Ustrchr(tls_cipher, ':');
1641       if (cipher == NULL) cipher = tls_cipher; else
1642         {
1643         endcipher = Ustrchr(++cipher, ':');
1644         if (endcipher != NULL) *endcipher = 0;
1645         }
1646       rc = match_isinlist(cipher, &arg, 0, NULL, NULL, MCL_STRING, TRUE, NULL);
1647       if (endcipher != NULL) *endcipher = ':';
1648       }
1649     break;
1650
1651     /* Use verify_check_this_host() instead of verify_check_host() so that
1652     we can pass over &host_data to catch any looked up data. Once it has been
1653     set, it retains its value so that it's still there if another ACL verb
1654     comes through here and uses the cache. However, we must put it into
1655     permanent store in case it is also expected to be used in a subsequent
1656     message in the same SMTP connection. */
1657
1658     case ACLC_HOSTS:
1659     rc = verify_check_this_host(&arg, sender_host_cache, NULL,
1660       (sender_host_address == NULL)? US"" : sender_host_address, &host_data);
1661     if (host_data != NULL) host_data = string_copy_malloc(host_data);
1662     break;
1663
1664     case ACLC_LOCAL_PARTS:
1665     rc = match_isinlist(addr->cc_local_part, &arg, 0,
1666       &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART, TRUE,
1667       &deliver_localpart_data);
1668     break;
1669
1670     case ACLC_LOGWRITE:
1671       {
1672       int logbits = 0;
1673       uschar *s = arg;
1674       if (*s == ':')
1675         {
1676         s++;
1677         while (*s != ':')
1678           {
1679           if (Ustrncmp(s, "main", 4) == 0)
1680             { logbits |= LOG_MAIN; s += 4; }
1681           else if (Ustrncmp(s, "panic", 5) == 0)
1682             { logbits |= LOG_PANIC; s += 5; }
1683           else if (Ustrncmp(s, "reject", 6) == 0)
1684             { logbits |= LOG_REJECT; s += 6; }
1685           else
1686             {
1687             logbits = LOG_MAIN|LOG_PANIC;
1688             s = string_sprintf(":unknown log name in \"%s\" in "
1689               "\"logwrite\" in %s ACL", arg, acl_wherenames[where]);
1690             }
1691           if (*s == ',') s++;
1692           }
1693         s++;
1694         }
1695       while (isspace(*s)) s++;
1696       if (logbits == 0) logbits = LOG_MAIN;
1697       log_write(0, logbits, "%s", string_printing(s));
1698       }
1699     break;
1700     
1701 #ifdef WITH_CONTENT_SCAN
1702     case ACLC_MALWARE:
1703       {
1704       /* Seperate the regular expression and any optional parameters. */
1705       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
1706       /* Run the malware backend. */
1707       rc = malware(&ss);
1708       /* Modify return code based upon the existance of options. */
1709       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
1710             != NULL) {
1711         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
1712           {
1713           /* FAIL so that the message is passed to the next ACL */
1714           rc = FAIL;
1715           }
1716         }
1717       }
1718     break;
1719
1720     case ACLC_MIME_REGEX:
1721       rc = mime_regex(&arg);
1722     break;
1723 #endif
1724
1725     case ACLC_RECIPIENTS:
1726     rc = match_address_list(addr->address, TRUE, TRUE, &arg, NULL, -1, 0,
1727       &recipient_data);
1728     break;
1729
1730 #ifdef WITH_CONTENT_SCAN
1731    case ACLC_REGEX:
1732       rc = regex(&arg);
1733     break;
1734 #endif
1735
1736     case ACLC_SENDER_DOMAINS:
1737       {
1738       uschar *sdomain;
1739       sdomain = Ustrrchr(sender_address, '@');
1740       sdomain = (sdomain == NULL)? US"" : sdomain + 1;
1741       rc = match_isinlist(sdomain, &arg, 0, &domainlist_anchor,
1742         sender_domain_cache, MCL_DOMAIN, TRUE, NULL);
1743       }
1744     break;
1745
1746     case ACLC_SENDERS:
1747     rc = match_address_list(sender_address, TRUE, TRUE, &arg,
1748       sender_address_cache, -1, 0, &sender_data);
1749     break;
1750
1751     /* Connection variables must persist forever */
1752
1753     case ACLC_SET:
1754       {
1755       int old_pool = store_pool;
1756       if (cb->u.varnumber < ACL_C_MAX) store_pool = POOL_PERM;
1757       acl_var[cb->u.varnumber] = string_copy(arg);
1758       store_pool = old_pool;
1759       }
1760     break;
1761
1762 #ifdef WITH_CONTENT_SCAN
1763     case ACLC_SPAM:
1764       {
1765       /* Seperate the regular expression and any optional parameters. */
1766       uschar *ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size);
1767       /* Run the spam backend. */
1768       rc = spam(&ss);
1769       /* Modify return code based upon the existance of options. */
1770       while ((ss = string_nextinlist(&arg, &sep, big_buffer, big_buffer_size))
1771             != NULL) {
1772         if (strcmpic(ss, US"defer_ok") == 0 && rc == DEFER)
1773           {
1774           /* FAIL so that the message is passed to the next ACL */
1775           rc = FAIL;
1776           }
1777         }
1778       }
1779     break;
1780 #endif
1781
1782     /* If the verb is WARN, discard any user message from verification, because
1783     such messages are SMTP responses, not header additions. The latter come
1784     only from explicit "message" modifiers. */
1785
1786     case ACLC_VERIFY:
1787     rc = acl_verify(where, addr, arg, user_msgptr, log_msgptr, basic_errno);
1788     if (verb == ACL_WARN) *user_msgptr = NULL;
1789     break;
1790
1791     default:
1792     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown "
1793       "condition %d", cb->type);
1794     break;
1795     }
1796
1797   /* If a condition was negated, invert OK/FAIL. */
1798
1799   if (!cond_modifiers[cb->type] && cb->u.negated)
1800     {
1801     if (rc == OK) rc = FAIL;
1802       else if (rc == FAIL || rc == FAIL_DROP) rc = OK;
1803     }
1804
1805   if (rc != OK) break;   /* Conditions loop */
1806   }
1807
1808
1809 /* If the result is the one for which "message" and/or "log_message" are used,
1810 handle the values of these options. Most verbs have but a single return for
1811 which the messages are relevant, but for "discard", it's useful to have the log
1812 message both when it succeeds and when it fails. Also, for an "accept" that
1813 appears in a QUIT ACL, we want to handle the user message. Since only "accept"
1814 and "warn" are permitted in that ACL, we don't need to test the verb.
1815
1816 These modifiers act in different ways:
1817
1818 "message" is a user message that will be included in an SMTP response. Unless
1819 it is empty, it overrides any previously set user message.
1820
1821 "log_message" is a non-user message, and it adds to any existing non-user
1822 message that is already set.
1823
1824 If there isn't a log message set, we make it the same as the user message. */
1825
1826 if (((rc == FAIL_DROP)? FAIL : rc) == msgcond[verb] ||
1827     (verb == ACL_DISCARD && rc == OK) ||
1828     (where == ACL_WHERE_QUIT))
1829   {
1830   uschar *expmessage;
1831
1832   /* If the verb is "warn", messages generated by conditions (verification or
1833   nested ACLs) are discarded. Only messages specified at this level are used.
1834   However, the value of an existing message is available in $acl_verify_message
1835   during expansions. */
1836
1837   uschar *old_user_msgptr = *user_msgptr;
1838   uschar *old_log_msgptr = (*log_msgptr != NULL)? *log_msgptr : old_user_msgptr;
1839
1840   if (verb == ACL_WARN) *log_msgptr = *user_msgptr = NULL;
1841
1842   if (user_message != NULL)
1843     {
1844     acl_verify_message = old_user_msgptr;
1845     expmessage = expand_string(user_message);
1846     if (expmessage == NULL)
1847       {
1848       if (!expand_string_forcedfail)
1849         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
1850           user_message, expand_string_message);
1851       }
1852     else if (expmessage[0] != 0) *user_msgptr = expmessage;
1853     }
1854
1855   if (log_message != NULL)
1856     {
1857     acl_verify_message = old_log_msgptr;
1858     expmessage = expand_string(log_message);
1859     if (expmessage == NULL)
1860       {
1861       if (!expand_string_forcedfail)
1862         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand ACL message \"%s\": %s",
1863           log_message, expand_string_message);
1864       }
1865     else if (expmessage[0] != 0)
1866       {
1867       *log_msgptr = (*log_msgptr == NULL)? expmessage :
1868         string_sprintf("%s: %s", expmessage, *log_msgptr);
1869       }
1870     }
1871
1872   /* If no log message, default it to the user message */
1873
1874   if (*log_msgptr == NULL) *log_msgptr = *user_msgptr;
1875   }
1876
1877 acl_verify_message = NULL;
1878 return rc;
1879 }
1880
1881
1882
1883
1884
1885 /*************************************************
1886 *        Get line from a literal ACL             *
1887 *************************************************/
1888
1889 /* This function is passed to acl_read() in order to extract individual lines
1890 of a literal ACL, which we access via static pointers. We can destroy the
1891 contents because this is called only once (the compiled ACL is remembered).
1892
1893 This code is intended to treat the data in the same way as lines in the main
1894 Exim configuration file. That is:
1895
1896   . Leading spaces are ignored.
1897
1898   . A \ at the end of a line is a continuation - trailing spaces after the \
1899     are permitted (this is because I don't believe in making invisible things
1900     significant). Leading spaces on the continued part of a line are ignored.
1901
1902   . Physical lines starting (significantly) with # are totally ignored, and
1903     may appear within a sequence of backslash-continued lines.
1904
1905   . Blank lines are ignored, but will end a sequence of continuations.
1906
1907 Arguments: none
1908 Returns:   a pointer to the next line
1909 */
1910
1911
1912 static uschar *acl_text;          /* Current pointer in the text */
1913 static uschar *acl_text_end;      /* Points one past the terminating '0' */
1914
1915
1916 static uschar *
1917 acl_getline(void)
1918 {
1919 uschar *yield;
1920
1921 /* This loop handles leading blank lines and comments. */
1922
1923 for(;;)
1924   {
1925   while (isspace(*acl_text)) acl_text++;   /* Leading spaces/empty lines */
1926   if (*acl_text == 0) return NULL;         /* No more data */
1927   yield = acl_text;                        /* Potential data line */
1928
1929   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
1930
1931   /* If we hit the end before a newline, we have the whole logical line. If
1932   it's a comment, there's no more data to be given. Otherwise, yield it. */
1933
1934   if (*acl_text == 0) return (*yield == '#')? NULL : yield;
1935
1936   /* After reaching a newline, end this loop if the physical line does not
1937   start with '#'. If it does, it's a comment, and the loop continues. */
1938
1939   if (*yield != '#') break;
1940   }
1941
1942 /* This loop handles continuations. We know we have some real data, ending in
1943 newline. See if there is a continuation marker at the end (ignoring trailing
1944 white space). We know that *yield is not white space, so no need to test for
1945 cont > yield in the backwards scanning loop. */
1946
1947 for(;;)
1948   {
1949   uschar *cont;
1950   for (cont = acl_text - 1; isspace(*cont); cont--);
1951
1952   /* If no continuation follows, we are done. Mark the end of the line and
1953   return it. */
1954
1955   if (*cont != '\\')
1956     {
1957     *acl_text++ = 0;
1958     return yield;
1959     }
1960
1961   /* We have encountered a continuation. Skip over whitespace at the start of
1962   the next line, and indeed the whole of the next line or lines if they are
1963   comment lines. */
1964
1965   for (;;)
1966     {
1967     while (*(++acl_text) == ' ' || *acl_text == '\t');
1968     if (*acl_text != '#') break;
1969     while (*(++acl_text) != 0 && *acl_text != '\n');
1970     }
1971
1972   /* We have the start of a continuation line. Move all the rest of the data
1973   to join onto the previous line, and then find its end. If the end is not a
1974   newline, we are done. Otherwise loop to look for another continuation. */
1975
1976   memmove(cont, acl_text, acl_text_end - acl_text);
1977   acl_text_end -= acl_text - cont;
1978   acl_text = cont;
1979   while (*acl_text != 0 && *acl_text != '\n') acl_text++;
1980   if (*acl_text == 0) return yield;
1981   }
1982
1983 /* Control does not reach here */
1984 }
1985
1986
1987
1988
1989
1990 /*************************************************
1991 *        Check access using an ACL               *
1992 *************************************************/
1993
1994 /* This function is called from address_check. It may recurse via
1995 acl_check_condition() - hence the use of a level to stop looping. The ACL is
1996 passed as a string which is expanded. A forced failure implies no access check
1997 is required. If the result is a single word, it is taken as the name of an ACL
1998 which is sought in the global ACL tree. Otherwise, it is taken as literal ACL
1999 text, complete with newlines, and parsed as such. In both cases, the ACL check
2000 is then run. This function uses an auxiliary function for acl_read() to call
2001 for reading individual lines of a literal ACL. This is acl_getline(), which
2002 appears immediately above.
2003
2004 Arguments:
2005   where        where called from
2006   addr         address item when called from RCPT; otherwise NULL
2007   s            the input string; NULL is the same as an empty ACL => DENY
2008   level        the nesting level
2009   user_msgptr  where to put a user error (for SMTP response)
2010   log_msgptr   where to put a logging message (not for SMTP response)
2011
2012 Returns:       OK         access is granted
2013                DISCARD    access is apparently granted...
2014                FAIL       access is denied
2015                FAIL_DROP  access is denied; drop the connection
2016                DEFER      can't tell at the moment
2017                ERROR      disaster
2018 */
2019
2020 static int
2021 acl_check_internal(int where, address_item *addr, uschar *s, int level,
2022   uschar **user_msgptr, uschar **log_msgptr)
2023 {
2024 int fd = -1;
2025 acl_block *acl = NULL;
2026 uschar *acl_name = US"inline ACL";
2027 uschar *ss;
2028
2029 /* Catch configuration loops */
2030
2031 if (level > 20)
2032   {
2033   *log_msgptr = US"ACL nested too deep: possible loop";
2034   return ERROR;
2035   }
2036
2037 if (s == NULL)
2038   {
2039   HDEBUG(D_acl) debug_printf("ACL is NULL: implicit DENY\n");
2040   return FAIL;
2041   }
2042
2043 /* At top level, we expand the incoming string. At lower levels, it has already
2044 been expanded as part of condition processing. */
2045
2046 if (level == 0)
2047   {
2048   ss = expand_string(s);
2049   if (ss == NULL)
2050     {
2051     if (expand_string_forcedfail) return OK;
2052     *log_msgptr = string_sprintf("failed to expand ACL string \"%s\": %s", s,
2053       expand_string_message);
2054     return ERROR;
2055     }
2056   }
2057 else ss = s;
2058
2059 while (isspace(*ss))ss++;
2060
2061 /* If we can't find a named ACL, the default is to parse it as an inline one.
2062 (Unless it begins with a slash; non-existent files give rise to an error.) */
2063
2064 acl_text = ss;
2065
2066 /* Handle the case of a string that does not contain any spaces. Look for a
2067 named ACL among those read from the configuration, or a previously read file.
2068 It is possible that the pointer to the ACL is NULL if the configuration
2069 contains a name with no data. If not found, and the text begins with '/',
2070 read an ACL from a file, and save it so it can be re-used. */
2071
2072 if (Ustrchr(ss, ' ') == NULL)
2073   {
2074   tree_node *t = tree_search(acl_anchor, ss);
2075   if (t != NULL)
2076     {
2077     acl = (acl_block *)(t->data.ptr);
2078     if (acl == NULL)
2079       {
2080       HDEBUG(D_acl) debug_printf("ACL \"%s\" is empty: implicit DENY\n", ss);
2081       return FAIL;
2082       }
2083     acl_name = string_sprintf("ACL \"%s\"", ss);
2084     HDEBUG(D_acl) debug_printf("using ACL \"%s\"\n", ss);
2085     }
2086
2087   else if (*ss == '/')
2088     {
2089     struct stat statbuf;
2090     fd = Uopen(ss, O_RDONLY, 0);
2091     if (fd < 0)
2092       {
2093       *log_msgptr = string_sprintf("failed to open ACL file \"%s\": %s", ss,
2094         strerror(errno));
2095       return ERROR;
2096       }
2097
2098     if (fstat(fd, &statbuf) != 0)
2099       {
2100       *log_msgptr = string_sprintf("failed to fstat ACL file \"%s\": %s", ss,
2101         strerror(errno));
2102       return ERROR;
2103       }
2104
2105     acl_text = store_get(statbuf.st_size + 1);
2106     acl_text_end = acl_text + statbuf.st_size + 1;
2107
2108     if (read(fd, acl_text, statbuf.st_size) != statbuf.st_size)
2109       {
2110       *log_msgptr = string_sprintf("failed to read ACL file \"%s\": %s",
2111         ss, strerror(errno));
2112       return ERROR;
2113       }
2114     acl_text[statbuf.st_size] = 0;
2115     close(fd);
2116
2117     acl_name = string_sprintf("ACL \"%s\"", ss);
2118     HDEBUG(D_acl) debug_printf("read ACL from file %s\n", ss);
2119     }
2120   }
2121
2122 /* Parse an ACL that is still in text form. If it came from a file, remember it
2123 in the ACL tree, having read it into the POOL_PERM store pool so that it
2124 persists between multiple messages. */
2125
2126 if (acl == NULL)
2127   {
2128   int old_pool = store_pool;
2129   if (fd >= 0) store_pool = POOL_PERM;
2130   acl = acl_read(acl_getline, log_msgptr);
2131   store_pool = old_pool;
2132   if (acl == NULL && *log_msgptr != NULL) return ERROR;
2133   if (fd >= 0)
2134     {
2135     tree_node *t = store_get_perm(sizeof(tree_node) + Ustrlen(ss));
2136     Ustrcpy(t->name, ss);
2137     t->data.ptr = acl;
2138     (void)tree_insertnode(&acl_anchor, t);
2139     }
2140   }
2141
2142 /* Now we have an ACL to use. It's possible it may be NULL. */
2143
2144 while (acl != NULL)
2145   {
2146   int cond;
2147   int basic_errno = 0;
2148   BOOL endpass_seen = FALSE;
2149
2150   *log_msgptr = *user_msgptr = NULL;
2151   acl_temp_details = FALSE;
2152
2153   if (where == ACL_WHERE_QUIT &&
2154       acl->verb != ACL_ACCEPT &&
2155       acl->verb != ACL_WARN)
2156     {
2157     *log_msgptr = string_sprintf("\"%s\" is not allowed in a QUIT ACL",
2158       verbs[acl->verb]);
2159     return ERROR;
2160     }
2161
2162   HDEBUG(D_acl) debug_printf("processing \"%s\"\n", verbs[acl->verb]);
2163
2164   /* Clear out any search error message from a previous check before testing
2165   this condition. */
2166
2167   search_error_message = NULL;
2168   cond = acl_check_condition(acl->verb, acl->condition, where, addr, level,
2169     &endpass_seen, user_msgptr, log_msgptr, &basic_errno);
2170
2171   /* Handle special returns: DEFER causes a return except on a WARN verb;
2172   ERROR always causes a return. */
2173
2174   switch (cond)
2175     {
2176     case DEFER:
2177     HDEBUG(D_acl) debug_printf("%s: condition test deferred\n", verbs[acl->verb]);
2178     if (basic_errno != ERRNO_CALLOUTDEFER)
2179       {
2180       if (search_error_message != NULL && *search_error_message != 0)
2181         *log_msgptr = search_error_message;
2182       if (smtp_return_error_details) acl_temp_details = TRUE;
2183       }
2184     else
2185       {
2186       acl_temp_details = TRUE;
2187       }
2188     if (acl->verb != ACL_WARN) return DEFER;
2189     break;
2190
2191     default:      /* Paranoia */
2192     case ERROR:
2193     HDEBUG(D_acl) debug_printf("%s: condition test error\n", verbs[acl->verb]);
2194     return ERROR;
2195
2196     case OK:
2197     HDEBUG(D_acl) debug_printf("%s: condition test succeeded\n",
2198       verbs[acl->verb]);
2199     break;
2200
2201     case FAIL:
2202     HDEBUG(D_acl) debug_printf("%s: condition test failed\n", verbs[acl->verb]);
2203     break;
2204
2205     /* DISCARD and DROP can happen only from a nested ACL condition, and
2206     DISCARD can happen only for an "accept" or "discard" verb. */
2207
2208     case DISCARD:
2209     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"discard\"\n",
2210       verbs[acl->verb]);
2211     break;
2212
2213     case FAIL_DROP:
2214     HDEBUG(D_acl) debug_printf("%s: condition test yielded \"drop\"\n",
2215       verbs[acl->verb]);
2216     break;
2217     }
2218
2219   /* At this point, cond for most verbs is either OK or FAIL or (as a result of
2220   a nested ACL condition) FAIL_DROP. However, for WARN, cond may be DEFER, and
2221   for ACCEPT and DISCARD, it may be DISCARD after a nested ACL call. */
2222
2223   switch(acl->verb)
2224     {
2225     case ACL_ACCEPT:
2226     if (cond == OK || cond == DISCARD) return cond;
2227     if (endpass_seen)
2228       {
2229       HDEBUG(D_acl) debug_printf("accept: endpass encountered - denying access\n");
2230       return cond;
2231       }
2232     break;
2233
2234     case ACL_DEFER:
2235     if (cond == OK)
2236       {
2237       acl_temp_details = TRUE;
2238       return DEFER;
2239       }
2240     break;
2241
2242     case ACL_DENY:
2243     if (cond == OK) return FAIL;
2244     break;
2245
2246     case ACL_DISCARD:
2247     if (cond == OK || cond == DISCARD) return DISCARD;
2248     if (endpass_seen)
2249       {
2250       HDEBUG(D_acl) debug_printf("discard: endpass encountered - denying access\n");
2251       return cond;
2252       }
2253     break;
2254
2255     case ACL_DROP:
2256     if (cond == OK) return FAIL_DROP;
2257     break;
2258
2259     case ACL_REQUIRE:
2260     if (cond != OK) return cond;
2261     break;
2262
2263     case ACL_WARN:
2264     if (cond == OK)
2265       acl_warn(where, *user_msgptr, *log_msgptr);
2266     else if (cond == DEFER)
2267       acl_warn(where, NULL, string_sprintf("ACL \"warn\" statement skipped: "
2268         "condition test deferred: %s",
2269         (*log_msgptr == NULL)? US"" : *log_msgptr));
2270     *log_msgptr = *user_msgptr = NULL;  /* In case implicit DENY follows */
2271     break;
2272
2273     default:
2274     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "internal ACL error: unknown verb %d",
2275       acl->verb);
2276     break;
2277     }
2278
2279   /* Pass to the next ACL item */
2280
2281   acl = acl->next;
2282   }
2283
2284 /* We have reached the end of the ACL. This is an implicit DENY. */
2285
2286 HDEBUG(D_acl) debug_printf("end of %s: implicit DENY\n", acl_name);
2287 return FAIL;
2288 }
2289
2290
2291 /*************************************************
2292 *        Check access using an ACL               *
2293 *************************************************/
2294
2295 /* This is the external interface for ACL checks. It sets up an address and the
2296 expansions for $domain and $local_part when called after RCPT, then calls
2297 acl_check_internal() to do the actual work.
2298
2299 Arguments:
2300   where        ACL_WHERE_xxxx indicating where called from
2301   data_string  RCPT address, or SMTP command argument, or NULL
2302   s            the input string; NULL is the same as an empty ACL => DENY
2303   user_msgptr  where to put a user error (for SMTP response)
2304   log_msgptr   where to put a logging message (not for SMTP response)
2305
2306 Returns:       OK         access is granted by an ACCEPT verb
2307                DISCARD    access is granted by a DISCARD verb
2308                FAIL       access is denied
2309                FAIL_DROP  access is denied; drop the connection
2310                DEFER      can't tell at the moment
2311                ERROR      disaster
2312 */
2313
2314 int
2315 acl_check(int where, uschar *data_string, uschar *s, uschar **user_msgptr,
2316   uschar **log_msgptr)
2317 {
2318 int rc;
2319 address_item adb;
2320 address_item *addr;
2321
2322 *user_msgptr = *log_msgptr = NULL;
2323 sender_verified_failed = NULL;
2324
2325 if (where == ACL_WHERE_RCPT)
2326   {
2327   adb = address_defaults;
2328   addr = &adb;
2329   addr->address = data_string;
2330   if (deliver_split_address(addr) == DEFER)
2331     {
2332     *log_msgptr = US"defer in percent_hack_domains check";
2333     return DEFER;
2334     }
2335   deliver_domain = addr->domain;
2336   deliver_localpart = addr->local_part;
2337   }
2338 else
2339   {
2340   addr = NULL;
2341   smtp_command_argument = data_string;
2342   }
2343
2344 rc = acl_check_internal(where, addr, s, 0, user_msgptr, log_msgptr);
2345
2346 smtp_command_argument = deliver_domain =
2347   deliver_localpart = deliver_address_data = sender_address_data = NULL;
2348
2349 /* A DISCARD response is permitted only for message ACLs, excluding the PREDATA
2350 ACL, which is really in the middle of an SMTP command. */
2351
2352 if (rc == DISCARD)
2353   {
2354   if (where > ACL_WHERE_NOTSMTP || where == ACL_WHERE_PREDATA)
2355     {
2356     log_write(0, LOG_MAIN|LOG_PANIC, "\"discard\" verb not allowed in %s "
2357       "ACL", acl_wherenames[where]);
2358     return ERROR;
2359     }
2360   return DISCARD;
2361   }
2362
2363 /* A DROP response is not permitted from MAILAUTH */
2364
2365 if (rc == FAIL_DROP && where == ACL_WHERE_MAILAUTH)
2366   {
2367   log_write(0, LOG_MAIN|LOG_PANIC, "\"drop\" verb not allowed in %s "
2368     "ACL", acl_wherenames[where]);
2369   return ERROR;
2370   }
2371
2372 /* Before giving an error response, take a look at the length of any user
2373 message, and split it up into multiple lines if possible. */
2374
2375 if (rc != OK && *user_msgptr != NULL && Ustrlen(*user_msgptr) > 75)
2376   {
2377   uschar *s = *user_msgptr = string_copy(*user_msgptr);
2378   uschar *ss = s;
2379
2380   for (;;)
2381     {
2382     int i = 0;
2383     while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
2384     if (*ss == 0) break;
2385     if (*ss == '\n')
2386       s = ++ss;
2387     else
2388       {
2389       uschar *t = ss + 1;
2390       uschar *tt = NULL;
2391       while (--t > s + 35)
2392         {
2393         if (*t == ' ')
2394           {
2395           if (t[-1] == ':') { tt = t; break; }
2396           if (tt == NULL) tt = t;
2397           }
2398         }
2399
2400       if (tt == NULL)          /* Can't split behind - try ahead */
2401         {
2402         t = ss + 1;
2403         while (*t != 0)
2404           {
2405           if (*t == ' ' || *t == '\n')
2406             { tt = t; break; }
2407           t++;
2408           }
2409         }
2410
2411       if (tt == NULL) break;   /* Can't find anywhere to split */
2412       *tt = '\n';
2413       s = ss = tt+1;
2414       }
2415     }
2416   }
2417
2418 return rc;
2419 }
2420
2421 /* End of acl.c */