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