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