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