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