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