1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
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 */
13 #ifdef ROUTER_MANUALROUTE
14 #include "rf_functions.h"
15 #include "manualroute.h"
18 /* Options specific to the manualroute router. */
20 optionlist manualroute_router_options[] = {
21 { "host_all_ignored", opt_stringptr,
22 OPT_OFF(manualroute_router_options_block, host_all_ignored) },
23 { "host_find_failed", opt_stringptr,
24 OPT_OFF(manualroute_router_options_block, host_find_failed) },
25 { "hosts_randomize", opt_bool,
26 OPT_OFF(manualroute_router_options_block, hosts_randomize) },
27 { "route_data", opt_stringptr,
28 OPT_OFF(manualroute_router_options_block, route_data) },
29 { "route_list", opt_stringptr,
30 OPT_OFF(manualroute_router_options_block, route_list) },
31 { "same_domain_copy_routing", opt_bool|opt_public,
32 OPT_OFF(router_instance, same_domain_copy_routing) }
35 /* Size of the options list. An extern variable has to be used so that its
36 address can appear in the tables drtables.c. */
38 int manualroute_router_options_count =
39 sizeof(manualroute_router_options)/sizeof(optionlist);
45 manualroute_router_options_block manualroute_router_option_defaults = {0};
46 void manualroute_router_init(router_instance *rblock) {}
47 int manualroute_router_entry(router_instance *rblock, address_item *addr,
48 struct passwd *pw, int verify, address_item **addr_local,
49 address_item **addr_remote, address_item **addr_new,
50 address_item **addr_succeed) {return 0;}
52 #else /*!MACRO_PREDEF*/
56 /* Default private options block for the manualroute router. */
58 manualroute_router_options_block manualroute_router_option_defaults = {
59 -1, /* host_all_ignored code (unset) */
60 -1, /* host_find_failed code (unset) */
61 FALSE, /* hosts_randomize */
62 US"defer", /* host_all_ignored */
63 US"freeze", /* host_find_failed */
64 NULL, /* route_data */
69 /* Names and values for host_find_failed and host_all_ignored. */
71 static uschar *hff_names[] = {
72 US"ignore", /* MUST be first - not valid for host_all_ignored */
79 static int hff_codes[] = { hff_ignore, hff_decline, hff_defer, hff_fail,
80 hff_freeze, hff_pass };
82 static int hff_count= sizeof(hff_codes)/sizeof(int);
86 /*************************************************
87 * Initialization entry point *
88 *************************************************/
90 /* Called for each instance, after its options have been read, to enable
91 consistency checks to be done, or anything else that needs to be set up. */
94 manualroute_router_init(router_instance *rblock)
96 manualroute_router_options_block *ob =
97 (manualroute_router_options_block *)(rblock->options_block);
99 /* Host_find_failed must be a recognized word */
101 for (int i = 0; i < hff_count; i++)
102 if (Ustrcmp(ob->host_find_failed, hff_names[i]) == 0)
104 ob->hff_code = hff_codes[i];
107 if (ob->hff_code < 0)
108 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
109 "unrecognized setting for host_find_failed option", rblock->name);
111 for (int i = 1; i < hff_count; i++) /* NB starts at 1 to skip "ignore" */
112 if (Ustrcmp(ob->host_all_ignored, hff_names[i]) == 0)
114 ob->hai_code = hff_codes[i];
117 if (ob->hai_code < 0)
118 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
119 "unrecognized setting for host_all_ignored option", rblock->name);
121 /* One of route_list or route_data must be specified */
123 if ( !ob->route_list && !ob->route_data
124 || ob->route_list && ob->route_data)
125 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n "
126 "route_list or route_data (but not both) must be specified",
133 /*************************************************
134 * Parse a route item *
135 *************************************************/
137 /* The format of a route list item is:
139 <domain> [<host[list]> [<options>]]
141 if obtained from route_list. The domain is absent if the string came from
142 route_data, in which case domain==NULL. The domain and the host list may be
146 s pointer to route list item
147 domain if not NULL, where to put the domain pointer
148 hostlist where to put the host[list] pointer
149 options where to put the options pointer
151 Returns: FALSE if domain expected and string is empty;
156 parse_route_item(const uschar *s, const uschar **domain, const uschar **hostlist,
157 const uschar **options)
159 while (*s != 0 && isspace(*s)) s++;
163 if (!*s) return FALSE; /* missing data */
164 *domain = string_dequote(&s);
165 while (*s && isspace(*s)) s++;
168 *hostlist = string_dequote(&s);
169 while (*s && isspace(*s)) s++;
176 /*************************************************
178 *************************************************/
180 /* The manualroute router provides a manual routing facility (surprise,
181 surprise). The data that defines the routing can either be set in route_data
182 (which means it can be found by, for example, looking up the domain in a file),
183 or a list of domain patterns and their corresponding data can be provided in
186 /* See local README for interface details. This router returns:
189 . no pattern in route_list matched (route_data not set)
190 . route_data was an empty string (route_list not set)
191 . forced expansion failure in route_data (rf_expand_data)
192 . forced expansion of host list
193 . host_find_failed = decline
196 . transport not defined when needed
197 . lookup defer in route_list when matching domain pattern
198 . non-forced expansion failure in route_data
199 . non-forced expansion failure in host list
200 . unknown routing option
201 . host list missing for remote transport (not verifying)
202 . timeout etc on host lookup (pass_on_timeout not set)
203 . verifying the errors address caused a deferment or a big disaster such
204 as an expansion failure (rf_get_errors_address)
205 . expanding a headers_{add,remove} string caused a deferment or another
206 expansion error (rf_get_munge_headers)
207 . a problem in rf_get_transport: no transport when one is needed;
208 failed to expand dynamic transport; failed to find dynamic transport
209 . failure to expand or find a uid/gid (rf_get_ugid via rf_queue_add)
210 . host_find_failed = freeze or defer
211 . self = freeze or defer
214 . timeout etc on host lookup (pass_on_timeout set)
215 . host_find_failed = pass
222 . host_find_failed = fail
226 . added address to addr_local or addr_remote, as appropriate for the
227 type of transport; this includes the self="send" case.
231 manualroute_router_entry(
232 router_instance *rblock, /* data for this instantiation */
233 address_item *addr, /* address we are working on */
234 struct passwd *pw, /* passwd entry after check_local_user */
235 int verify, /* v_none/v_recipient/v_sender/v_expn */
236 address_item **addr_local, /* add it to this if it's local */
237 address_item **addr_remote, /* add it to this if it's remote */
238 address_item **addr_new, /* put new addresses on here */
239 address_item **addr_succeed) /* put old address here on success */
242 uschar *route_item = NULL;
243 const uschar *options = NULL;
244 const uschar *hostlist = NULL;
245 const uschar *domain;
247 const uschar *listptr;
248 manualroute_router_options_block *ob =
249 (manualroute_router_options_block *)(rblock->options_block);
250 transport_instance *transport = NULL;
251 BOOL individual_transport_set = FALSE;
252 BOOL randomize = ob->hosts_randomize;
254 DEBUG(D_route) debug_printf("%s router called for %s\n domain = %s\n",
255 rblock->name, addr->address, addr->domain);
257 /* The initialization check ensures that either route_list or route_data is
262 int sep = -(';'); /* Default is semicolon */
263 listptr = ob->route_list;
265 while ((route_item = string_nextinlist(&listptr, &sep, NULL, 0)))
269 DEBUG(D_route) debug_printf("route_item = %s\n", route_item);
270 if (!parse_route_item(route_item, &domain, &hostlist, &options))
271 continue; /* Ignore blank items */
273 /* Check the current domain; if it matches, break the loop */
275 if ((rc = match_isinlist(addr->domain, &domain, UCHAR_MAX+1,
276 &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, CUSS &lookup_value)) == OK)
279 /* If there was a problem doing the check, defer */
283 addr->message = US"lookup defer in route_list";
288 if (!route_item) return DECLINE; /* No pattern in the list matched */
291 /* Handle a single routing item in route_data. If it expands to an empty
296 GET_OPTION("route_data");
297 if (!(route_item = rf_expand_data(addr, ob->route_data, &rc)))
299 (void) parse_route_item(route_item, NULL, &hostlist, &options);
300 if (!hostlist[0]) return DECLINE;
303 /* Expand the hostlist item. It may then pointing to an empty string, or to a
304 single host or a list of hosts; options is pointing to the rest of the
305 routelist item, which is either empty or contains various option words. */
307 DEBUG(D_route) debug_printf("original list of hosts = '%s' options = '%s'\n",
310 newhostlist = expand_string_copy(hostlist);
311 lookup_value = NULL; /* Finished with */
314 /* If the expansion was forced to fail, just decline. Otherwise there is a
315 configuration problem. */
319 if (f.expand_string_forcedfail) return DECLINE;
320 addr->message = string_sprintf("%s router: failed to expand \"%s\": %s",
321 rblock->name, hostlist, expand_string_message);
324 else hostlist = newhostlist;
326 DEBUG(D_route) debug_printf("expanded list of hosts = '%s' options = '%s'\n",
329 /* Set default lookup type and scan the options */
331 lookup_type = LK_DEFAULT;
336 const uschar *s = options;
337 while (*options != 0 && !isspace(*options)) options++;
340 if (Ustrncmp(s, "randomize", n) == 0) randomize = TRUE;
341 else if (Ustrncmp(s, "no_randomize", n) == 0) randomize = FALSE;
342 else if (Ustrncmp(s, "byname", n) == 0)
343 lookup_type = lookup_type & ~(LK_DEFAULT | LK_BYDNS) | LK_BYNAME;
344 else if (Ustrncmp(s, "bydns", n) == 0)
345 lookup_type = lookup_type & ~(LK_DEFAULT | LK_BYNAME) & LK_BYDNS;
346 else if (Ustrncmp(s, "ipv4_prefer", n) == 0) lookup_type |= LK_IPV4_PREFER;
347 else if (Ustrncmp(s, "ipv4_only", n) == 0) lookup_type |= LK_IPV4_ONLY;
350 transport_instance *t;
351 for (t = transports; t; t = t->next)
352 if (Ustrncmp(t->name, s, n) == 0)
355 individual_transport_set = TRUE;
361 s = string_sprintf("unknown routing option or transport name \"%s\"", s);
362 log_write(0, LOG_MAIN, "Error in %s router: %s", rblock->name, s);
363 addr->message = string_sprintf("error in router: %s", s);
371 while (*options != 0 && isspace(*options)) options++;
375 /* Set up the errors address, if any. */
377 rc = rf_get_errors_address(addr, rblock, verify, &addr->prop.errors_address);
378 if (rc != OK) return rc;
380 /* Set up the additional and removable headers for this address. */
382 rc = rf_get_munge_headers(addr, rblock, &addr->prop.extra_headers,
383 &addr->prop.remove_headers);
384 if (rc != OK) return rc;
386 /* If an individual transport is not set, get the transport for this router, if
387 any. It might be expanded, or it might be unset if this router has verify_only
390 if (!individual_transport_set)
392 if (!rf_get_transport(rblock->transport_name, &(rblock->transport), addr,
395 transport = rblock->transport;
398 /* Deal with the case of a local transport. The host list is passed over as a
399 single text string that ends up in $host. */
401 if (transport && transport->info->local)
406 addr->host_list = h = store_get(sizeof(host_item), GET_UNTAINTED);
407 h->name = string_copy(hostlist);
411 h->status = hstatus_unknown;
412 h->why = hwhy_unknown;
417 /* There is nothing more to do other than to queue the address for the
418 local transport, filling in any uid/gid. This can be done by the common
419 rf_queue_add() function. */
421 addr->transport = transport;
422 return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)?
426 /* There is either no transport (verify_only) or a remote transport. A host
427 list is mandatory in either case, except when verifying, in which case the
428 address is just accepted. */
432 if (verify != v_none) goto ROUTED;
433 addr->message = string_sprintf("error in %s router: no host(s) specified "
434 "for domain %s", rblock->name, addr->domain);
435 log_write(0, LOG_MAIN, "%s", addr->message);
439 /* Otherwise we finish the routing here by building a chain of host items
440 for the list of configured hosts, and then finding their addresses. */
442 host_build_hostlist(&addr->host_list, hostlist, randomize);
443 rc = rf_lookup_hostlist(rblock, addr, rblock->ignore_target_hosts, lookup_type,
444 ob->hff_code, addr_new);
445 if (rc != OK) return rc;
447 /* If host_find_failed is set to "ignore", it is possible for all the hosts to
448 be ignored, in which case we will end up with an empty host list. What happens
449 is controlled by host_all_ignored. */
451 if (!addr->host_list)
454 DEBUG(D_route) debug_printf("host_find_failed ignored every host\n");
455 if (ob->hai_code == hff_decline) return DECLINE;
456 if (ob->hai_code == hff_pass) return PASS;
458 for (i = 0; i < hff_count; i++)
459 if (ob->hai_code == hff_codes[i]) break;
461 addr->message = string_sprintf("lookup failed for all hosts in %s router: "
462 "host_find_failed=ignore host_all_ignored=%s", rblock->name, hff_names[i]);
464 if (ob->hai_code == hff_defer) return DEFER;
465 if (ob->hai_code == hff_fail) return FAIL;
467 addr->special_action = SPECIAL_FREEZE;
471 /* Finally, since we have done all the routing here, there must be a transport
472 defined for these hosts. It will be a remote one, as a local transport is
473 dealt with above. However, we don't need one if verifying only. */
475 if (!transport && verify == v_none)
477 log_write(0, LOG_MAIN, "Error in %s router: no transport defined",
479 addr->message = US"error in router: transport missing";
483 /* Fill in the transport, queue for remote delivery. The yield of
484 rf_queue_add() is always TRUE for a remote transport. */
488 addr->transport = transport;
489 (void)rf_queue_add(addr, addr_local, addr_remote, rblock, NULL);
493 #endif /*!MACRO_PREDEF*/
494 #endif /*ROUTER_MANUALROUTE*/
495 /* End of routers/manualroute.c */