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