8b43613ce9a477fbc0a40a6a701da151258695f3
[exim.git] / src / src / route.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions concerned with routing, and the list of generic router options. */
9
10
11 #include "exim.h"
12
13
14
15 /* Generic options for routers, all of which live inside router_instance
16 data blocks and which therefore have the opt_public flag set. */
17 #define LOFF(field) OPT_OFF(router_instance, field)
18
19 optionlist optionlist_routers[] = {
20   { "*expand_group",      opt_stringptr | opt_hidden | opt_public,
21                  LOFF(expand_gid) },
22   { "*expand_more",       opt_stringptr | opt_hidden | opt_public,
23                  LOFF(expand_more) },
24   { "*expand_unseen",     opt_stringptr | opt_hidden | opt_public,
25                  LOFF(expand_unseen) },
26   { "*expand_user",       opt_stringptr | opt_hidden | opt_public,
27                  LOFF(expand_uid) },
28   { "*set_group",         opt_bool | opt_hidden | opt_public,
29                  LOFF(gid_set) },
30   { "*set_user",          opt_bool | opt_hidden | opt_public,
31                  LOFF(uid_set) },
32   { "address_data",       opt_stringptr|opt_public,
33                  LOFF(address_data) },
34   { "address_test",       opt_bool|opt_public,
35                  LOFF(address_test) },
36 #ifdef EXPERIMENTAL_BRIGHTMAIL
37   { "bmi_deliver_alternate",   opt_bool | opt_public,
38                  LOFF(bmi_deliver_alternate) },
39   { "bmi_deliver_default",   opt_bool | opt_public,
40                  LOFF(bmi_deliver_default) },
41   { "bmi_dont_deliver",   opt_bool | opt_public,
42                  LOFF(bmi_dont_deliver) },
43   { "bmi_rule",           opt_stringptr|opt_public,
44                  LOFF(bmi_rule) },
45 #endif
46   { "cannot_route_message", opt_stringptr | opt_public,
47                  LOFF(cannot_route_message) },
48   { "caseful_local_part", opt_bool | opt_public,
49                  LOFF(caseful_local_part) },
50   { "check_local_user",   opt_bool | opt_public,
51                  LOFF(check_local_user) },
52   { "condition",          opt_stringptr|opt_public|opt_rep_con,
53                  LOFF(condition) },
54   { "debug_print",        opt_stringptr | opt_public,
55                  LOFF(debug_string) },
56   { "disable_logging",    opt_bool | opt_public,
57                  LOFF(disable_logging) },
58   { "dnssec_request_domains",            opt_stringptr|opt_public,
59                  LOFF(dnssec.request) },
60   { "dnssec_require_domains",            opt_stringptr|opt_public,
61                  LOFF(dnssec.require) },
62   { "domains",            opt_stringptr|opt_public,
63                  LOFF(domains) },
64   { "driver",             opt_stringptr|opt_public,
65                  LOFF(driver_name) },
66   { "dsn_lasthop",        opt_bool|opt_public,
67                  LOFF(dsn_lasthop) },
68   { "errors_to",          opt_stringptr|opt_public,
69                  LOFF(errors_to) },
70   { "expn",               opt_bool|opt_public,
71                  LOFF(expn) },
72   { "fail_verify",        opt_bool_verify|opt_hidden|opt_public,
73                  LOFF(fail_verify_sender) },
74   { "fail_verify_recipient", opt_bool|opt_public,
75                  LOFF(fail_verify_recipient) },
76   { "fail_verify_sender", opt_bool|opt_public,
77                  LOFF(fail_verify_sender) },
78   { "fallback_hosts",     opt_stringptr|opt_public,
79                  LOFF(fallback_hosts) },
80   { "group",              opt_expand_gid | opt_public,
81                  LOFF(gid) },
82   { "headers_add",        opt_stringptr|opt_public|opt_rep_str,
83                  LOFF(extra_headers) },
84   { "headers_remove",     opt_stringptr|opt_public|opt_rep_str,
85                  LOFF(remove_headers) },
86   { "ignore_target_hosts",opt_stringptr|opt_public,
87                  LOFF(ignore_target_hosts) },
88   { "initgroups",         opt_bool | opt_public,
89                  LOFF(initgroups) },
90   { "local_part_prefix",  opt_stringptr|opt_public,
91                  LOFF(prefix) },
92   { "local_part_prefix_optional",opt_bool|opt_public,
93                  LOFF(prefix_optional) },
94   { "local_part_suffix",  opt_stringptr|opt_public,
95                  LOFF(suffix) },
96   { "local_part_suffix_optional",opt_bool|opt_public,
97                  LOFF(suffix_optional) },
98   { "local_parts",        opt_stringptr|opt_public,
99                  LOFF(local_parts) },
100   { "log_as_local",       opt_bool|opt_public,
101                  LOFF(log_as_local) },
102   { "more",               opt_expand_bool|opt_public,
103                  LOFF(more) },
104   { "pass_on_timeout",    opt_bool|opt_public,
105                  LOFF(pass_on_timeout) },
106   { "pass_router",       opt_stringptr|opt_public,
107                  LOFF(pass_router_name) },
108   { "redirect_router",    opt_stringptr|opt_public,
109                  LOFF(redirect_router_name) },
110   { "require_files",      opt_stringptr|opt_public,
111                  LOFF(require_files) },
112   { "retry_use_local_part", opt_bool|opt_public,
113                  LOFF(retry_use_local_part) },
114   { "router_home_directory", opt_stringptr|opt_public,
115                  LOFF(router_home_directory) },
116   { "self",               opt_stringptr|opt_public,
117                  LOFF(self) },
118   { "senders",            opt_stringptr|opt_public,
119                  LOFF(senders) },
120   { "set",                opt_stringptr|opt_public|opt_rep_str,
121                  LOFF(set) },
122   #ifdef SUPPORT_TRANSLATE_IP_ADDRESS
123   { "translate_ip_address", opt_stringptr|opt_public,
124                  LOFF(translate_ip_address) },
125   #endif
126   { "transport",          opt_stringptr|opt_public,
127                  LOFF(transport_name) },
128   { "transport_current_directory", opt_stringptr|opt_public,
129                  LOFF(current_directory) },
130   { "transport_home_directory", opt_stringptr|opt_public,
131                  LOFF(home_directory) },
132   { "unseen",             opt_expand_bool|opt_public,
133                  LOFF(unseen) },
134   { "user",               opt_expand_uid | opt_public,
135                  LOFF(uid) },
136   { "verify",             opt_bool_verify|opt_hidden|opt_public,
137                  LOFF(verify_sender) },
138   { "verify_only",        opt_bool|opt_public,
139                  LOFF(verify_only) },
140   { "verify_recipient",   opt_bool|opt_public,
141                  LOFF(verify_recipient) },
142   { "verify_sender",      opt_bool|opt_public,
143                  LOFF(verify_sender) }
144 };
145
146 int optionlist_routers_size = nelem(optionlist_routers);
147
148
149 #ifdef MACRO_PREDEF
150
151 # include "macro_predef.h"
152
153 void
154 options_routers(void)
155 {
156 uschar buf[64];
157
158 options_from_list(optionlist_routers, nelem(optionlist_routers), US"ROUTERS", NULL);
159
160 for (router_info * ri = routers_available; ri->driver_name[0]; ri++)
161   {
162   spf(buf, sizeof(buf), US"_DRIVER_ROUTER_%T", ri->driver_name);
163   builtin_macro_create(buf);
164   options_from_list(ri->options, (unsigned)*ri->options_count, US"ROUTER", ri->driver_name);
165   }
166 }
167
168 #else   /*!MACRO_PREDEF*/
169
170 /*************************************************
171 *          Set router pointer from name          *
172 *************************************************/
173
174 /* This function is used for the redirect_router and pass_router options and
175 called from route_init() below.
176
177 Arguments:
178   r           the current router
179   name        new router name
180   ptr         where to put the pointer
181   after       TRUE if router must follow this one
182
183 Returns:      nothing.
184 */
185
186 static void
187 set_router(router_instance *r, uschar *name, router_instance **ptr, BOOL after)
188 {
189 BOOL afterthis = FALSE;
190 router_instance *rr;
191
192 for (rr = routers; rr; rr = rr->next)
193   {
194   if (Ustrcmp(name, rr->name) == 0)
195     {
196     *ptr = rr;
197     break;
198     }
199   if (rr == r) afterthis = TRUE;
200   }
201
202 if (!rr)
203   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
204     "new_router \"%s\" not found for \"%s\" router", name, r->name);
205
206 if (after && !afterthis)
207   log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
208     "new_router \"%s\" does not follow \"%s\" router", name, r->name);
209 }
210
211
212
213 /*************************************************
214 *             Initialize router list             *
215 *************************************************/
216
217 /* Read the routers section of the configuration file, and set up a chain of
218 router instances according to its contents. Each router has generic options and
219 may also have its own private options. This function is only ever called when
220 routers == NULL. We use generic code in readconf to do the work. It will set
221 values from the configuration file, and then call the driver's initialization
222 function. */
223
224 void
225 route_init(void)
226 {
227 readconf_driver_init(US"router",
228   (driver_instance **)(&routers),     /* chain anchor */
229   (driver_info *)routers_available,   /* available drivers */
230   sizeof(router_info),                /* size of info blocks */
231   &router_defaults,                   /* default values for generic options */
232   sizeof(router_instance),            /* size of instance block */
233   optionlist_routers,                 /* generic options */
234   optionlist_routers_size);
235
236 for (router_instance * r = routers; r; r = r->next)
237   {
238   uschar *s = r->self;
239
240   /* If log_as_local is unset, its overall default is FALSE. (The accept
241   router defaults it to TRUE.) */
242
243   if (r->log_as_local == TRUE_UNSET) r->log_as_local = FALSE;
244
245   /* Check for transport or no transport on certain routers */
246
247   if (  (r->info->ri_flags & ri_yestransport)
248      && !r->transport_name && !r->verify_only)
249     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "%s router:\n  "
250       "a transport is required for this router", r->name);
251
252   if ((r->info->ri_flags & ri_notransport) && r->transport_name)
253     log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "%s router:\n  "
254       "a transport must not be defined for this router", r->name);
255
256   /* The "self" option needs to be decoded into a code value and possibly a
257   new domain string and a rewrite boolean. */
258
259   if      (Ustrcmp(s, "freeze") == 0)    r->self_code = self_freeze;
260   else if (Ustrcmp(s, "defer") == 0)     r->self_code = self_defer;
261   else if (Ustrcmp(s, "send") == 0)      r->self_code = self_send;
262   else if (Ustrcmp(s, "pass") == 0)      r->self_code = self_pass;
263   else if (Ustrcmp(s, "fail") == 0)      r->self_code = self_fail;
264   else if (Ustrncmp(s, "reroute:", 8) == 0)
265     {
266     s += 8;
267     while (isspace(*s)) s++;
268     if (Ustrncmp(s, "rewrite:", 8) == 0)
269       {
270       r->self_rewrite = TRUE;
271       s += 8;
272       while (isspace(*s)) s++;
273       }
274     r->self = s;
275     r->self_code = self_reroute;
276     }
277
278   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
279       "%s is not valid for the self option", r->name, s);
280
281   /* If any router has check_local_user set, default retry_use_local_part
282   TRUE; otherwise its default is FALSE. */
283
284   if (r->retry_use_local_part == TRUE_UNSET)
285     r->retry_use_local_part =
286       r->check_local_user || r->local_parts || r->condition || r->prefix || r->suffix || r->senders || r->require_files;
287
288   /* Build a host list if fallback hosts is set. */
289
290   host_build_hostlist(&(r->fallback_hostlist), r->fallback_hosts, FALSE);
291
292   /* Check redirect_router and pass_router are valid */
293
294   if (r->redirect_router_name)
295     set_router(r, r->redirect_router_name, &(r->redirect_router), FALSE);
296
297   if (r->pass_router_name)
298     set_router(r, r->pass_router_name, &(r->pass_router), TRUE);
299
300 #ifdef notdef
301   DEBUG(D_route) debug_printf("DSN: %s %s\n", r->name,
302         r->dsn_lasthop ? "lasthop set" : "propagating DSN");
303 #endif
304   }
305 }
306
307
308
309 /*************************************************
310 *             Tidy up after routing              *
311 *************************************************/
312
313 /* Routers are entitled to keep hold of certain resources in their instance
314 blocks so as to save setting them up each time. An example is an open file.
315 Such routers must provide a tidyup entry point which is called when all routing
316 is finished, via this function. */
317
318 void
319 route_tidyup(void)
320 {
321 for (router_instance * r = routers; r; r = r->next)
322   if (r->info->tidyup) (r->info->tidyup)(r);
323 }
324
325
326
327 /*************************************************
328 *         Check local part for prefix            *
329 *************************************************/
330
331 /* This function is handed a local part and a list of possible prefixes; if any
332 one matches, return the prefix length. A prefix beginning with '*' is a
333 wildcard.
334
335 Arguments:
336   local_part    the local part to check
337   prefixes      the list of prefixes
338   vp            if set, pointer to place for size of wildcard portion
339
340 Returns:        length of matching prefix or zero
341 */
342
343 int
344 route_check_prefix(const uschar * local_part, const uschar * prefixes,
345   unsigned * vp)
346 {
347 int sep = 0;
348 uschar *prefix;
349 const uschar *listptr = prefixes;
350
351 while ((prefix = string_nextinlist(&listptr, &sep, NULL, 0)))
352   {
353   int plen = Ustrlen(prefix);
354   if (prefix[0] == '*')
355     {
356     prefix++;
357     for (const uschar * p = local_part + Ustrlen(local_part) - (--plen);
358          p >= local_part; p--)
359       if (strncmpic(prefix, p, plen) == 0)
360         {
361         unsigned vlen = p - local_part;
362         if (vp) *vp = vlen;
363         return plen + vlen;
364         }
365     }
366   else
367     if (strncmpic(prefix, local_part, plen) == 0)
368       {
369       if (vp) *vp = 0;
370       return plen;
371       }
372   }
373
374 return 0;
375 }
376
377
378
379 /*************************************************
380 *         Check local part for suffix            *
381 *************************************************/
382
383 /* This function is handed a local part and a list of possible suffixes;
384 if any one matches, return the suffix length. A suffix ending with '*'
385 is a wildcard.
386
387 Arguments:
388   local_part    the local part to check
389   suffixes      the list of suffixes
390   vp            if set, pointer to place for size of wildcard portion
391
392 Returns:        length of matching suffix or zero
393 */
394
395 int
396 route_check_suffix(const uschar * local_part, const uschar * suffixes,
397   unsigned * vp)
398 {
399 int sep = 0;
400 int alen = Ustrlen(local_part);
401 uschar *suffix;
402 const uschar *listptr = suffixes;
403
404 while ((suffix = string_nextinlist(&listptr, &sep, NULL, 0)))
405   {
406   int slen = Ustrlen(suffix);
407   if (suffix[slen-1] == '*')
408     {
409     const uschar * pend = local_part + alen - (--slen) + 1;
410     for (const uschar * p = local_part; p < pend; p++)
411       if (strncmpic(suffix, p, slen) == 0)
412         {
413         int tlen = alen - (p - local_part);
414         if (vp) *vp = tlen - slen;
415         return tlen;
416         }
417     }
418   else
419     if (alen > slen && strncmpic(suffix, local_part + alen - slen, slen) == 0)
420       {
421       if (vp) *vp = 0;
422       return slen;
423       }
424   }
425
426 return 0;
427 }
428
429
430
431
432 /*************************************************
433 *     Check local part, domain, or sender        *
434 *************************************************/
435
436 /* The checks in check_router_conditions() require similar code, so we use
437 this function to save repetition.
438
439 Arguments:
440   rname          router name for error messages
441   type           type of check, for error message
442   list           domains, local_parts, or senders list
443   anchorptr      -> tree for possibly cached items (domains)
444   cache_bits     cached bits pointer
445   listtype       MCL_DOMAIN for domain check
446                  MCL_LOCALPART for local part check
447                  MCL_ADDRESS for sender check
448   domloc         current domain, current local part, or NULL for sender check
449   ldata          where to put lookup data
450   caseless       passed on to match_isinlist()
451   perror         where to put an error message
452
453 Returns:         OK     item is in list
454                  SKIP   item is not in list, router is to be skipped
455                  DEFER  lookup or other defer
456 */
457
458 static int
459 route_check_dls(uschar *rname, uschar *type, const uschar *list,
460   tree_node **anchorptr, unsigned int *cache_bits, int listtype,
461   const uschar *domloc, const uschar **ldata, BOOL caseless, uschar **perror)
462 {
463 if (!list) return OK;   /* Empty list always succeeds */
464
465 DEBUG(D_route) debug_printf("checking %s\n", type);
466
467 /* The domain and local part use the same matching function, whereas sender
468 has its own code. */
469
470 switch(domloc
471   ? match_isinlist(domloc, &list, 0, anchorptr, cache_bits, listtype,
472     caseless, ldata)
473   : match_address_list(sender_address ? sender_address : US"",
474     TRUE, TRUE, &list, cache_bits, -1, 0, CUSS &sender_data)
475       )
476   {
477   case OK:
478     return OK;
479
480   case FAIL:
481     *perror = string_sprintf("%s router skipped: %s mismatch", rname, type);
482     DEBUG(D_route) debug_printf("%s\n", *perror);
483     return SKIP;
484
485   default:      /* Paranoia, and keeps compilers happy */
486   case DEFER:
487     *perror = string_sprintf("%s check lookup or other defer", type);
488     DEBUG(D_route) debug_printf("%s\n", *perror);
489     return DEFER;
490   }
491 }
492
493
494
495 /*************************************************
496 *        Check access by a given uid/gid         *
497 *************************************************/
498
499 /* This function checks whether a given uid/gid has access to a given file or
500 directory. It is called only from check_files() below. This is hopefully a
501 cheapish check that does the job most of the time. Exim does *not* rely on this
502 test when actually accessing any file. The test is used when routing to make it
503 possible to take actions such as "if user x can access file y then run this
504 router".
505
506 During routing, Exim is normally running as root, and so the test will work
507 except for NFS non-root mounts. When verifying during message reception, Exim
508 is running as "exim", so the test may not work. This is a limitation of the
509 Exim design.
510
511 Code in check_files() below detects the case when it cannot stat() the file (as
512 root), and in that situation it uses a setuid subprocess in which to run this
513 test.
514
515 Arguments:
516   path          the path to check
517   uid           the user
518   gid           the group
519   bits          the bits required in the final component
520
521 Returns:        TRUE
522                 FALSE errno=EACCES or ENOENT (or others from realpath or stat)
523 */
524
525 static BOOL
526 route_check_access(uschar *path, uid_t uid, gid_t gid, int bits)
527 {
528 struct stat statbuf;
529 uschar *slash;
530 uschar *rp = US realpath(CS path, CS big_buffer);
531 uschar *sp = rp + 1;
532
533 DEBUG(D_route) debug_printf("route_check_access(%s,%d,%d,%o)\n", path,
534   (int)uid, (int)gid, bits);
535
536 if (!rp) return FALSE;
537
538 while ((slash = Ustrchr(sp, '/')))
539   {
540   *slash = 0;
541   DEBUG(D_route) debug_printf("stat %s\n", rp);
542   if (Ustat(rp, &statbuf) < 0) return FALSE;
543   if ((statbuf.st_mode &
544        ((statbuf.st_uid == uid)? 0100 : (statbuf.st_gid == gid)? 0010 : 001)
545       ) == 0)
546     {
547     errno = EACCES;
548     return FALSE;
549     }
550   *slash = '/';
551   sp = slash + 1;
552   }
553
554 /* Down to the final component */
555
556 DEBUG(D_route) debug_printf("stat %s\n", rp);
557
558 if (Ustat(rp, &statbuf) < 0) return FALSE;
559
560 if (statbuf.st_uid == uid) bits = bits << 6;
561   else if (statbuf.st_gid == gid) bits = bits << 3;
562 if ((statbuf.st_mode & bits) != bits)
563   {
564   errno = EACCES;
565   return FALSE;
566   }
567
568 DEBUG(D_route) debug_printf("route_check_access() succeeded\n");
569 return TRUE;
570 }
571
572
573
574 /*************************************************
575 *           Do file existence tests              *
576 *************************************************/
577
578 /* This function is given a colon-separated list of file tests, each of which
579 is expanded before use. A test consists of a file name, optionally preceded by
580 ! (require non-existence) and/or + for handling permission denied (+ means
581 treat as non-existing).
582
583 An item that contains no slashes is interpreted as a username or id, with an
584 optional group id, for checking access to the file. This cannot be done
585 "perfectly", but it is good enough for a number of applications.
586
587 Arguments:
588   s        a colon-separated list of file tests or NULL
589   perror   a pointer to an anchor for an error text in the case of a DEFER
590
591 Returns:   OK if s == NULL or all tests are as required
592            DEFER if the existence of at least one of the files is
593              unclear (an error other than non-existence occurred);
594            DEFER if an expansion failed
595            DEFER if a name is not absolute
596            DEFER if problems with user/group
597            SKIP otherwise
598 */
599
600 static int
601 check_files(const uschar *s, uschar **perror)
602 {
603 int sep = 0;              /* List has default separators */
604 uid_t uid = 0;            /* For picky compilers */
605 gid_t gid = 0;            /* For picky compilers */
606 BOOL ugid_set = FALSE;
607 const uschar *listptr;
608 uschar *check;
609 uschar buffer[1024];
610
611 if (!s) return OK;
612
613 DEBUG(D_route) debug_printf("checking require_files\n");
614
615 listptr = s;
616 while ((check = string_nextinlist(&listptr, &sep, buffer, sizeof(buffer))))
617   {
618   int rc;
619   int eacces_code = 0;
620   BOOL invert = FALSE;
621   struct stat statbuf;
622   uschar *ss = expand_string(check);
623
624   if (!ss)
625     {
626     if (f.expand_string_forcedfail) continue;
627     *perror = string_sprintf("failed to expand \"%s\" for require_files: %s",
628       check, expand_string_message);
629     goto RETURN_DEFER;
630     }
631
632   /* Empty items are just skipped */
633
634   if (*ss == 0) continue;
635
636   /* If there are no slashes in the string, we have a user name or uid, with
637   optional group/gid. */
638
639   if (Ustrchr(ss, '/') == NULL)
640     {
641     BOOL ok;
642     struct passwd *pw;
643     uschar *comma = Ustrchr(ss, ',');
644
645     /* If there's a comma, temporarily terminate the user name/number
646     at that point. Then set the uid. */
647
648     if (comma != NULL) *comma = 0;
649     ok = route_finduser(ss, &pw, &uid);
650     if (comma != NULL) *comma = ',';
651
652     if (!ok)
653       {
654       *perror = string_sprintf("user \"%s\" for require_files not found", ss);
655       goto RETURN_DEFER;
656       }
657
658     /* If there was no comma, the gid is that associated with the user. */
659
660     if (comma == NULL)
661       {
662       if (pw != NULL) gid = pw->pw_gid; else
663         {
664         *perror = string_sprintf("group missing after numerical uid %d for "
665           "require_files", (int)uid);
666         goto RETURN_DEFER;
667         }
668       }
669     else
670       {
671       if (!route_findgroup(comma + 1, &gid))
672         {
673         *perror = string_sprintf("group \"%s\" for require_files not found\n",
674           comma + 1);
675         goto RETURN_DEFER;
676         }
677       }
678
679     /* Note that we have values set, and proceed to next item */
680
681     DEBUG(D_route)
682       debug_printf("check subsequent files for access by %s\n", ss);
683     ugid_set = TRUE;
684     continue;
685     }
686
687   /* Path, possibly preceded by + and ! */
688
689   if (*ss == '+')
690     {
691     eacces_code = 1;
692     while (isspace((*(++ss))));
693     }
694
695   if (*ss == '!')
696     {
697     invert = TRUE;
698     while (isspace((*(++ss))));
699     }
700
701   if (*ss != '/')
702     {
703     *perror = string_sprintf("require_files: \"%s\" is not absolute", ss);
704     goto RETURN_DEFER;
705     }
706
707   /* Stat the file, either as root (while routing) or as exim (while verifying
708   during message reception). */
709
710   rc = Ustat(ss, &statbuf);
711
712   DEBUG(D_route)
713     {
714     debug_printf("file check: %s\n", check);
715     if (ss != check) debug_printf("expanded file: %s\n", ss);
716     debug_printf("stat() yielded %d\n", rc);
717     }
718
719   /* If permission is denied, and we are running as root (i.e. routing for
720   delivery rather than verifying), and the requirement is to test for access by
721   a particular uid/gid, it must mean that the file is on a non-root-mounted NFS
722   system. In this case, we have to use a subprocess that runs as the relevant
723   uid in order to do the test. */
724
725   if (rc != 0 && errno == EACCES && ugid_set && getuid() == root_uid)
726     {
727     int status;
728     pid_t pid;
729     void (*oldsignal)(int);
730
731     DEBUG(D_route) debug_printf("root is denied access: forking to check "
732       "in subprocess\n");
733
734     /* Before forking, ensure that SIGCHLD is set to SIG_DFL before forking, so
735     that the child process can be waited for, just in case get here with it set
736     otherwise. Save the old state for resetting on the wait. */
737
738     oldsignal = signal(SIGCHLD, SIG_DFL);
739     pid = fork();
740
741     /* If fork() fails, reinstate the original error and behave as if
742     this block of code were not present. This is the same behaviour as happens
743     when Exim is not running as root at this point. */
744
745     if (pid < 0)
746       {
747       DEBUG(D_route)
748        debug_printf("require_files: fork failed: %s\n", strerror(errno));
749       errno = EACCES;
750       goto HANDLE_ERROR;
751       }
752
753     /* In the child process, change uid and gid, and then do the check using
754     the route_check_access() function. This does more than just stat the file;
755     it tests permissions as well. Return 0 for OK and 1 for failure. */
756
757     if (pid == 0)
758       {
759       exim_setugid(uid, gid, TRUE,
760         string_sprintf("require_files check, file=%s", ss));
761       if (route_check_access(ss, uid, gid, 4))
762         exim_underbar_exit(0);
763       DEBUG(D_route) debug_printf("route_check_access() failed\n");
764       exim_underbar_exit(1);
765       }
766
767     /* In the parent, wait for the child to finish */
768
769     while (waitpid(pid, &status, 0) < 0)
770      if (errno != EINTR)  /* unexpected error, interpret as failure */
771        {
772        status = 1;
773        break;
774        }
775
776     signal(SIGCHLD, oldsignal);   /* restore */
777     if ((status == 0) == invert) return SKIP;
778     continue;   /* to test the next file */
779     }
780
781   /* Control reaches here if the initial stat() succeeds, or fails with an
782   error other than EACCES, or no uid/gid is set, or we are not running as root.
783   If we know the file exists and uid/gid are set, try to check read access for
784   that uid/gid as best we can. */
785
786   if (rc == 0 && ugid_set && !route_check_access(ss, uid, gid, 4))
787     {
788     DEBUG(D_route) debug_printf("route_check_access() failed\n");
789     rc = -1;
790     }
791
792   /* Handle error returns from stat() or route_check_access(). The EACCES error
793   is handled specially. At present, we can force it to be treated as
794   non-existence. Write the code so that it will be easy to add forcing for
795   existence if required later. */
796
797   HANDLE_ERROR:
798   if (rc < 0)
799     {
800     DEBUG(D_route) debug_printf("errno = %d\n", errno);
801     if (errno == EACCES)
802       {
803       if (eacces_code == 1)
804         {
805         DEBUG(D_route) debug_printf("EACCES => ENOENT\n");
806         errno = ENOENT;   /* Treat as non-existent */
807         }
808       }
809     if (errno != ENOENT)
810       {
811       *perror = string_sprintf("require_files: error for %s: %s", ss,
812         strerror(errno));
813       goto RETURN_DEFER;
814       }
815     }
816
817   /* At this point, rc < 0 => non-existence; rc >= 0 => existence */
818
819   if ((rc >= 0) == invert) return SKIP;
820   }
821
822 return OK;
823
824 /* Come here on any of the errors that return DEFER. */
825
826 RETURN_DEFER:
827 DEBUG(D_route) debug_printf("%s\n", *perror);
828 return DEFER;
829 }
830
831
832
833
834
835 /*************************************************
836 *             Check for router skipping          *
837 *************************************************/
838
839 /* This function performs various checks to see whether a router should be
840 skipped. The order in which they are performed is important.
841
842 Arguments:
843   r            pointer to router instance block
844   addr         address that is being handled
845   verify       the verification type
846   pw           ptr to ptr to passwd structure for local user
847   perror       for lookup errors
848
849 Returns:       OK if all the tests succeed
850                SKIP if router is to be skipped
851                DEFER for a lookup defer
852                FAIL for address to be failed
853 */
854
855 static BOOL
856 check_router_conditions(router_instance *r, address_item *addr, int verify,
857   struct passwd **pw, uschar **perror)
858 {
859 int rc;
860 uschar *check_local_part;
861 unsigned int *localpart_cache;
862
863 /* Reset variables to hold a home directory and data from lookup of a domain or
864 local part, and ensure search_find_defer is unset, in case there aren't any
865 actual lookups. */
866
867 deliver_home = NULL;
868 deliver_domain_data = NULL;
869 deliver_localpart_data = NULL;
870 sender_data = NULL;
871 local_user_gid = (gid_t)(-1);
872 local_user_uid = (uid_t)(-1);
873 f.search_find_defer = FALSE;
874
875 /* Skip this router if not verifying and it has verify_only set */
876
877 if ((verify == v_none || verify == v_expn) && r->verify_only)
878   {
879   DEBUG(D_route) debug_printf("%s router skipped: verify_only set\n", r->name);
880   return SKIP;
881   }
882
883 /* Skip this router if testing an address (-bt) and address_test is not set */
884
885 if (f.address_test_mode && !r->address_test)
886   {
887   DEBUG(D_route) debug_printf("%s router skipped: address_test is unset\n",
888     r->name);
889   return SKIP;
890   }
891
892 /* Skip this router if verifying and it hasn't got the appropriate verify flag
893 set. */
894
895 if ((verify == v_sender && !r->verify_sender) ||
896     (verify == v_recipient && !r->verify_recipient))
897   {
898   DEBUG(D_route) debug_printf("%s router skipped: verify %d %d %d\n",
899     r->name, verify, r->verify_sender, r->verify_recipient);
900   return SKIP;
901   }
902
903 /* Skip this router if processing EXPN and it doesn't have expn set */
904
905 if (verify == v_expn && !r->expn)
906   {
907   DEBUG(D_route) debug_printf("%s router skipped: no_expn set\n", r->name);
908   return SKIP;
909   }
910
911 /* Skip this router if there's a domain mismatch. */
912
913 if ((rc = route_check_dls(r->name, US"domains", r->domains, &domainlist_anchor,
914      addr->domain_cache, TRUE, addr->domain, CUSS &deliver_domain_data,
915      MCL_DOMAIN, perror)) != OK)
916   return rc;
917
918 /* Skip this router if there's a local part mismatch. We want to pass over the
919 caseful local part, so that +caseful can restore it, even if this router is
920 handling local parts caselessly. However, we can't just pass cc_local_part,
921 because that doesn't have the prefix or suffix stripped. A bit of massaging is
922 required. Also, we only use the match cache for local parts that have not had
923 a prefix or suffix stripped. */
924
925 if (!addr->prefix && !addr->suffix)
926   {
927   localpart_cache = addr->localpart_cache;
928   check_local_part = addr->cc_local_part;
929   }
930 else
931   {
932   localpart_cache = NULL;
933   check_local_part = string_copy(addr->cc_local_part);
934   if (addr->prefix)
935     check_local_part += Ustrlen(addr->prefix);
936   if (addr->suffix)
937     check_local_part[Ustrlen(check_local_part) - Ustrlen(addr->suffix)] = 0;
938   }
939
940 if ((rc = route_check_dls(r->name, US"local_parts", r->local_parts,
941        &localpartlist_anchor, localpart_cache, MCL_LOCALPART,
942        check_local_part, CUSS &deliver_localpart_data,
943        !r->caseful_local_part, perror)) != OK)
944   return rc;
945
946 /* If the check_local_user option is set, check that the local_part is the
947 login of a local user. Note: the third argument to route_finduser() must be
948 NULL here, to prevent a numeric string being taken as a numeric uid. If the
949 user is found, set deliver_home to the home directory, and also set
950 local_user_{uid,gid} and local_part_verified.  */
951
952 if (r->check_local_user)
953   {
954   DEBUG(D_route) debug_printf("checking for local user\n");
955   if (!route_finduser(addr->local_part, pw, NULL))
956     {
957     DEBUG(D_route) debug_printf("%s router skipped: %s is not a local user\n",
958       r->name, addr->local_part);
959     return SKIP;
960     }
961   deliver_localpart_verified = string_copy(US (*pw)->pw_name);
962   deliver_home = string_copy(US (*pw)->pw_dir);
963   local_user_gid = (*pw)->pw_gid;
964   local_user_uid = (*pw)->pw_uid;
965   }
966
967 /* Set (or override in the case of check_local_user) the home directory if
968 router_home_directory is set. This is done here so that it overrides $home from
969 check_local_user before any subsequent expansions are done. Otherwise, $home
970 could mean different things for different options, which would be extremely
971 confusing. */
972
973 if (r->router_home_directory)
974   {
975   uschar *router_home = expand_string(r->router_home_directory);
976   if (!router_home)
977     {
978     if (!f.expand_string_forcedfail)
979       {
980       *perror = string_sprintf("failed to expand \"%s\" for "
981         "router_home_directory: %s", r->router_home_directory,
982         expand_string_message);
983       return DEFER;
984       }
985     }
986   else
987     {
988     setflag(addr, af_home_expanded); /* Note set from router_home_directory */
989     deliver_home = router_home;
990     }
991   }
992
993 /* Skip if the sender condition is not met. We leave this one till after the
994 local user check so that $home is set - enabling the possibility of letting
995 individual recipients specify lists of acceptable/unacceptable senders. */
996
997 if ((rc = route_check_dls(r->name, US"senders", r->senders, NULL,
998      sender_address_cache, MCL_ADDRESS, NULL, NULL, FALSE, perror)) != OK)
999   return rc;
1000
1001 /* This is the point at which we print out the router's debugging string if it
1002 is set. We wait till here so as to have $home available for local users (and
1003 anyway, we don't want too much stuff for skipped routers). */
1004
1005 debug_print_string(r->debug_string);
1006
1007 /* Perform file existence tests. */
1008
1009 if ((rc = check_files(r->require_files, perror)) != OK)
1010   {
1011   DEBUG(D_route) debug_printf("%s router %s: file check\n", r->name,
1012     (rc == SKIP)? "skipped" : "deferred");
1013   return rc;
1014   }
1015
1016 /* Now the general condition test. */
1017
1018 if (r->condition)
1019   {
1020   DEBUG(D_route) debug_printf("checking \"condition\" \"%.80s\"...\n", r->condition);
1021   if (!expand_check_condition(r->condition, r->name, US"router"))
1022     {
1023     if (f.search_find_defer)
1024       {
1025       *perror = US"condition check lookup defer";
1026       DEBUG(D_route) debug_printf("%s\n", *perror);
1027       return DEFER;
1028       }
1029     DEBUG(D_route)
1030       debug_printf("%s router skipped: condition failure\n", r->name);
1031     return SKIP;
1032     }
1033   }
1034
1035 #ifdef EXPERIMENTAL_BRIGHTMAIL
1036 /* check if a specific Brightmail AntiSpam rule fired on the message */
1037 if (r->bmi_rule)
1038   {
1039   DEBUG(D_route) debug_printf("checking bmi_rule\n");
1040   if (bmi_check_rule(bmi_base64_verdict, r->bmi_rule) == 0)
1041     {    /* none of the rules fired */
1042     DEBUG(D_route)
1043       debug_printf("%s router skipped: none of bmi_rule rules fired\n", r->name);
1044     return SKIP;
1045     }
1046   }
1047
1048 /* check if message should not be delivered */
1049 if (r->bmi_dont_deliver && bmi_deliver == 1)
1050   {
1051   DEBUG(D_route)
1052     debug_printf("%s router skipped: bmi_dont_deliver is FALSE\n", r->name);
1053   return SKIP;
1054   }
1055
1056 /* check if message should go to an alternate location */
1057 if (  r->bmi_deliver_alternate
1058    && (bmi_deliver == 0 || !bmi_alt_location)
1059    )
1060   {
1061   DEBUG(D_route)
1062     debug_printf("%s router skipped: bmi_deliver_alternate is FALSE\n", r->name);
1063   return SKIP;
1064   }
1065
1066 /* check if message should go to default location */
1067 if (  r->bmi_deliver_default
1068    && (bmi_deliver == 0 || bmi_alt_location)
1069    )
1070   {
1071   DEBUG(D_route)
1072     debug_printf("%s router skipped: bmi_deliver_default is FALSE\n", r->name);
1073   return SKIP;
1074   }
1075 #endif
1076
1077 /* All the checks passed. */
1078
1079 return OK;
1080 }
1081
1082
1083
1084
1085 /*************************************************
1086 *           Find a local user                    *
1087 *************************************************/
1088
1089 /* Try several times (if configured) to find a local user, in case delays in
1090 NIS or NFS whatever cause an incorrect refusal. It's a pity that getpwnam()
1091 doesn't have some kind of indication as to why it has failed. If the string
1092 given consists entirely of digits, and the third argument is not NULL, assume
1093 the string is the numerical value of the uid. Otherwise it is looked up using
1094 getpwnam(). The uid is passed back via return_uid, if not NULL, and the
1095 pointer to a passwd structure, if found, is passed back via pw, if not NULL.
1096
1097 Because this may be called several times in succession for the same user for
1098 different routers, cache the result of the previous getpwnam call so that it
1099 can be re-used. Note that we can't just copy the structure, as the store it
1100 points to can get trashed.
1101
1102 Arguments:
1103   s           the login name or textual form of the numerical uid of the user
1104   pw          if not NULL, return the result of getpwnam here, or set NULL
1105                 if no call to getpwnam is made (s numeric, return_uid != NULL)
1106   return_uid  if not NULL, return the uid via this address
1107
1108 Returns:      TRUE if s is numerical or was looked up successfully
1109
1110 */
1111
1112 static struct passwd pwcopy;
1113 static struct passwd *lastpw = NULL;
1114 static uschar lastname[48] = { 0 };
1115 static uschar lastdir[128];
1116 static uschar lastgecos[128];
1117 static uschar lastshell[128];
1118
1119 BOOL
1120 route_finduser(const uschar *s, struct passwd **pw, uid_t *return_uid)
1121 {
1122 BOOL cache_set = (Ustrcmp(lastname, s) == 0);
1123
1124 DEBUG(D_uid) debug_printf("seeking password data for user \"%s\": %s\n", s,
1125   cache_set ? "using cached result" : "cache not available");
1126
1127 if (!cache_set)
1128   {
1129   int i = 0;
1130
1131   if (return_uid && (isdigit(*s) || *s == '-') &&
1132        s[Ustrspn(s+1, "0123456789")+1] == 0)
1133     {
1134     *return_uid = (uid_t)Uatoi(s);
1135     if (pw) *pw = NULL;
1136     return TRUE;
1137     }
1138
1139   string_format_nt(lastname, sizeof(lastname), "%s", s);
1140
1141   /* Force failure if string length is greater than given maximum */
1142
1143   if (max_username_length > 0 && Ustrlen(lastname) > max_username_length)
1144     {
1145     DEBUG(D_uid) debug_printf("forced failure of finduser(): string "
1146       "length of %s is greater than %d\n", lastname, max_username_length);
1147     lastpw = NULL;
1148     }
1149
1150   /* Try a few times if so configured; this handles delays in NIS etc. */
1151
1152   else for (;;)
1153     {
1154     errno = 0;
1155     if ((lastpw = getpwnam(CS s))) break;
1156     if (++i > finduser_retries) break;
1157     sleep(1);
1158     }
1159
1160   if (lastpw)
1161     {
1162     pwcopy.pw_uid = lastpw->pw_uid;
1163     pwcopy.pw_gid = lastpw->pw_gid;
1164     (void)string_format(lastdir, sizeof(lastdir), "%s", lastpw->pw_dir);
1165     (void)string_format(lastgecos, sizeof(lastgecos), "%s", lastpw->pw_gecos);
1166     (void)string_format(lastshell, sizeof(lastshell), "%s", lastpw->pw_shell);
1167     pwcopy.pw_name = CS lastname;
1168     pwcopy.pw_dir = CS lastdir;
1169     pwcopy.pw_gecos = CS lastgecos;
1170     pwcopy.pw_shell = CS lastshell;
1171     lastpw = &pwcopy;
1172     }
1173
1174   else DEBUG(D_uid) if (errno != 0)
1175     debug_printf("getpwnam(%s) failed: %s\n", s, strerror(errno));
1176   }
1177
1178 if (!lastpw)
1179   {
1180   DEBUG(D_uid) debug_printf("getpwnam() returned NULL (user not found)\n");
1181   return FALSE;
1182   }
1183
1184 DEBUG(D_uid) debug_printf("getpwnam() succeeded uid=%d gid=%d\n",
1185     lastpw->pw_uid, lastpw->pw_gid);
1186
1187 if (return_uid) *return_uid = lastpw->pw_uid;
1188 if (pw) *pw = lastpw;
1189
1190 return TRUE;
1191 }
1192
1193
1194
1195
1196 /*************************************************
1197 *           Find a local group                   *
1198 *************************************************/
1199
1200 /* Try several times (if configured) to find a local group, in case delays in
1201 NIS or NFS whatever cause an incorrect refusal. It's a pity that getgrnam()
1202 doesn't have some kind of indication as to why it has failed.
1203
1204 Arguments:
1205   s           the group name or textual form of the numerical gid
1206   return_gid  return the gid via this address
1207
1208 Returns:      TRUE if the group was found; FALSE otherwise
1209
1210 */
1211
1212 BOOL
1213 route_findgroup(uschar *s, gid_t *return_gid)
1214 {
1215 int i = 0;
1216 struct group *gr;
1217
1218 if ((isdigit(*s) || *s == '-') && s[Ustrspn(s+1, "0123456789")+1] == 0)
1219   {
1220   *return_gid = (gid_t)Uatoi(s);
1221   return TRUE;
1222   }
1223
1224 for (;;)
1225   {
1226   if ((gr = getgrnam(CS s)))
1227     {
1228     *return_gid = gr->gr_gid;
1229     return TRUE;
1230     }
1231   if (++i > finduser_retries) break;
1232   sleep(1);
1233   }
1234
1235 return FALSE;
1236 }
1237
1238
1239
1240
1241 /*************************************************
1242 *          Find user by expanding string         *
1243 *************************************************/
1244
1245 /* Expands a string, and then looks up the result in the passwd file.
1246
1247 Arguments:
1248   string       the string to be expanded, yielding a login name or a numerical
1249                  uid value (to be passed to route_finduser())
1250   driver_name  caller name for panic error message (only)
1251   driver_type  caller type for panic error message (only)
1252   pw           return passwd entry via this pointer
1253   uid          return uid via this pointer
1254   errmsg       where to point a message on failure
1255
1256 Returns:       TRUE if user found, FALSE otherwise
1257 */
1258
1259 BOOL
1260 route_find_expanded_user(uschar *string, uschar *driver_name,
1261   uschar *driver_type, struct passwd **pw, uid_t *uid, uschar **errmsg)
1262 {
1263 uschar *user = expand_string(string);
1264
1265 if (!user)
1266   {
1267   *errmsg = string_sprintf("Failed to expand user string \"%s\" for the "
1268     "%s %s: %s", string, driver_name, driver_type, expand_string_message);
1269   log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1270   return FALSE;
1271   }
1272
1273 if (route_finduser(user, pw, uid)) return TRUE;
1274
1275 *errmsg = string_sprintf("Failed to find user \"%s\" from expanded string "
1276   "\"%s\" for the %s %s", user, string, driver_name, driver_type);
1277 log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1278 return FALSE;
1279 }
1280
1281
1282
1283 /*************************************************
1284 *          Find group by expanding string        *
1285 *************************************************/
1286
1287 /* Expands a string and then looks up the result in the group file.
1288
1289 Arguments:
1290   string       the string to be expanded, yielding a group name or a numerical
1291                  gid value (to be passed to route_findgroup())
1292   driver_name  caller name for panic error message (only)
1293   driver_type  caller type for panic error message (only)
1294   gid          return gid via this pointer
1295   errmsg       return error message via this pointer
1296
1297 Returns:       TRUE if found group, FALSE otherwise
1298 */
1299
1300 BOOL
1301 route_find_expanded_group(uschar *string, uschar *driver_name, uschar *driver_type,
1302   gid_t *gid, uschar **errmsg)
1303 {
1304 BOOL yield = TRUE;
1305 uschar *group = expand_string(string);
1306
1307 if (!group)
1308   {
1309   *errmsg = string_sprintf("Failed to expand group string \"%s\" for the "
1310     "%s %s: %s", string, driver_name, driver_type, expand_string_message);
1311   log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1312   return FALSE;
1313   }
1314
1315 if (!route_findgroup(group, gid))
1316   {
1317   *errmsg = string_sprintf("Failed to find group \"%s\" from expanded string "
1318     "\"%s\" for the %s %s", group, string, driver_name, driver_type);
1319   log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1320   yield = FALSE;
1321   }
1322
1323 return yield;
1324 }
1325
1326
1327
1328 /*************************************************
1329 *            Handle an unseen routing            *
1330 *************************************************/
1331
1332 /* This function is called when an address is routed by a router with "unseen"
1333 set. It must make a clone of the address, for handling by subsequent drivers.
1334 The clone is set to start routing at the next router.
1335
1336 The original address must be replaced by an invented "parent" which has the
1337 routed address plus the clone as its children. This is necessary in case the
1338 address is at the top level - we don't want to mark it complete until both
1339 deliveries have been done.
1340
1341 A new unique field must be made, so that the record of the delivery isn't a
1342 record of the original address, and checking for already delivered has
1343 therefore to be done here. If the delivery has happened, then take the base
1344 address off whichever delivery queue it is on - it will always be the top item.
1345
1346 Arguments:
1347   name          router name
1348   addr          address that was routed
1349   paddr_local   chain of local-delivery addresses
1350   paddr_remote  chain of remote-delivery addresses
1351   addr_new      chain for newly created addresses
1352
1353 Returns:        nothing
1354 */
1355
1356 static void
1357 route_unseen(uschar *name, address_item *addr, address_item **paddr_local,
1358   address_item **paddr_remote, address_item **addr_new)
1359 {
1360 address_item *parent = deliver_make_addr(addr->address, TRUE);
1361 address_item *new = deliver_make_addr(addr->address, TRUE);
1362
1363 /* The invented parent is a copy that replaces the original; note that
1364 this copies its parent pointer. It has two children, and its errors_address is
1365 from the original address' parent, if present, otherwise unset. */
1366
1367 *parent = *addr;
1368 parent->child_count = 2;
1369 parent->prop.errors_address =
1370   addr->parent ? addr->parent->prop.errors_address : NULL;
1371
1372 /* The routed address gets a new parent. */
1373
1374 addr->parent = parent;
1375
1376 /* The clone has this parent too. Set its errors address from the parent. This
1377 was set from the original parent (or to NULL) - see above. We do NOT want to
1378 take the errors address from the unseen router. */
1379
1380 new->parent = parent;
1381 new->prop.errors_address = parent->prop.errors_address;
1382
1383 /* Copy the propagated flags and address_data from the original. */
1384
1385 new->prop.ignore_error = addr->prop.ignore_error;
1386 new->prop.address_data = addr->prop.address_data;
1387 new->prop.variables = NULL;
1388 tree_dup((tree_node **)&new->prop.variables, addr->prop.variables);
1389 new->dsn_flags = addr->dsn_flags;
1390 new->dsn_orcpt = addr->dsn_orcpt;
1391
1392
1393 /* As it has turned out, we haven't set headers_add or headers_remove for the
1394  * clone. Thinking about it, it isn't entirely clear whether they should be
1395  * copied from the original parent, like errors_address, or taken from the
1396  * unseen router, like address_data and the flags. Until somebody brings this
1397  * up, I propose to leave the code as it is.
1398  */
1399
1400
1401 /* Set the cloned address to start at the next router, and put it onto the
1402 chain of new addresses. */
1403
1404 new->start_router = addr->router->next;
1405 new->next = *addr_new;
1406 *addr_new = new;
1407
1408 DEBUG(D_route) debug_printf("\"unseen\" set: replicated %s\n", addr->address);
1409
1410 /* Make a new unique field, to distinguish from the normal one. */
1411
1412 addr->unique = string_sprintf("%s/%s", addr->unique, name);
1413
1414 /* If the address has been routed to a transport, see if it was previously
1415 delivered. If so, we take it off the relevant queue so that it isn't delivered
1416 again. Otherwise, it was an alias or something, and the addresses it generated
1417 are handled in the normal way. */
1418
1419 if (addr->transport && tree_search(tree_nonrecipients, addr->unique))
1420   {
1421   DEBUG(D_route)
1422     debug_printf("\"unseen\" delivery previously done - discarded\n");
1423   parent->child_count--;
1424   if (*paddr_remote == addr) *paddr_remote = addr->next;
1425   if (*paddr_local == addr) *paddr_local = addr->next;
1426   }
1427 }
1428
1429
1430
1431 /************************************************/
1432 /* Add router-assigned variables
1433 Return OK/DEFER/FAIL/PASS */
1434
1435 static int
1436 set_router_vars(address_item * addr, const router_instance * r)
1437 {
1438 const uschar * varlist = r->set;
1439 tree_node ** root = (tree_node **) &addr->prop.variables;
1440 int sep = ';';
1441
1442 if (!varlist) return OK;
1443
1444 /* Walk the varlist, creating variables */
1445
1446 for (uschar * ele; (ele = string_nextinlist(&varlist, &sep, NULL, 0)); )
1447   {
1448   const uschar * assignment = ele;
1449   int esep = '=';
1450   uschar * name = string_nextinlist(&assignment, &esep, NULL, 0);
1451   uschar * val;
1452   tree_node * node;
1453
1454   /* Variable name must exist and start "r_". */
1455
1456   if (!name || name[0] != 'r' || name[1] != '_' || !name[2])
1457     {
1458     log_write(0, LOG_MAIN|LOG_PANIC,
1459         "bad router variable name '%s' in router '%s'\n", name, r->name);
1460     return FAIL;
1461     }
1462   name += 2;
1463
1464   while (isspace(*assignment)) assignment++;
1465
1466   if (!(val = expand_string(US assignment)))
1467     if (f.expand_string_forcedfail)
1468       {
1469       int yield;
1470       BOOL more;
1471       DEBUG(D_route) debug_printf("forced failure in expansion of \"%s\" "
1472           "(router variable): decline action taken\n", ele);
1473
1474       /* Expand "more" if necessary; DEFER => an expansion failed */
1475
1476       yield = exp_bool(addr, US"router", r->name, D_route,
1477                       US"more", r->more, r->expand_more, &more);
1478       if (yield != OK) return yield;
1479
1480       if (!more)
1481         {
1482         DEBUG(D_route)
1483           debug_printf("\"more\"=false: skipping remaining routers\n");
1484         router_name = NULL;
1485         r = NULL;
1486         return FAIL;
1487         }
1488       return PASS;
1489       }
1490     else
1491       {
1492       addr->message = string_sprintf("expansion of \"%s\" failed "
1493         "in %s router: %s", ele, r->name, expand_string_message);
1494       return DEFER;
1495       }
1496
1497   if (!(node = tree_search(*root, name)))
1498     {                           /* name should never be tainted */
1499     node = store_get(sizeof(tree_node) + Ustrlen(name), FALSE);
1500     Ustrcpy(node->name, name);
1501     (void)tree_insertnode(root, node);
1502     }
1503   node->data.ptr = US val;
1504   DEBUG(D_route) debug_printf("set r_%s%s = '%s'%s\n",
1505                     name, is_tainted(name)?" (tainted)":"",
1506                     val, is_tainted(val)?" (tainted)":"");
1507
1508   /* All expansions after this point need visibility of that variable */
1509   router_var = *root;
1510   }
1511 return OK;
1512 }
1513
1514
1515 /*************************************************
1516 *                 Route one address              *
1517 *************************************************/
1518
1519 /* This function is passed in one address item, for processing by the routers.
1520 The verify flag is set if this is being called for verification rather than
1521 delivery. If the router doesn't have its "verify" flag set, it is skipped.
1522
1523 Arguments:
1524   addr           address to route
1525   paddr_local    chain of local-delivery addresses
1526   paddr_remote   chain of remote-delivery addresses
1527   addr_new       chain for newly created addresses
1528   addr_succeed   chain for completed addresses
1529   verify         v_none if not verifying
1530                  v_sender if verifying a sender address
1531                  v_recipient if verifying a recipient address
1532                  v_expn if processing an EXPN address
1533
1534 Returns:         OK      => address successfully routed
1535                  DISCARD => address was discarded
1536                  FAIL    => address could not be routed
1537                  DEFER   => some temporary problem
1538                  ERROR   => some major internal or configuration failure
1539 */
1540
1541 int
1542 route_address(address_item *addr, address_item **paddr_local,
1543   address_item **paddr_remote, address_item **addr_new,
1544   address_item **addr_succeed, int verify)
1545 {
1546 int yield = OK;
1547 BOOL unseen;
1548 router_instance *r, *nextr;
1549 const uschar *old_domain = addr->domain;
1550
1551 HDEBUG(D_route)
1552   {
1553   debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1554   debug_printf("routing %s\n", addr->address);
1555   }
1556
1557 /* Loop through all router instances until a router succeeds, fails, defers, or
1558 encounters an error. If the address has start_router set, we begin from there
1559 instead of at the first router. */
1560
1561 for (r = addr->start_router ? addr->start_router : routers; r; r = nextr)
1562   {
1563   uschar *error;
1564   struct passwd *pw = NULL;
1565   struct passwd pwcopy;
1566   BOOL loop_detected = FALSE;
1567   BOOL more;
1568   int loopcount = 0;
1569   int rc;
1570
1571   DEBUG(D_route) debug_printf("--------> %s router <--------\n", r->name);
1572
1573   /* Reset any search error message from the previous router. */
1574
1575   search_error_message = NULL;
1576
1577   /* There are some weird cases where logging is disabled */
1578
1579   f.disable_logging = r->disable_logging;
1580
1581   /* Record the last router to handle the address, and set the default
1582   next router. */
1583
1584   addr->router = r;
1585   nextr = r->next;
1586
1587   /* Loop protection: If this address has an ancestor with the same address,
1588   and that ancestor was routed by this router, we skip this router. This
1589   prevents a variety of looping states when a new address is created by
1590   redirection or by the use of "unseen" on a router.
1591
1592   If no_repeat_use is set on the router, we skip if _any_ ancestor was routed
1593   by  this router, even if it was different to the current address.
1594
1595   Just in case someone does put it into a loop (possible with redirection
1596   continually adding to an address, for example), put a long stop counter on
1597   the number of parents. */
1598
1599   for (address_item * parent = addr->parent; parent; parent = parent->parent)
1600     {
1601     if (parent->router == r)
1602       {
1603       BOOL break_loop = !r->repeat_use;
1604
1605       /* When repeat_use is set, first check the active addresses caselessly.
1606       If they match, we have to do a further caseful check of the local parts
1607       when caseful_local_part is set. This is assumed to be rare, which is why
1608       the code is written this way. */
1609
1610       if (!break_loop)
1611         {
1612         break_loop = strcmpic(parent->address, addr->address) == 0;
1613         if (break_loop && r->caseful_local_part)
1614           break_loop = Ustrncmp(parent->address, addr->address,
1615              Ustrrchr(addr->address, '@') - addr->address) == 0;
1616         }
1617
1618       if (break_loop)
1619         {
1620         DEBUG(D_route) debug_printf("%s router skipped: previously routed %s\n",
1621           r->name, parent->address);
1622         loop_detected = TRUE;
1623         break;
1624         }
1625       }
1626
1627     /* Continue with parents, limiting the size of the dynasty. */
1628
1629     if (loopcount++ > 100)
1630       {
1631       log_write(0, LOG_MAIN|LOG_PANIC, "routing loop for %s", addr->address);
1632       yield = DEFER;
1633       goto ROUTE_EXIT;
1634       }
1635     }
1636
1637   if (loop_detected) continue;
1638
1639   /* Default no affixes and select whether to use a caseful or caseless local
1640   part in this router. */
1641
1642   addr->prefix = addr->prefix_v = addr->suffix = addr->suffix_v = NULL;
1643   addr->local_part = r->caseful_local_part
1644     ? addr->cc_local_part : addr->lc_local_part;
1645
1646   DEBUG(D_route) debug_printf("local_part=%s domain=%s\n", addr->local_part,
1647     addr->domain);
1648
1649   /* Handle any configured prefix by replacing the local_part address,
1650   and setting the prefix. Skip the router if the prefix doesn't match,
1651   unless the prefix is optional. */
1652
1653   if (r->prefix)
1654     {
1655     unsigned vlen;
1656     int plen = route_check_prefix(addr->local_part, r->prefix, &vlen);
1657     if (plen > 0)
1658       {
1659       addr->prefix = string_copyn(addr->local_part, plen);
1660       if (vlen) addr->prefix_v = string_copyn(addr->local_part, vlen);
1661       addr->local_part += plen;
1662       DEBUG(D_route) debug_printf("stripped prefix %s\n", addr->prefix);
1663       }
1664     else if (!r->prefix_optional)
1665       {
1666       DEBUG(D_route) debug_printf("%s router skipped: prefix mismatch\n",
1667         r->name);
1668       continue;
1669       }
1670     }
1671
1672   /* Handle any configured suffix likewise. */
1673
1674   if (r->suffix)
1675     {
1676     unsigned vlen;
1677     int slen = route_check_suffix(addr->local_part, r->suffix, &vlen);
1678     if (slen > 0)
1679       {
1680       int lplen = Ustrlen(addr->local_part) - slen;
1681       addr->suffix = addr->local_part + lplen;
1682       addr->suffix_v = addr->suffix + Ustrlen(addr->suffix) - vlen;
1683       addr->local_part = string_copyn(addr->local_part, lplen);
1684       DEBUG(D_route) debug_printf("stripped suffix %s\n", addr->suffix);
1685       }
1686     else if (!r->suffix_optional)
1687       {
1688       DEBUG(D_route) debug_printf("%s router skipped: suffix mismatch\n",
1689         r->name);
1690       continue;
1691       }
1692     }
1693
1694   /* Set the expansion variables now that we have the affixes and the case of
1695   the local part sorted. */
1696
1697   router_name = r->name;
1698   deliver_localpart_verified = NULL;
1699   deliver_set_expansions(addr);
1700
1701   /* For convenience, the pre-router checks are in a separate function, which
1702   returns OK, SKIP, FAIL, or DEFER. */
1703
1704   if ((rc = check_router_conditions(r, addr, verify, &pw, &error)) != OK)
1705     {
1706     router_name = NULL;
1707     if (rc == SKIP) continue;
1708     addr->message = error;
1709     yield = rc;
1710     goto ROUTE_EXIT;
1711     }
1712
1713   /* All pre-conditions have been met. Reset any search error message from
1714   pre-condition tests. These can arise in negated tests where the failure of
1715   the lookup leads to a TRUE pre-condition. */
1716
1717   search_error_message = NULL;
1718
1719   /* Add any variable-settings that are on the router, to the set on the
1720   addr. Expansion is done here and not later when the addr is used.  There may
1721   be multiple settings, gathered during readconf; this code gathers them during
1722   router traversal.  On the addr string they are held as a variable tree, so
1723   as to maintain the post-expansion taints separate. */
1724
1725   switch (set_router_vars(addr, r))
1726     {
1727     case OK:    break;
1728     case PASS:  continue;               /* with next router */
1729     default:     goto ROUTE_EXIT;
1730     }
1731
1732   /* Finally, expand the address_data field in the router. Forced failure
1733   behaves as if the router declined. Any other failure is more serious. On
1734   success, the string is attached to the address for all subsequent processing.
1735   */
1736
1737   if (r->address_data)
1738     {
1739     DEBUG(D_route) debug_printf("processing address_data\n");
1740     if (!(deliver_address_data = expand_string(r->address_data)))
1741       {
1742       if (f.expand_string_forcedfail)
1743         {
1744         DEBUG(D_route) debug_printf("forced failure in expansion of \"%s\" "
1745             "(address_data): decline action taken\n", r->address_data);
1746
1747         /* Expand "more" if necessary; DEFER => an expansion failed */
1748
1749         yield = exp_bool(addr, US"router", r->name, D_route,
1750                         US"more", r->more, r->expand_more, &more);
1751         if (yield != OK) goto ROUTE_EXIT;
1752
1753         if (!more)
1754           {
1755           DEBUG(D_route)
1756             debug_printf("\"more\"=false: skipping remaining routers\n");
1757           router_name = NULL;
1758           r = NULL;
1759           break;
1760           }
1761         else continue;    /* With next router */
1762         }
1763
1764       else
1765         {
1766         addr->message = string_sprintf("expansion of \"%s\" failed "
1767           "in %s router: %s", r->address_data, r->name, expand_string_message);
1768         yield = DEFER;
1769         goto ROUTE_EXIT;
1770         }
1771       }
1772     addr->prop.address_data = deliver_address_data;
1773     }
1774
1775   /* We are finally cleared for take-off with this router. Clear the the flag
1776   that records that a local host was removed from a routed host list. Make a
1777   copy of relevant fields in the password information from check_local_user,
1778   because it will be overwritten if check_local_user is invoked again while
1779   verifying an errors_address setting. */
1780
1781   clearflag(addr, af_local_host_removed);
1782
1783   if (pw)
1784     {
1785     pwcopy.pw_name = CS string_copy(US pw->pw_name);
1786     pwcopy.pw_uid = pw->pw_uid;
1787     pwcopy.pw_gid = pw->pw_gid;
1788     pwcopy.pw_gecos = CS string_copy(US pw->pw_gecos);
1789     pwcopy.pw_dir = CS string_copy(US pw->pw_dir);
1790     pwcopy.pw_shell = CS string_copy(US pw->pw_shell);
1791     pw = &pwcopy;
1792     }
1793
1794   /* If this should be the last hop for DSN flag the addr. */
1795
1796   if (r->dsn_lasthop && !(addr->dsn_flags & rf_dsnlasthop))
1797     {
1798     addr->dsn_flags |= rf_dsnlasthop;
1799     HDEBUG(D_route) debug_printf("DSN: last hop for %s\n", addr->address);
1800     }
1801
1802   /* Run the router, and handle the consequences. */
1803
1804   HDEBUG(D_route) debug_printf("calling %s router\n", r->name);
1805
1806   yield = (r->info->code)(r, addr, pw, verify, paddr_local, paddr_remote,
1807     addr_new, addr_succeed);
1808
1809   router_name = NULL;
1810
1811   if (yield == FAIL)
1812     {
1813     HDEBUG(D_route) debug_printf("%s router forced address failure\n", r->name);
1814     goto ROUTE_EXIT;
1815     }
1816
1817   /* If succeeded while verifying but fail_verify is set, convert into
1818   a failure, and take it off the local or remote delivery list. */
1819
1820   if (  (  verify == v_sender && r->fail_verify_sender
1821         || verify == v_recipient && r->fail_verify_recipient
1822         )
1823      && (yield == OK || yield == PASS))
1824     {
1825     addr->message = string_sprintf("%s router forced verify failure", r->name);
1826     if (*paddr_remote == addr) *paddr_remote = addr->next;
1827     if (*paddr_local == addr) *paddr_local = addr->next;
1828     yield = FAIL;
1829     goto ROUTE_EXIT;
1830     }
1831
1832   /* PASS and DECLINE are the only two cases where the loop continues. For all
1833   other returns, we break the loop and handle the result below. */
1834
1835   if (yield != PASS && yield != DECLINE) break;
1836
1837   HDEBUG(D_route)
1838     {
1839     debug_printf("%s router %s for %s\n", r->name,
1840       yield == PASS ? "passed" : "declined", addr->address);
1841     if (Ustrcmp(old_domain, addr->domain) != 0)
1842       debug_printf("domain %s rewritten\n", old_domain);
1843     }
1844
1845   /* PASS always continues to another router; DECLINE does so if "more"
1846   is true. Initialization insists that pass_router is always a following
1847   router. Otherwise, break the loop as if at the end of the routers. */
1848
1849   if (yield == PASS)
1850     {
1851     if (r->pass_router != NULL) nextr = r->pass_router;
1852     }
1853   else
1854     {
1855     /* Expand "more" if necessary */
1856
1857     yield = exp_bool(addr, US"router", r->name, D_route,
1858                         US"more", r->more, r->expand_more, &more);
1859     if (yield != OK) goto ROUTE_EXIT;
1860
1861     if (!more)
1862       {
1863       HDEBUG(D_route)
1864         debug_printf("\"more\" is false: skipping remaining routers\n");
1865       r = NULL;
1866       break;
1867       }
1868     }
1869   }                                      /* Loop for all routers */
1870
1871 /* On exit from the routers loop, if r == NULL we have run out of routers,
1872 either genuinely, or as a result of no_more. Otherwise, the loop ended
1873 prematurely, either because a router succeeded, or because of some special
1874 router response. Note that FAIL errors and errors detected before actually
1875 running a router go direct to ROUTE_EXIT from code above. */
1876
1877 if (!r)
1878   {
1879   HDEBUG(D_route) debug_printf("no more routers\n");
1880   if (!addr->message)
1881     {
1882     uschar *message = US"Unrouteable address";
1883     if (addr->router && addr->router->cannot_route_message)
1884       {
1885       uschar *expmessage = expand_string(addr->router->cannot_route_message);
1886       if (!expmessage)
1887         {
1888         if (!f.expand_string_forcedfail)
1889           log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
1890             "cannot_route_message in %s router: %s", addr->router->name,
1891             expand_string_message);
1892         }
1893       else message = expmessage;
1894       }
1895     addr->user_message = addr->message = message;
1896     }
1897   addr->router = NULL;         /* For logging */
1898   yield = FAIL;
1899   goto ROUTE_EXIT;
1900   }
1901
1902 if (yield == DEFER)
1903   {
1904   HDEBUG(D_route) debug_printf("%s router: defer for %s\n  message: %s\n",
1905       r->name, addr->address, addr->message ? addr->message : US"<none>");
1906   goto ROUTE_EXIT;
1907   }
1908
1909 if (yield == DISCARD) goto ROUTE_EXIT;
1910
1911 /* The yield must be either OK or REROUTED. */
1912
1913 if (yield != OK && yield != REROUTED)
1914   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router returned unknown value %d",
1915     r->name, yield);
1916
1917 /* If the yield was REROUTED, the router put a child address on the new chain
1918 as a result of a domain change of some sort (widening, typically). */
1919
1920 if (yield == REROUTED)
1921   {
1922   HDEBUG(D_route) debug_printf("re-routed to %s\n", addr->address);
1923   yield = OK;
1924   goto ROUTE_EXIT;
1925   }
1926
1927 /* The only remaining possibility is that the router succeeded. If the
1928 translate_ip_address options is set and host addresses were associated with the
1929 address, run them through the translation. This feature is for weird and
1930 wonderful situations (the amateur packet radio people need it) or very broken
1931 networking, so it is included in the binary only if requested. */
1932
1933 #ifdef SUPPORT_TRANSLATE_IP_ADDRESS
1934
1935 if (r->translate_ip_address)
1936   {
1937   int rc;
1938   int old_pool = store_pool;
1939   for (host_item * h = addr->host_list; h; h = h->next)
1940     {
1941     uschar *newaddress;
1942     uschar *oldaddress, *oldname;
1943
1944     if (!h->address) continue;
1945
1946     deliver_host_address = h->address;
1947     newaddress = expand_string(r->translate_ip_address);
1948     deliver_host_address = NULL;
1949
1950     if (!newaddress)
1951       {
1952       if (f.expand_string_forcedfail) continue;
1953       addr->basic_errno = ERRNO_EXPANDFAIL;
1954       addr->message = string_sprintf("translate_ip_address expansion "
1955         "failed: %s", expand_string_message);
1956       yield = DEFER;
1957       goto ROUTE_EXIT;
1958       }
1959
1960     DEBUG(D_route) debug_printf("%s [%s] translated to %s\n",
1961       h->name, h->address, newaddress);
1962     if (string_is_ip_address(newaddress, NULL) != 0)
1963       {
1964       h->address = newaddress;
1965       continue;
1966       }
1967
1968     oldname = h->name;
1969     oldaddress = h->address;
1970     h->name = newaddress;
1971     h->address = NULL;
1972     h->mx = MX_NONE;
1973
1974     store_pool = POOL_PERM;
1975     rc = host_find_byname(h, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, TRUE);
1976     store_pool = old_pool;
1977
1978     if (rc == HOST_FIND_FAILED || rc == HOST_FIND_AGAIN)
1979       {
1980       addr->basic_errno = ERRNO_UNKNOWNHOST;
1981       addr->message = string_sprintf("host %s not found when "
1982         "translating %s [%s]", h->name, oldname, oldaddress);
1983       yield = DEFER;
1984       goto ROUTE_EXIT;
1985       }
1986     }
1987   }
1988 #endif  /* SUPPORT_TRANSLATE_IP_ADDRESS */
1989
1990 /* See if this is an unseen routing; first expand the option if necessary.
1991 DEFER can be given if the expansion fails */
1992
1993 yield = exp_bool(addr, US"router", r->name, D_route,
1994                 US"unseen", r->unseen, r->expand_unseen, &unseen);
1995 if (yield != OK) goto ROUTE_EXIT;
1996
1997 /* Debugging output recording a successful routing */
1998
1999 HDEBUG(D_route) debug_printf("routed by %s router%s\n", r->name,
2000     unseen? " (unseen)" : "");
2001
2002 DEBUG(D_route)
2003   {
2004   debug_printf("  envelope to: %s\n", addr->address);
2005   debug_printf("  transport: %s\n", addr->transport
2006     ? addr->transport->name : US"<none>");
2007
2008   if (addr->prop.errors_address)
2009     debug_printf("  errors to %s\n", addr->prop.errors_address);
2010
2011   for (host_item * h = addr->host_list; h; h = h->next)
2012     {
2013     debug_printf("  host %s", h->name);
2014     if (h->address) debug_printf(" [%s]", h->address);
2015     if (h->mx >= 0) debug_printf(" MX=%d", h->mx);
2016       else if (h->mx != MX_NONE) debug_printf(" rgroup=%d", h->mx);
2017     if (h->port != PORT_NONE) debug_printf(" port=%d", h->port);
2018     if (h->dnssec != DS_UNK) debug_printf(" dnssec=%s", h->dnssec==DS_YES ? "yes" : "no");
2019     debug_printf("\n");
2020     }
2021   }
2022
2023 /* Clear any temporary error message set by a router that declined, and handle
2024 the "unseen" option (ignore if there are no further routers). */
2025
2026 addr->message = NULL;
2027 if (unseen && r->next)
2028   route_unseen(r->name, addr, paddr_local, paddr_remote, addr_new);
2029
2030 /* Unset the address expansions, and return the final result. */
2031
2032 ROUTE_EXIT:
2033 if (yield == DEFER && addr->message)
2034   addr->message = expand_hide_passwords(addr->message);
2035
2036 deliver_set_expansions(NULL);
2037 router_name = NULL;
2038 f.disable_logging = FALSE;
2039 return yield;
2040 }
2041
2042 #endif  /*!MACRO_PREDEF*/
2043 /* End of route.c */