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