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