1 /* $Cambridge: exim/src/src/route.c,v 1.9 2006/07/14 14:00:16 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2006 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* Functions concerned with routing, and the list of generic router options. */
17 /* Generic options for routers, all of which live inside router_instance
18 data blocks and which therefore have the opt_public flag set. */
20 optionlist optionlist_routers[] = {
21 { "*expand_group", opt_stringptr | opt_hidden | opt_public,
22 (void *)(offsetof(router_instance, expand_gid)) },
23 { "*expand_more", opt_stringptr | opt_hidden | opt_public,
24 (void *)(offsetof(router_instance, expand_more)) },
25 { "*expand_unseen", opt_stringptr | opt_hidden | opt_public,
26 (void *)(offsetof(router_instance, expand_unseen)) },
27 { "*expand_user", opt_stringptr | opt_hidden | opt_public,
28 (void *)(offsetof(router_instance, expand_uid)) },
29 { "*set_group", opt_bool | opt_hidden | opt_public,
30 (void *)(offsetof(router_instance, gid_set)) },
31 { "*set_user", opt_bool | opt_hidden | opt_public,
32 (void *)(offsetof(router_instance, uid_set)) },
33 { "address_data", opt_stringptr|opt_public,
34 (void *)(offsetof(router_instance, address_data)) },
35 { "address_test", opt_bool|opt_public,
36 (void *)(offsetof(router_instance, address_test)) },
37 #ifdef EXPERIMENTAL_BRIGHTMAIL
38 { "bmi_deliver_alternate", opt_bool | opt_public,
39 (void *)(offsetof(router_instance, bmi_deliver_alternate)) },
40 { "bmi_deliver_default", opt_bool | opt_public,
41 (void *)(offsetof(router_instance, bmi_deliver_default)) },
42 { "bmi_dont_deliver", opt_bool | opt_public,
43 (void *)(offsetof(router_instance, bmi_dont_deliver)) },
44 { "bmi_rule", opt_stringptr|opt_public,
45 (void *)(offsetof(router_instance, bmi_rule)) },
47 { "cannot_route_message", opt_stringptr | opt_public,
48 (void *)(offsetof(router_instance, cannot_route_message)) },
49 { "caseful_local_part", opt_bool | opt_public,
50 (void *)(offsetof(router_instance, caseful_local_part)) },
51 { "check_local_user", opt_bool | opt_public,
52 (void *)(offsetof(router_instance, check_local_user)) },
53 { "condition", opt_stringptr|opt_public,
54 (void *)offsetof(router_instance, condition) },
55 { "debug_print", opt_stringptr | opt_public,
56 (void *)offsetof(router_instance, debug_string) },
57 { "disable_logging", opt_bool | opt_public,
58 (void *)offsetof(router_instance, disable_logging) },
59 { "domains", opt_stringptr|opt_public,
60 (void *)offsetof(router_instance, domains) },
61 { "driver", opt_stringptr|opt_public,
62 (void *)offsetof(router_instance, driver_name) },
63 { "errors_to", opt_stringptr|opt_public,
64 (void *)(offsetof(router_instance, errors_to)) },
65 { "expn", opt_bool|opt_public,
66 (void *)offsetof(router_instance, expn) },
67 { "fail_verify", opt_bool_verify|opt_hidden|opt_public,
68 (void *)offsetof(router_instance, fail_verify_sender) },
69 { "fail_verify_recipient", opt_bool|opt_public,
70 (void *)offsetof(router_instance, fail_verify_recipient) },
71 { "fail_verify_sender", opt_bool|opt_public,
72 (void *)offsetof(router_instance, fail_verify_sender) },
73 { "fallback_hosts", opt_stringptr|opt_public,
74 (void *)offsetof(router_instance, fallback_hosts) },
75 { "group", opt_expand_gid | opt_public,
76 (void *)(offsetof(router_instance, gid)) },
77 { "headers_add", opt_stringptr|opt_public,
78 (void *)offsetof(router_instance, extra_headers) },
79 { "headers_remove", opt_stringptr|opt_public,
80 (void *)offsetof(router_instance, remove_headers) },
81 { "ignore_target_hosts",opt_stringptr|opt_public,
82 (void *)offsetof(router_instance, ignore_target_hosts) },
83 { "initgroups", opt_bool | opt_public,
84 (void *)(offsetof(router_instance, initgroups)) },
85 { "local_part_prefix", opt_stringptr|opt_public,
86 (void *)offsetof(router_instance, prefix) },
87 { "local_part_prefix_optional",opt_bool|opt_public,
88 (void *)offsetof(router_instance, prefix_optional) },
89 { "local_part_suffix", opt_stringptr|opt_public,
90 (void *)offsetof(router_instance, suffix) },
91 { "local_part_suffix_optional",opt_bool|opt_public,
92 (void *)offsetof(router_instance, suffix_optional) },
93 { "local_parts", opt_stringptr|opt_public,
94 (void *)offsetof(router_instance, local_parts) },
95 { "log_as_local", opt_bool|opt_public,
96 (void *)offsetof(router_instance, log_as_local) },
97 { "more", opt_expand_bool|opt_public,
98 (void *)offsetof(router_instance, more) },
99 { "pass_on_timeout", opt_bool|opt_public,
100 (void *)offsetof(router_instance, pass_on_timeout) },
101 { "pass_router", opt_stringptr|opt_public,
102 (void *)offsetof(router_instance, pass_router_name) },
103 { "redirect_router", opt_stringptr|opt_public,
104 (void *)offsetof(router_instance, redirect_router_name) },
105 { "require_files", opt_stringptr|opt_public,
106 (void *)offsetof(router_instance, require_files) },
107 { "retry_use_local_part", opt_bool|opt_public,
108 (void *)offsetof(router_instance, retry_use_local_part) },
109 { "router_home_directory", opt_stringptr|opt_public,
110 (void *)offsetof(router_instance, router_home_directory) },
111 { "self", opt_stringptr|opt_public,
112 (void *)(offsetof(router_instance, self)) },
113 { "senders", opt_stringptr|opt_public,
114 (void *)offsetof(router_instance, senders) },
115 #ifdef SUPPORT_TRANSLATE_IP_ADDRESS
116 { "translate_ip_address", opt_stringptr|opt_public,
117 (void *)offsetof(router_instance, translate_ip_address) },
119 { "transport", opt_stringptr|opt_public,
120 (void *)offsetof(router_instance, transport_name) },
121 { "transport_current_directory", opt_stringptr|opt_public,
122 (void *)offsetof(router_instance, current_directory) },
123 { "transport_home_directory", opt_stringptr|opt_public,
124 (void *)offsetof(router_instance, home_directory) },
125 { "unseen", opt_expand_bool|opt_public,
126 (void *)offsetof(router_instance, unseen) },
127 { "user", opt_expand_uid | opt_public,
128 (void *)(offsetof(router_instance, uid)) },
129 { "verify", opt_bool_verify|opt_hidden|opt_public,
130 (void *)offsetof(router_instance, verify_sender) },
131 { "verify_only", opt_bool|opt_public,
132 (void *)offsetof(router_instance, verify_only) },
133 { "verify_recipient", opt_bool|opt_public,
134 (void *)offsetof(router_instance, verify_recipient) },
135 { "verify_sender", opt_bool|opt_public,
136 (void *)offsetof(router_instance, verify_sender) }
139 int optionlist_routers_size = sizeof(optionlist_routers)/sizeof(optionlist);
143 /*************************************************
144 * Set router pointer from name *
145 *************************************************/
147 /* This function is used for the redirect_router and pass_router options and
148 called from route_init() below.
153 ptr where to put the pointer
154 after TRUE if router must follow this one
160 set_router(router_instance *r, uschar *name, router_instance **ptr, BOOL after)
162 BOOL afterthis = FALSE;
165 for (rr = routers; rr != NULL; rr = rr->next)
167 if (Ustrcmp(name, rr->name) == 0)
172 if (rr == r) afterthis = TRUE;
176 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
177 "new_router \"%s\" not found for \"%s\" router", name, r->name);
179 if (after && !afterthis)
180 log_write(0, LOG_PANIC_DIE|LOG_CONFIG,
181 "new_router \"%s\" does not follow \"%s\" router", name, r->name);
186 /*************************************************
187 * Initialize router list *
188 *************************************************/
190 /* Read the routers section of the configuration file, and set up a chain of
191 router instances according to its contents. Each router has generic options and
192 may also have its own private options. This function is only ever called when
193 routers == NULL. We use generic code in readconf to do the work. It will set
194 values from the configuration file, and then call the driver's initialization
202 readconf_driver_init(US"router",
203 (driver_instance **)(&routers), /* chain anchor */
204 (driver_info *)routers_available, /* available drivers */
205 sizeof(router_info), /* size of info blocks */
206 &router_defaults, /* default values for generic options */
207 sizeof(router_instance), /* size of instance block */
208 optionlist_routers, /* generic options */
209 optionlist_routers_size);
211 for (r = routers; r != NULL; r = r->next)
215 /* If log_as_local is unset, its overall default is FALSE. (The accept
216 router defaults it to TRUE.) */
218 if (r->log_as_local == TRUE_UNSET) r->log_as_local = FALSE;
220 /* Check for transport or no transport on certain routers */
222 if ((r->info->ri_flags & ri_yestransport) != 0 &&
223 r->transport_name == NULL &&
225 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "%s router:\n "
226 "a transport is required for this router", r->name);
228 if ((r->info->ri_flags & ri_notransport) != 0 &&
229 r->transport_name != NULL)
230 log_write(0, LOG_PANIC_DIE|LOG_CONFIG, "%s router:\n "
231 "a transport must not be defined for this router", r->name);
233 /* The "self" option needs to be decoded into a code value and possibly a
234 new domain string and a rewrite boolean. */
236 if (Ustrcmp(s, "freeze") == 0) r->self_code = self_freeze;
237 else if (Ustrcmp(s, "defer") == 0) r->self_code = self_defer;
238 else if (Ustrcmp(s, "send") == 0) r->self_code = self_send;
239 else if (Ustrcmp(s, "pass") == 0) r->self_code = self_pass;
240 else if (Ustrcmp(s, "fail") == 0) r->self_code = self_fail;
241 else if (Ustrncmp(s, "reroute:", 8) == 0)
244 while (isspace(*s)) s++;
245 if (Ustrncmp(s, "rewrite:", 8) == 0)
247 r->self_rewrite = TRUE;
249 while (isspace(*s)) s++;
252 r->self_code = self_reroute;
255 else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
256 "%s is not valid for the self option", r->name, s);
258 /* If any router has check_local_user set, default retry_use_local_part
259 TRUE; otherwise its default is FALSE. */
261 if (r->retry_use_local_part == TRUE_UNSET)
262 r->retry_use_local_part = r->check_local_user;
264 /* Build a host list if fallback hosts is set. */
266 host_build_hostlist(&(r->fallback_hostlist), r->fallback_hosts, FALSE);
268 /* Check redirect_router and pass_router are valid */
270 if (r->redirect_router_name != NULL)
271 set_router(r, r->redirect_router_name, &(r->redirect_router), FALSE);
273 if (r->pass_router_name != NULL)
274 set_router(r, r->pass_router_name, &(r->pass_router), TRUE);
280 /*************************************************
281 * Tidy up after routing *
282 *************************************************/
284 /* Routers are entitled to keep hold of certain resources in their instance
285 blocks so as to save setting them up each time. An example is an open file.
286 Such routers must provide a tidyup entry point which is called when all routing
287 is finished, via this function. */
293 for (r = routers; r != NULL; r = r->next)
294 if (r->info->tidyup != NULL) (r->info->tidyup)(r);
299 /*************************************************
300 * Check local part for prefix *
301 *************************************************/
303 /* This function is handed a local part and a list of possible prefixes; if any
304 one matches, return the prefix length. A prefix beginning with '*' is a
308 local_part the local part to check
309 prefixes the list of prefixes
311 Returns: length of matching prefix or zero
315 route_check_prefix(uschar *local_part, uschar *prefixes)
319 uschar *listptr = prefixes;
322 while ((prefix = string_nextinlist(&listptr, &sep, prebuf, sizeof(prebuf)))
325 int plen = Ustrlen(prefix);
326 if (prefix[0] == '*')
330 for (p = local_part + Ustrlen(local_part) - (--plen);
331 p >= local_part; p--)
332 if (strncmpic(prefix, p, plen) == 0) return plen + p - local_part;
335 if (strncmpic(prefix, local_part, plen) == 0) return plen;
343 /*************************************************
344 * Check local part for suffix *
345 *************************************************/
347 /* This function is handed a local part and a list of possible suffixes;
348 if any one matches, return the suffix length. A suffix ending with '*'
352 local_part the local part to check
353 suffixes the list of suffixes
355 Returns: length of matching suffix or zero
359 route_check_suffix(uschar *local_part, uschar *suffixes)
362 int alen = Ustrlen(local_part);
364 uschar *listptr = suffixes;
367 while ((suffix = string_nextinlist(&listptr, &sep, sufbuf, sizeof(sufbuf)))
370 int slen = Ustrlen(suffix);
371 if (suffix[slen-1] == '*')
374 pend = local_part + alen - (--slen) + 1;
375 for (p = local_part; p < pend; p++)
376 if (strncmpic(suffix, p, slen) == 0) return alen - (p - local_part);
379 if (alen > slen && strncmpic(suffix, local_part + alen - slen, slen) == 0)
389 /*************************************************
390 * Check local part, domain, or sender *
391 *************************************************/
393 /* The checks in check_router_conditions() require similar code, so we use
394 this function to save repetition.
397 rname router name for error messages
398 type type of check, for error message
399 list domains, local_parts, or senders list
400 anchorptr -> tree for possibly cached items (domains)
401 cache_bits cached bits pointer
402 listtype MCL_DOMAIN for domain check
403 MCL_LOCALPART for local part check
404 MCL_ADDRESS for sender check
405 domloc current domain, current local part, or NULL for sender check
406 ldata where to put lookup data
407 caseless passed on to match_isinlist()
408 perror where to put an error message
410 Returns: OK item is in list
411 SKIP item is not in list, router is to be skipped
412 DEFER lookup or other defer
416 route_check_dls(uschar *rname, uschar *type, uschar *list, tree_node
417 **anchorptr, unsigned int *cache_bits, int listtype, uschar *domloc,
418 uschar **ldata, BOOL caseless, uschar **perror)
422 if (list == NULL) return OK; /* Empty list always succeeds */
424 DEBUG(D_route) debug_printf("checking %s\n", type);
426 /* The domain and local part use the same matching function, whereas sender
431 rc = match_isinlist(domloc, &list, 0, anchorptr, cache_bits, listtype,
436 uschar *address = (sender_address == NULL)? US"" : sender_address;
437 rc = match_address_list(address, TRUE, TRUE, &list, cache_bits, -1, 0,
447 *perror = string_sprintf("%s router skipped: %s mismatch", rname, type);
448 DEBUG(D_route) debug_printf("%s\n", *perror);
451 default: /* Paranoia, and keeps compilers happy */
453 *perror = string_sprintf("%s check lookup or other defer", type);
454 DEBUG(D_route) debug_printf("%s\n", *perror);
461 /*************************************************
462 * Check access by a given uid/gid *
463 *************************************************/
465 /* This function checks whether a given uid/gid has access to a given file or
466 directory. It is called only from check_files() below. This is hopefully a
467 cheapish check that does the job most of the time. Exim does *not* rely on this
468 test when actually accessing any file. The test is used when routing to make it
469 possible to take actions such as "if user x can access file y then run this
472 During routing, Exim is normally running as root, and so the test will work
473 except for NFS non-root mounts. When verifying during message reception, Exim
474 is running as "exim", so the test may not work. This is a limitation of the
477 Code in check_files() below detects the case when it cannot stat() the file (as
478 root), and in that situation it uses a setuid subprocess in which to run this
482 path the path to check
485 bits the bits required in the final component
488 FALSE errno=EACCES or ENOENT (or others from realpath or stat)
492 route_check_access(uschar *path, uid_t uid, gid_t gid, int bits)
496 uschar *rp = US realpath(CS path, CS big_buffer);
499 DEBUG(D_route) debug_printf("route_check_access(%s,%d,%d,%o)\n", path,
500 (int)uid, (int)gid, bits);
502 if (rp == NULL) return FALSE;
504 while ((slash = Ustrchr(sp, '/')) != NULL)
507 DEBUG(D_route) debug_printf("stat %s\n", rp);
508 if (Ustat(rp, &statbuf) < 0) return FALSE;
509 if ((statbuf.st_mode &
510 ((statbuf.st_uid == uid)? 0100 : (statbuf.st_gid == gid)? 0010 : 001)
520 /* Down to the final component */
522 DEBUG(D_route) debug_printf("stat %s\n", rp);
524 if (Ustat(rp, &statbuf) < 0) return FALSE;
526 if (statbuf.st_uid == uid) bits = bits << 6;
527 else if (statbuf.st_gid == gid) bits = bits << 3;
528 if ((statbuf.st_mode & bits) != bits)
534 DEBUG(D_route) debug_printf("route_check_access() succeeded\n");
540 /*************************************************
541 * Do file existence tests *
542 *************************************************/
544 /* This function is given a colon-separated list of file tests, each of which
545 is expanded before use. A test consists of a file name, optionally preceded by
546 ! (require non-existence) and/or + for handling permission denied (+ means
547 treat as non-existing).
549 An item that contains no slashes is interpreted as a username or id, with an
550 optional group id, for checking access to the file. This cannot be done
551 "perfectly", but it is good enough for a number of applications.
554 s a colon-separated list of file tests or NULL
555 perror a pointer to an anchor for an error text in the case of a DEFER
557 Returns: OK if s == NULL or all tests are as required
558 DEFER if the existence of at least one of the files is
559 unclear (an error other than non-existence occurred);
560 DEFER if an expansion failed
561 DEFER if a name is not absolute
562 DEFER if problems with user/group
567 check_files(uschar *s, uschar **perror)
569 int sep = 0; /* List has default separators */
570 uid_t uid = 0; /* For picky compilers */
571 gid_t gid = 0; /* For picky compilers */
572 BOOL ugid_set = FALSE;
573 uschar *check, *listptr;
576 if (s == NULL) return OK;
578 DEBUG(D_route) debug_printf("checking require_files\n");
581 while ((check = string_nextinlist(&listptr, &sep, buffer, sizeof(buffer)))
588 uschar *ss = expand_string(check);
592 if (expand_string_forcedfail) continue;
593 *perror = string_sprintf("failed to expand \"%s\" for require_files: %s",
594 check, expand_string_message);
598 /* Empty items are just skipped */
600 if (*ss == 0) continue;
602 /* If there are no slashes in the string, we have a user name or uid, with
603 optional group/gid. */
605 if (Ustrchr(ss, '/') == NULL)
609 uschar *comma = Ustrchr(ss, ',');
611 /* If there's a comma, temporarily terminate the user name/number
612 at that point. Then set the uid. */
614 if (comma != NULL) *comma = 0;
615 ok = route_finduser(ss, &pw, &uid);
616 if (comma != NULL) *comma = ',';
620 *perror = string_sprintf("user \"%s\" for require_files not found", ss);
624 /* If there was no comma, the gid is that associated with the user. */
628 if (pw != NULL) gid = pw->pw_gid; else
630 *perror = string_sprintf("group missing after numerical uid %d for "
631 "require_files", (int)uid);
637 if (!route_findgroup(comma + 1, &gid))
639 *perror = string_sprintf("group \"%s\" for require_files not found\n",
645 /* Note that we have values set, and proceed to next item */
648 debug_printf("check subsequent files for access by %s\n", ss);
653 /* Path, possibly preceded by + and ! */
658 while (isspace((*(++ss))));
664 while (isspace((*(++ss))));
669 *perror = string_sprintf("require_files: \"%s\" is not absolute", ss);
673 /* Stat the file, either as root (while routing) or as exim (while verifying
674 during message reception). */
676 rc = Ustat(ss, &statbuf);
680 debug_printf("file check: %s\n", check);
681 if (ss != check) debug_printf("expanded file: %s\n", ss);
682 debug_printf("stat() yielded %d\n", rc);
685 /* If permission is denied, and we are running as root (i.e. routing for
686 delivery rather than verifying), and the requirement is to test for access by
687 a particular uid/gid, it must mean that the file is on a non-root-mounted NFS
688 system. In this case, we have to use a subprocess that runs as the relevant
689 uid in order to do the test. */
691 if (rc != 0 && errno == EACCES && ugid_set && getuid() == root_uid)
695 void (*oldsignal)(int);
697 DEBUG(D_route) debug_printf("root is denied access: forking to check "
700 /* Before forking, ensure that SIGCHLD is set to SIG_DFL before forking, so
701 that the child process can be waited for, just in case get here with it set
702 otherwise. Save the old state for resetting on the wait. */
704 oldsignal = signal(SIGCHLD, SIG_DFL);
707 /* If fork() fails, reinstate the original error and behave as if
708 this block of code were not present. This is the same behavious as happens
709 when Exim is not running as root at this point. */
714 debug_printf("require_files: fork failed: %s\n", strerror(errno));
719 /* In the child process, change uid and gid, and then do the check using
720 the route_check_access() function. This does more than just stat the file;
721 it tests permissions as well. Return 0 for OK and 1 for failure. */
725 exim_setugid(uid, gid, TRUE,
726 string_sprintf("require_files check, file=%s", ss));
727 if (route_check_access(ss, uid, gid, 4)) _exit(0);
728 DEBUG(D_route) debug_printf("route_check_access() failed\n");
732 /* In the parent, wait for the child to finish */
734 while (waitpid(pid, &status, 0) < 0)
736 if (errno != EINTR) /* unexpected error, interpret as failure */
743 signal(SIGCHLD, oldsignal); /* restore */
744 if ((status == 0) == invert) return SKIP;
745 continue; /* to test the next file */
748 /* Control reaches here if the initial stat() succeeds, or fails with an
749 error other than EACCES, or no uid/gid is set, or we are not running as root.
750 If we know the file exists and uid/gid are set, try to check read access for
751 that uid/gid as best we can. */
753 if (rc == 0 && ugid_set && !route_check_access(ss, uid, gid, 4))
755 DEBUG(D_route) debug_printf("route_check_access() failed\n");
759 /* Handle error returns from stat() or route_check_access(). The EACESS error
760 is handled specially. At present, we can force it to be treated as
761 non-existence. Write the code so that it will be easy to add forcing for
762 existence if required later. */
767 DEBUG(D_route) debug_printf("errno = %d\n", errno);
770 if (eacces_code == 1)
772 DEBUG(D_route) debug_printf("EACCES => ENOENT\n");
773 errno = ENOENT; /* Treat as non-existent */
778 *perror = string_sprintf("require_files: error for %s: %s", ss,
784 /* At this point, rc < 0 => non-existence; rc >= 0 => existence */
786 if ((rc >= 0) == invert) return SKIP;
791 /* Come here on any of the errors that return DEFER. */
794 DEBUG(D_route) debug_printf("%s\n", *perror);
802 /*************************************************
803 * Check for router skipping *
804 *************************************************/
806 /* This function performs various checks to see whether a router should be
807 skipped. The order in which they are performed is important.
810 r pointer to router instance block
811 addr address that is being handled
812 verify the verification type
813 pw ptr to ptr to passwd structure for local user
814 perror for lookup errors
816 Returns: OK if all the tests succeed
817 SKIP if router is to be skipped
818 DEFER for a lookup defer
819 FAIL for address to be failed
823 check_router_conditions(router_instance *r, address_item *addr, int verify,
824 struct passwd **pw, uschar **perror)
827 uschar *check_local_part;
829 /* Reset variables to hold a home directory and data from lookup of a domain or
830 local part, and ensure search_find_defer is unset, in case there aren't any
834 deliver_domain_data = NULL;
835 deliver_localpart_data = NULL;
837 local_user_gid = (gid_t)(-1);
838 local_user_uid = (uid_t)(-1);
839 search_find_defer = FALSE;
841 /* Skip this router if not verifying and it has verify_only set */
843 if ((verify == v_none || verify == v_expn) && r->verify_only)
845 DEBUG(D_route) debug_printf("%s router skipped: verify_only set\n", r->name);
849 /* Skip this router if testing an address (-bt) and address_test is not set */
851 if (address_test_mode && !r->address_test)
853 DEBUG(D_route) debug_printf("%s router skipped: address_test is unset\n",
858 /* Skip this router if verifying and it hasn't got the appropriate verify flag
861 if ((verify == v_sender && !r->verify_sender) ||
862 (verify == v_recipient && !r->verify_recipient))
864 DEBUG(D_route) debug_printf("%s router skipped: verify %d %d %d\n",
865 r->name, verify, r->verify_sender, r->verify_recipient);
869 /* Skip this router if processing EXPN and it doesn't have expn set */
871 if (verify == v_expn && !r->expn)
873 DEBUG(D_route) debug_printf("%s router skipped: no_expn set\n", r->name);
877 /* Skip this router if there's a domain mismatch. */
879 if ((rc = route_check_dls(r->name, US"domains", r->domains, &domainlist_anchor,
880 addr->domain_cache, TRUE, addr->domain, &deliver_domain_data, MCL_DOMAIN,
884 /* Skip this router if there's a local part mismatch. We want to pass over the
885 caseful local part, so that +caseful can restore it, even if this router is
886 handling local parts caselessly. However, we can't just pass cc_local_part,
887 because that doesn't have the prefix or suffix stripped. A bit of massaging is
890 if (addr->prefix == NULL && addr->suffix == NULL)
891 check_local_part = addr->cc_local_part;
894 check_local_part = string_copy(addr->cc_local_part);
895 if (addr->prefix != NULL)
896 check_local_part += Ustrlen(addr->prefix);
897 if (addr->suffix != NULL)
898 check_local_part[Ustrlen(check_local_part) - Ustrlen(addr->suffix)] = 0;
901 if ((rc = route_check_dls(r->name, US"local_parts", r->local_parts,
902 &localpartlist_anchor, addr->localpart_cache, MCL_LOCALPART,
903 check_local_part, &deliver_localpart_data, !r->caseful_local_part,
907 /* If the check_local_user option is set, check that the local_part is the
908 login of a local user. Note: the third argument to route_finduser() must be
909 NULL here, to prevent a numeric string being taken as a numeric uid. If the
910 user is found, set deliver_home to the home directory, and also set
911 local_user_{uid,gid}. */
913 if (r->check_local_user)
915 DEBUG(D_route) debug_printf("checking for local user\n");
916 if (!route_finduser(addr->local_part, pw, NULL))
918 DEBUG(D_route) debug_printf("%s router skipped: %s is not a local user\n",
919 r->name, addr->local_part);
922 deliver_home = string_copy(US (*pw)->pw_dir);
923 local_user_gid = (*pw)->pw_gid;
924 local_user_uid = (*pw)->pw_uid;
927 /* Set (or override in the case of check_local_user) the home directory if
928 router_home_directory is set. This is done here so that it overrides $home from
929 check_local_user before any subsequent expansions are done. Otherwise, $home
930 could mean different things for different options, which would be extremely
933 if (r->router_home_directory != NULL)
935 uschar *router_home = expand_string(r->router_home_directory);
936 if (router_home == NULL)
938 if (!expand_string_forcedfail)
940 *perror = string_sprintf("failed to expand \"%s\" for "
941 "router_home_directory: %s", r->router_home_directory,
942 expand_string_message);
948 setflag(addr, af_home_expanded); /* Note set from router_home_directory */
949 deliver_home = router_home;
953 /* Skip if the sender condition is not met. We leave this one till after the
954 local user check so that $home is set - enabling the possiblity of letting
955 individual recipients specify lists of acceptable/unacceptable senders. */
957 if ((rc = route_check_dls(r->name, US"senders", r->senders, NULL,
958 sender_address_cache, MCL_ADDRESS, NULL, NULL, FALSE, perror)) != OK)
961 /* This is the point at which we print out the router's debugging string if it
962 is set. We wait till here so as to have $home available for local users (and
963 anyway, we don't want too much stuff for skipped routers). */
965 debug_print_string(r->debug_string);
967 /* Perform file existence tests. */
969 if ((rc = check_files(r->require_files, perror)) != OK)
971 DEBUG(D_route) debug_printf("%s router %s: file check\n", r->name,
972 (rc == SKIP)? "skipped" : "deferred");
976 /* Now the general condition test. */
978 if (r->condition != NULL)
980 DEBUG(D_route) debug_printf("checking \"condition\"\n");
981 if (!expand_check_condition(r->condition, r->name, US"router"))
983 if (search_find_defer)
985 *perror = US"condition check lookup defer";
986 DEBUG(D_route) debug_printf("%s\n", *perror);
990 debug_printf("%s router skipped: condition failure\n", r->name);
995 #ifdef EXPERIMENTAL_BRIGHTMAIL
996 /* check if a specific Brightmail AntiSpam rule fired on the message */
997 if (r->bmi_rule != NULL) {
998 DEBUG(D_route) debug_printf("checking bmi_rule\n");
999 if (bmi_check_rule(bmi_base64_verdict, r->bmi_rule) == 0) {
1000 /* none of the rules fired */
1002 debug_printf("%s router skipped: none of bmi_rule rules fired\n", r->name);
1007 /* check if message should not be delivered */
1008 if (r->bmi_dont_deliver) {
1009 if (bmi_deliver == 1) {
1011 debug_printf("%s router skipped: bmi_dont_deliver is FALSE\n", r->name);
1016 /* check if message should go to an alternate location */
1017 if (r->bmi_deliver_alternate) {
1018 if ((bmi_deliver == 0) || (bmi_alt_location == NULL)) {
1020 debug_printf("%s router skipped: bmi_deliver_alternate is FALSE\n", r->name);
1025 /* check if message should go to default location */
1026 if (r->bmi_deliver_default) {
1027 if ((bmi_deliver == 0) || (bmi_alt_location != NULL)) {
1029 debug_printf("%s router skipped: bmi_deliver_default is FALSE\n", r->name);
1035 /* All the checks passed. */
1043 /*************************************************
1044 * Find a local user *
1045 *************************************************/
1047 /* Try several times (if configured) to find a local user, in case delays in
1048 NIS or NFS whatever cause an incorrect refusal. It's a pity that getpwnam()
1049 doesn't have some kind of indication as to why it has failed. If the string
1050 given consists entirely of digits, and the third argument is not NULL, assume
1051 the string is the numerical value of the uid. Otherwise it is looked up using
1052 getpwnam(). The uid is passed back via return_uid, if not NULL, and the
1053 pointer to a passwd structure, if found, is passed back via pw, if not NULL.
1055 Because this may be called several times in succession for the same user for
1056 different routers, cache the result of the previous getpwnam call so that it
1057 can be re-used. Note that we can't just copy the structure, as the store it
1058 points to can get trashed.
1061 s the login name or textual form of the numerical uid of the user
1062 pw if not NULL, return the result of getpwnam here, or set NULL
1063 if no call to getpwnam is made (s numeric, return_uid != NULL)
1064 return_uid if not NULL, return the uid via this address
1066 Returns: TRUE if s is numerical or was looked up successfully
1070 static struct passwd pwcopy;
1071 static struct passwd *lastpw = NULL;
1072 static uschar lastname[48] = { 0 };
1073 static uschar lastdir[128];
1074 static uschar lastgecos[128];
1075 static uschar lastshell[128];
1078 route_finduser(uschar *s, struct passwd **pw, uid_t *return_uid)
1080 BOOL cache_set = (Ustrcmp(lastname, s) == 0);
1082 DEBUG(D_uid) debug_printf("seeking password data for user \"%s\": %s\n", s,
1083 cache_set? "using cached result" : "cache not available");
1089 if (return_uid != NULL && (isdigit(*s) || *s == '-') &&
1090 s[Ustrspn(s+1, "0123456789")+1] == 0)
1092 *return_uid = (uid_t)Uatoi(s);
1093 if (pw != NULL) *pw = NULL;
1097 (void)string_format(lastname, sizeof(lastname), "%s", s);
1099 /* Force failure if string length is greater than given maximum */
1101 if (max_username_length > 0 && Ustrlen(lastname) > max_username_length)
1103 DEBUG(D_uid) debug_printf("forced failure of finduser(): string "
1104 "length of %s is greater than %d\n", lastname, max_username_length);
1108 /* Try a few times if so configured; this handles delays in NIS etc. */
1112 if ((lastpw = getpwnam(CS s)) != NULL) break;
1113 if (++i > finduser_retries) break;
1119 pwcopy.pw_uid = lastpw->pw_uid;
1120 pwcopy.pw_gid = lastpw->pw_gid;
1121 (void)string_format(lastdir, sizeof(lastdir), "%s", lastpw->pw_dir);
1122 (void)string_format(lastgecos, sizeof(lastgecos), "%s", lastpw->pw_gecos);
1123 (void)string_format(lastshell, sizeof(lastshell), "%s", lastpw->pw_shell);
1124 pwcopy.pw_name = CS lastname;
1125 pwcopy.pw_dir = CS lastdir;
1126 pwcopy.pw_gecos = CS lastgecos;
1127 pwcopy.pw_shell = CS lastshell;
1133 if (errno != 0) debug_printf("getpwnam(%s) failed: %s\n", s,
1140 DEBUG(D_uid) debug_printf("getpwnam() returned NULL (user not found)\n");
1145 DEBUG(D_uid) debug_printf("getpwnam() succeeded uid=%d gid=%d\n",
1146 lastpw->pw_uid, lastpw->pw_gid);
1149 if (return_uid != NULL) *return_uid = lastpw->pw_uid;
1150 if (pw != NULL) *pw = lastpw;
1158 /*************************************************
1159 * Find a local group *
1160 *************************************************/
1162 /* Try several times (if configured) to find a local group, in case delays in
1163 NIS or NFS whatever cause an incorrect refusal. It's a pity that getgrnam()
1164 doesn't have some kind of indication as to why it has failed.
1167 s the group namd or textual form of the numerical gid
1168 return_gid return the gid via this address
1170 Returns: TRUE if the group was found; FALSE otherwise
1175 route_findgroup(uschar *s, gid_t *return_gid)
1180 if ((isdigit(*s) || *s == '-') && s[Ustrspn(s+1, "0123456789")+1] == 0)
1182 *return_gid = (gid_t)Uatoi(s);
1188 if ((gr = getgrnam(CS s)) != NULL)
1190 *return_gid = gr->gr_gid;
1193 if (++i > finduser_retries) break;
1203 /*************************************************
1204 * Find user by expanding string *
1205 *************************************************/
1207 /* Expands a string, and then looks up the result in the passwd file.
1210 string the string to be expanded, yielding a login name or a numerical
1211 uid value (to be passed to route_finduser())
1212 driver_name caller name for panic error message (only)
1213 driver_type caller type for panic error message (only)
1214 pw return passwd entry via this pointer
1215 uid return uid via this pointer
1216 errmsg where to point a message on failure
1218 Returns: TRUE if user found, FALSE otherwise
1222 route_find_expanded_user(uschar *string, uschar *driver_name,
1223 uschar *driver_type, struct passwd **pw, uid_t *uid, uschar **errmsg)
1225 uschar *user = expand_string(string);
1229 *errmsg = string_sprintf("Failed to expand user string \"%s\" for the "
1230 "%s %s: %s", string, driver_name, driver_type, expand_string_message);
1231 log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1235 if (route_finduser(user, pw, uid)) return TRUE;
1237 *errmsg = string_sprintf("Failed to find user \"%s\" from expanded string "
1238 "\"%s\" for the %s %s", user, string, driver_name, driver_type);
1239 log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1245 /*************************************************
1246 * Find group by expanding string *
1247 *************************************************/
1249 /* Expands a string and then looks up the result in the group file.
1252 string the string to be expanded, yielding a group name or a numerical
1253 gid value (to be passed to route_findgroup())
1254 driver_name caller name for panic error message (only)
1255 driver_type caller type for panic error message (only)
1256 gid return gid via this pointer
1257 errmsg return error message via this pointer
1259 Returns: TRUE if found group, FALSE otherwise
1263 route_find_expanded_group(uschar *string, uschar *driver_name, uschar *driver_type,
1264 gid_t *gid, uschar **errmsg)
1267 uschar *group = expand_string(string);
1271 *errmsg = string_sprintf("Failed to expand group string \"%s\" for the "
1272 "%s %s: %s", string, driver_name, driver_type, expand_string_message);
1273 log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1277 if (!route_findgroup(group, gid))
1279 *errmsg = string_sprintf("Failed to find group \"%s\" from expanded string "
1280 "\"%s\" for the %s %s", group, string, driver_name, driver_type);
1281 log_write(0, LOG_MAIN|LOG_PANIC, "%s", *errmsg);
1290 /*************************************************
1291 * Sort out "more" or "unseen" *
1292 *************************************************/
1294 /* These values are usually fixed boolean values, but they are permitted to be
1298 addr address being routed
1299 rname the router name
1300 oname the option name
1301 bvalue the router's boolean value
1302 svalue the router's string value
1303 rvalue where to put the returned value
1305 Returns: OK value placed in rvalue
1306 DEFER expansion failed
1310 exp_bool(address_item *addr, uschar *rname, uschar *oname, BOOL bvalue,
1311 uschar *svalue, BOOL *rvalue)
1314 if (svalue == NULL) { *rvalue = bvalue; return OK; }
1316 expanded = expand_string(svalue);
1317 if (expanded == NULL)
1319 if (expand_string_forcedfail)
1321 DEBUG(D_route) debug_printf("expansion of \"%s\" forced failure\n", oname);
1325 addr->message = string_sprintf("failed to expand \"%s\" in %s router: %s",
1326 oname, rname, expand_string_message);
1327 DEBUG(D_route) debug_printf("%s\n", addr->message);
1331 DEBUG(D_route) debug_printf("expansion of \"%s\" yields \"%s\"\n", oname,
1334 if (strcmpic(expanded, US"true") == 0 || strcmpic(expanded, US"yes") == 0)
1336 else if (strcmpic(expanded, US"false") == 0 || strcmpic(expanded, US"no") == 0)
1340 addr->message = string_sprintf("\"%s\" is not a valid value for the "
1341 "\"%s\" option in the %s router", expanded, oname, rname);
1351 /*************************************************
1352 * Handle an unseen routing *
1353 *************************************************/
1355 /* This function is called when an address is routed by a router with "unseen"
1356 set. It must make a clone of the address, for handling by subsequent drivers.
1357 The clone is set to start routing at the next router.
1359 The original address must be replaced by an invented "parent" which has the
1360 routed address plus the clone as its children. This is necessary in case the
1361 address is at the top level - we don't want to mark it complete until both
1362 deliveries have been done.
1364 A new unique field must be made, so that the record of the delivery isn't a
1365 record of the original address, and checking for already delivered has
1366 therefore to be done here. If the delivery has happened, then take the base
1367 address off whichever delivery queue it is on - it will always be the top item.
1371 addr address that was routed
1372 paddr_local chain of local-delivery addresses
1373 paddr_remote chain of remote-delivery addresses
1374 addr_new chain for newly created addresses
1380 route_unseen(uschar *name, address_item *addr, address_item **paddr_local,
1381 address_item **paddr_remote, address_item **addr_new)
1383 address_item *parent = deliver_make_addr(addr->address, TRUE);
1384 address_item *new = deliver_make_addr(addr->address, TRUE);
1386 /* The invented parent is a copy that replaces the original; note that
1387 this copies its parent pointer. It has two children, and its errors_address is
1388 from the original address' parent, if present, otherwise unset. */
1391 parent->child_count = 2;
1392 parent->p.errors_address =
1393 (addr->parent == NULL)? NULL : addr->parent->p.errors_address;
1395 /* The routed address gets a new parent. */
1397 addr->parent = parent;
1399 /* The clone has this parent too. Set its errors address from the parent. This
1400 was set from the original parent (or to NULL) - see above. We do NOT want to
1401 take the errors address from the unseen router. */
1403 new->parent = parent;
1404 new->p.errors_address = parent->p.errors_address;
1406 /* Copy the propagated flags and address_data from the original. */
1408 copyflag(new, addr, af_propagate);
1409 new->p.address_data = addr->p.address_data;
1412 /* As it has turned out, we haven't set headers_add or headers_remove for the
1413 * clone. Thinking about it, it isn't entirely clear whether they should be
1414 * copied from the original parent, like errors_address, or taken from the
1415 * unseen router, like address_data and the flags. Until somebody brings this
1416 * up, I propose to leave the code as it is.
1420 /* Set the cloned address to start at the next router, and put it onto the
1421 chain of new addresses. */
1423 new->start_router = addr->router->next;
1424 new->next = *addr_new;
1427 DEBUG(D_route) debug_printf("\"unseen\" set: replicated %s\n", addr->address);
1429 /* Make a new unique field, to distinguish from the normal one. */
1431 addr->unique = string_sprintf("%s/%s", addr->unique, name);
1433 /* If the address has been routed to a transport, see if it was previously
1434 delivered. If so, we take it off the relevant queue so that it isn't delivered
1435 again. Otherwise, it was an alias or something, and the addresses it generated
1436 are handled in the normal way. */
1438 if (addr->transport != NULL &&
1439 tree_search(tree_nonrecipients, addr->unique) != NULL)
1442 debug_printf("\"unseen\" delivery previously done - discarded\n");
1443 parent->child_count--;
1444 if (*paddr_remote == addr) *paddr_remote = addr->next;
1445 if (*paddr_local == addr) *paddr_local = addr->next;
1451 /*************************************************
1452 * Route one address *
1453 *************************************************/
1455 /* This function is passed in one address item, for processing by the routers.
1456 The verify flag is set if this is being called for verification rather than
1457 delivery. If the router doesn't have its "verify" flag set, it is skipped.
1460 addr address to route
1461 paddr_local chain of local-delivery addresses
1462 paddr_remote chain of remote-delivery addresses
1463 addr_new chain for newly created addresses
1464 addr_succeed chain for completed addresses
1465 verify v_none if not verifying
1466 v_sender if verifying a sender address
1467 v_recipient if verifying a recipient address
1468 v_expn if processing an EXPN address
1470 Returns: OK => address successfully routed
1471 DISCARD => address was discarded
1472 FAIL => address could not be routed
1473 DEFER => some temporary problem
1474 ERROR => some major internal or configuration failure
1478 route_address(address_item *addr, address_item **paddr_local,
1479 address_item **paddr_remote, address_item **addr_new,
1480 address_item **addr_succeed, int verify)
1484 router_instance *r, *nextr;
1485 uschar *old_domain = addr->domain;
1489 debug_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
1490 debug_printf("routing %s\n", addr->address);
1493 /* Loop through all router instances until a router succeeds, fails, defers, or
1494 encounters an error. If the address has start_router set, we begin from there
1495 instead of at the first router. */
1497 for (r = (addr->start_router == NULL)? routers : addr->start_router;
1498 r != NULL; r = nextr)
1501 struct passwd *pw = NULL;
1502 struct passwd pwcopy;
1503 address_item *parent;
1504 BOOL loop_detected = FALSE;
1509 DEBUG(D_route) debug_printf("--------> %s router <--------\n", r->name);
1511 /* Reset any search error message from the previous router. */
1513 search_error_message = NULL;
1515 /* There are some weird cases where logging is disabled */
1517 disable_logging = r->disable_logging;
1519 /* Record the last router to handle the address, and set the default
1525 /* Loop protection: If this address has an ancestor with the same address,
1526 and that ancestor was routed by this router, we skip this router. This
1527 prevents a variety of looping states when a new address is created by
1528 redirection or by the use of "unseen" on a router.
1530 If no_repeat_use is set on the router, we skip if _any_ ancestor was routed
1531 by this router, even if it was different to the current address.
1533 Just in case someone does put it into a loop (possible with redirection
1534 continally adding to an address, for example), put a long stop counter on
1535 the number of parents. */
1537 for (parent = addr->parent; parent != NULL; parent = parent->parent)
1539 if (parent->router == r)
1541 BOOL break_loop = !r->repeat_use;
1543 /* When repeat_use is set, first check the active addresses caselessly.
1544 If they match, we have to do a further caseful check of the local parts
1545 when caseful_local_part is set. This is assumed to be rare, which is why
1546 the code is written this way. */
1550 break_loop = strcmpic(parent->address, addr->address) == 0;
1551 if (break_loop && r->caseful_local_part)
1552 break_loop = Ustrncmp(parent->address, addr->address,
1553 Ustrrchr(addr->address, '@') - addr->address) == 0;
1558 DEBUG(D_route) debug_printf("%s router skipped: previously routed %s\n",
1559 r->name, parent->address);
1560 loop_detected = TRUE;
1565 /* Continue with parents, limiting the size of the dynasty. */
1567 if (loopcount++ > 100)
1569 log_write(0, LOG_MAIN|LOG_PANIC, "routing loop for %s", addr->address);
1575 if (loop_detected) continue;
1577 /* Default no affixes and select whether to use a caseful or caseless local
1578 part in this router. */
1580 addr->prefix = addr->suffix = NULL;
1581 addr->local_part = r->caseful_local_part?
1582 addr->cc_local_part : addr->lc_local_part;
1584 DEBUG(D_route) debug_printf("local_part=%s domain=%s\n", addr->local_part,
1587 /* Handle any configured prefix by replacing the local_part address,
1588 and setting the prefix. Skip the router if the prefix doesn't match,
1589 unless the prefix is optional. */
1591 if (r->prefix != NULL)
1593 int plen = route_check_prefix(addr->local_part, r->prefix);
1596 addr->prefix = string_copyn(addr->local_part, plen);
1597 addr->local_part += plen;
1598 DEBUG(D_route) debug_printf("stripped prefix %s\n", addr->prefix);
1600 else if (!r->prefix_optional)
1602 DEBUG(D_route) debug_printf("%s router skipped: prefix mismatch\n",
1608 /* Handle any configured suffix likewise. */
1610 if (r->suffix != NULL)
1612 int slen = route_check_suffix(addr->local_part, r->suffix);
1615 int lplen = Ustrlen(addr->local_part) - slen;
1616 addr->suffix = addr->local_part + lplen;
1617 addr->local_part = string_copyn(addr->local_part, lplen);
1618 DEBUG(D_route) debug_printf("stripped suffix %s\n", addr->suffix);
1620 else if (!r->suffix_optional)
1622 DEBUG(D_route) debug_printf("%s router skipped: suffix mismatch\n",
1628 /* Set the expansion variables now that we have the affixes and the case of
1629 the local part sorted. */
1631 deliver_set_expansions(addr);
1633 /* For convenience, the pre-router checks are in a separate function, which
1634 returns OK, SKIP, FAIL, or DEFER. */
1636 if ((rc = check_router_conditions(r, addr, verify, &pw, &error)) != OK)
1638 if (rc == SKIP) continue;
1639 addr->message = error;
1644 /* All pre-conditions have been met. Reset any search error message from
1645 pre-condition tests. These can arise in negated tests where the failure of
1646 the lookup leads to a TRUE pre-condition. */
1648 search_error_message = NULL;
1650 /* Finally, expand the address_data field in the router. Forced failure
1651 behaves as if the router declined. Any other failure is more serious. On
1652 success, the string is attached to the address for all subsequent processing.
1655 if (r->address_data != NULL)
1657 DEBUG(D_route) debug_printf("processing address_data\n");
1658 deliver_address_data = expand_string(r->address_data);
1659 if (deliver_address_data == NULL)
1661 if (expand_string_forcedfail)
1663 DEBUG(D_route) debug_printf("forced failure in expansion of \"%s\" "
1664 "(address_data): decline action taken\n", r->address_data);
1666 /* Expand "more" if necessary; DEFER => an expansion failed */
1668 yield = exp_bool(addr, r->name, US"more", r->more, r->expand_more,
1670 if (yield != OK) goto ROUTE_EXIT;
1675 debug_printf("\"more\"=false: skipping remaining routers\n");
1679 else continue; /* With next router */
1684 addr->message = string_sprintf("expansion of \"%s\" failed "
1685 "in %s router: %s", r->address_data, r->name, expand_string_message);
1690 addr->p.address_data = deliver_address_data;
1693 /* We are finally cleared for take-off with this router. Clear the the flag
1694 that records that a local host was removed from a routed host list. Make a
1695 copy of relevant fields in the password information from check_local_user,
1696 because it will be overwritten if check_local_user is invoked again while
1697 verifying an errors_address setting. */
1699 clearflag(addr, af_local_host_removed);
1703 pwcopy.pw_name = CS string_copy(US pw->pw_name);
1704 pwcopy.pw_uid = pw->pw_uid;
1705 pwcopy.pw_gid = pw->pw_gid;
1706 pwcopy.pw_gecos = CS string_copy(US pw->pw_gecos);
1707 pwcopy.pw_dir = CS string_copy(US pw->pw_dir);
1708 pwcopy.pw_shell = CS string_copy(US pw->pw_shell);
1712 /* Run the router, and handle the consequences. */
1714 HDEBUG(D_route) debug_printf("calling %s router\n", r->name);
1716 yield = (r->info->code)(r, addr, pw, verify, paddr_local, paddr_remote,
1717 addr_new, addr_succeed);
1721 HDEBUG(D_route) debug_printf("%s router forced address failure\n", r->name);
1725 /* If succeeded while verifying but fail_verify is set, convert into
1726 a failure, and take it off the local or remote delivery list. */
1728 if (((verify == v_sender && r->fail_verify_sender) ||
1729 (verify == v_recipient && r->fail_verify_recipient)) &&
1730 (yield == OK || yield == PASS))
1732 addr->message = string_sprintf("%s router forced verify failure", r->name);
1733 if (*paddr_remote == addr) *paddr_remote = addr->next;
1734 if (*paddr_local == addr) *paddr_local = addr->next;
1739 /* PASS and DECLINE are the only two cases where the loop continues. For all
1740 other returns, we break the loop and handle the result below. */
1742 if (yield != PASS && yield != DECLINE) break;
1746 debug_printf("%s router %s for %s\n", r->name,
1747 (yield == PASS)? "passed" : "declined", addr->address);
1748 if (Ustrcmp(old_domain, addr->domain) != 0)
1749 debug_printf("domain %s rewritten\n", old_domain);
1752 /* PASS always continues to another router; DECLINE does so if "more"
1753 is true. Initialization insists that pass_router is always a following
1754 router. Otherwise, break the loop as if at the end of the routers. */
1758 if (r->pass_router != NULL) nextr = r->pass_router;
1762 /* Expand "more" if necessary */
1764 yield = exp_bool(addr, r->name, US"more", r->more, r->expand_more, &more);
1765 if (yield != OK) goto ROUTE_EXIT;
1770 debug_printf("\"more\" is false: skipping remaining routers\n");
1775 } /* Loop for all routers */
1777 /* On exit from the routers loop, if r == NULL we have run out of routers,
1778 either genuinely, or as a result of no_more. Otherwise, the loop ended
1779 prematurely, either because a router succeeded, or because of some special
1780 router response. Note that FAIL errors and errors detected before actually
1781 running a router go direct to ROUTE_EXIT from code above. */
1785 HDEBUG(D_route) debug_printf("no more routers\n");
1786 if (addr->message == NULL)
1788 uschar *message = US"Unrouteable address";
1789 if (addr->router != NULL && addr->router->cannot_route_message != NULL)
1791 uschar *expmessage = expand_string(addr->router->cannot_route_message);
1792 if (expmessage == NULL)
1794 if (!expand_string_forcedfail)
1795 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand "
1796 "cannot_route_message in %s router: %s", addr->router->name,
1797 expand_string_message);
1799 else message = expmessage;
1801 addr->user_message = addr->message = message;
1803 addr->router = NULL; /* For logging */
1812 debug_printf("%s router: defer for %s\n", r->name, addr->address);
1813 debug_printf(" message: %s\n", (addr->message == NULL)?
1814 US"<none>" : addr->message);
1819 if (yield == DISCARD) goto ROUTE_EXIT;
1821 /* The yield must be either OK or REROUTED. */
1823 if (yield != OK && yield != REROUTED)
1824 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router returned unknown value %d",
1827 /* If the yield was REROUTED, the router put a child address on the new chain
1828 as a result of a domain change of some sort (widening, typically). */
1830 if (yield == REROUTED)
1832 HDEBUG(D_route) debug_printf("re-routed to %s\n", addr->address);
1837 /* The only remaining possibility is that the router succeeded. If the
1838 translate_ip_address options is set and host addresses were associated with the
1839 address, run them through the translation. This feature is for weird and
1840 wonderful situations (the amateur packet radio people need it) or very broken
1841 networking, so it is included in the binary only if requested. */
1843 #ifdef SUPPORT_TRANSLATE_IP_ADDRESS
1845 if (r->translate_ip_address != NULL)
1848 int old_pool = store_pool;
1850 for (h = addr->host_list; h != NULL; h = h->next)
1853 uschar *oldaddress, *oldname;
1855 if (h->address == NULL) continue;
1857 deliver_host_address = h->address;
1858 newaddress = expand_string(r->translate_ip_address);
1859 deliver_host_address = NULL;
1861 if (newaddress == NULL)
1863 if (expand_string_forcedfail) continue;
1864 addr->basic_errno = ERRNO_EXPANDFAIL;
1865 addr->message = string_sprintf("translate_ip_address expansion "
1866 "failed: %s", expand_string_message);
1871 DEBUG(D_route) debug_printf("%s [%s] translated to %s\n",
1872 h->name, h->address, newaddress);
1873 if (string_is_ip_address(newaddress, NULL) != 0)
1875 h->address = newaddress;
1880 oldaddress = h->address;
1881 h->name = newaddress;
1885 store_pool = POOL_PERM;
1886 rc = host_find_byname(h, NULL, NULL, TRUE);
1887 store_pool = old_pool;
1889 if (rc == HOST_FIND_FAILED || rc == HOST_FIND_AGAIN)
1891 addr->basic_errno = ERRNO_UNKNOWNHOST;
1892 addr->message = string_sprintf("host %s not found when "
1893 "translating %s [%s]", h->name, oldname, oldaddress);
1899 #endif /* SUPPORT_TRANSLATE_IP_ADDRESS */
1901 /* See if this is an unseen routing; first expand the option if necessary.
1902 DEFER can be given if the expansion fails */
1904 yield = exp_bool(addr, r->name, US"unseen", r->unseen, r->expand_unseen,
1906 if (yield != OK) goto ROUTE_EXIT;
1908 /* Debugging output recording a successful routing */
1912 debug_printf("routed by %s router%s\n", r->name,
1913 unseen? " (unseen)" : "");
1920 debug_printf(" envelope to: %s\n", addr->address);
1921 debug_printf(" transport: %s\n", (addr->transport == NULL)?
1922 US"<none>" : addr->transport->name);
1924 if (addr->p.errors_address != NULL)
1925 debug_printf(" errors to %s\n", addr->p.errors_address);
1927 for (h = addr->host_list; h != NULL; h = h->next)
1929 debug_printf(" host %s", h->name);
1930 if (h->address != NULL) debug_printf(" [%s]", h->address);
1931 if (h->mx >= 0) debug_printf(" MX=%d", h->mx);
1932 else if (h->mx != MX_NONE) debug_printf(" rgroup=%d", h->mx);
1933 if (h->port != PORT_NONE) debug_printf(" port=%d", h->port);
1938 /* Clear any temporary error message set by a router that declined, and handle
1939 the "unseen" option (ignore if there are no further routers). */
1941 addr->message = NULL;
1942 if (unseen && r->next != NULL)
1943 route_unseen(r->name, addr, paddr_local, paddr_remote, addr_new);
1945 /* Unset the address expansions, and return the final result. */
1948 deliver_set_expansions(NULL);
1949 disable_logging = FALSE;
1953 /* End of route.c */