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