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