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