Commit | Line | Data |
---|---|---|
0756eb3c PH |
1 | /************************************************* |
2 | * Exim - an Internet mail transport agent * | |
3 | *************************************************/ | |
4 | ||
f9ba5e22 | 5 | /* Copyright (c) University of Cambridge 1995 - 2018 */ |
1e1ddfac | 6 | /* Copyright (c) The Exim Maintainers 2020 */ |
0756eb3c PH |
7 | /* See the file NOTICE for conditions of use and distribution. */ |
8 | ||
9 | ||
10 | #include "../exim.h" | |
11 | #include "rf_functions.h" | |
12 | #include "manualroute.h" | |
13 | ||
14 | ||
15 | /* Options specific to the manualroute router. */ | |
16 | ||
17 | optionlist manualroute_router_options[] = { | |
c456d9bb | 18 | { "host_all_ignored", opt_stringptr, |
13a4b4c1 | 19 | OPT_OFF(manualroute_router_options_block, host_all_ignored) }, |
0756eb3c | 20 | { "host_find_failed", opt_stringptr, |
13a4b4c1 | 21 | OPT_OFF(manualroute_router_options_block, host_find_failed) }, |
0756eb3c | 22 | { "hosts_randomize", opt_bool, |
13a4b4c1 | 23 | OPT_OFF(manualroute_router_options_block, hosts_randomize) }, |
0756eb3c | 24 | { "route_data", opt_stringptr, |
13a4b4c1 | 25 | OPT_OFF(manualroute_router_options_block, route_data) }, |
0756eb3c | 26 | { "route_list", opt_stringptr, |
13a4b4c1 | 27 | OPT_OFF(manualroute_router_options_block, route_list) }, |
0756eb3c | 28 | { "same_domain_copy_routing", opt_bool|opt_public, |
13a4b4c1 | 29 | OPT_OFF(router_instance, same_domain_copy_routing) } |
0756eb3c PH |
30 | }; |
31 | ||
32 | /* Size of the options list. An extern variable has to be used so that its | |
33 | address can appear in the tables drtables.c. */ | |
34 | ||
35 | int manualroute_router_options_count = | |
36 | sizeof(manualroute_router_options)/sizeof(optionlist); | |
37 | ||
d185889f JH |
38 | |
39 | #ifdef MACRO_PREDEF | |
40 | ||
41 | /* Dummy entries */ | |
42 | manualroute_router_options_block manualroute_router_option_defaults = {0}; | |
43 | void manualroute_router_init(router_instance *rblock) {} | |
44 | int manualroute_router_entry(router_instance *rblock, address_item *addr, | |
45 | struct passwd *pw, int verify, address_item **addr_local, | |
46 | address_item **addr_remote, address_item **addr_new, | |
cab0c277 | 47 | address_item **addr_succeed) {return 0;} |
d185889f JH |
48 | |
49 | #else /*!MACRO_PREDEF*/ | |
50 | ||
51 | ||
52 | ||
0756eb3c PH |
53 | /* Default private options block for the manualroute router. */ |
54 | ||
55 | manualroute_router_options_block manualroute_router_option_defaults = { | |
c456d9bb PH |
56 | -1, /* host_all_ignored code (unset) */ |
57 | -1, /* host_find_failed code (unset) */ | |
0756eb3c | 58 | FALSE, /* hosts_randomize */ |
c456d9bb | 59 | US"defer", /* host_all_ignored */ |
0756eb3c PH |
60 | US"freeze", /* host_find_failed */ |
61 | NULL, /* route_data */ | |
62 | NULL /* route_list */ | |
63 | }; | |
64 | ||
65 | ||
c456d9bb PH |
66 | /* Names and values for host_find_failed and host_all_ignored. */ |
67 | ||
68 | static uschar *hff_names[] = { | |
69 | US"ignore", /* MUST be first - not valid for host_all_ignored */ | |
70 | US"decline", | |
71 | US"defer", | |
72 | US"fail", | |
73 | US"freeze", | |
74 | US"pass" }; | |
75 | ||
76 | static int hff_codes[] = { hff_ignore, hff_decline, hff_defer, hff_fail, | |
77 | hff_freeze, hff_pass }; | |
78 | ||
79 | static int hff_count= sizeof(hff_codes)/sizeof(int); | |
0756eb3c PH |
80 | |
81 | ||
82 | ||
83 | /************************************************* | |
84 | * Initialization entry point * | |
85 | *************************************************/ | |
86 | ||
87 | /* Called for each instance, after its options have been read, to enable | |
88 | consistency checks to be done, or anything else that needs to be set up. */ | |
89 | ||
90 | void | |
91 | manualroute_router_init(router_instance *rblock) | |
92 | { | |
93 | manualroute_router_options_block *ob = | |
94 | (manualroute_router_options_block *)(rblock->options_block); | |
95 | ||
96 | /* Host_find_failed must be a recognized word */ | |
97 | ||
d7978c0f | 98 | for (int i = 0; i < hff_count; i++) |
c456d9bb PH |
99 | if (Ustrcmp(ob->host_find_failed, hff_names[i]) == 0) |
100 | { | |
101 | ob->hff_code = hff_codes[i]; | |
102 | break; | |
103 | } | |
c456d9bb | 104 | if (ob->hff_code < 0) |
0756eb3c PH |
105 | log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n " |
106 | "unrecognized setting for host_find_failed option", rblock->name); | |
107 | ||
d7978c0f | 108 | for (int i = 1; i < hff_count; i++) /* NB starts at 1 to skip "ignore" */ |
c456d9bb PH |
109 | if (Ustrcmp(ob->host_all_ignored, hff_names[i]) == 0) |
110 | { | |
111 | ob->hai_code = hff_codes[i]; | |
112 | break; | |
113 | } | |
c456d9bb PH |
114 | if (ob->hai_code < 0) |
115 | log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n " | |
116 | "unrecognized setting for host_all_ignored option", rblock->name); | |
117 | ||
0756eb3c PH |
118 | /* One of route_list or route_data must be specified */ |
119 | ||
120 | if ((ob->route_list == NULL && ob->route_data == NULL) || | |
121 | (ob->route_list != NULL && ob->route_data != NULL)) | |
122 | log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n " | |
123 | "route_list or route_data (but not both) must be specified", | |
124 | rblock->name); | |
125 | } | |
126 | ||
127 | ||
128 | ||
129 | ||
130 | /************************************************* | |
131 | * Parse a route item * | |
132 | *************************************************/ | |
133 | ||
134 | /* The format of a route list item is: | |
135 | ||
136 | <domain> [<host[list]> [<options>]] | |
137 | ||
138 | if obtained from route_list. The domain is absent if the string came from | |
139 | route_data, in which case domain==NULL. The domain and the host list may be | |
140 | enclosed in quotes. | |
141 | ||
142 | Arguments: | |
143 | s pointer to route list item | |
144 | domain if not NULL, where to put the domain pointer | |
145 | hostlist where to put the host[list] pointer | |
146 | options where to put the options pointer | |
147 | ||
148 | Returns: FALSE if domain expected and string is empty; | |
149 | TRUE otherwise | |
150 | */ | |
151 | ||
152 | static BOOL | |
55414b25 JH |
153 | parse_route_item(const uschar *s, const uschar **domain, const uschar **hostlist, |
154 | const uschar **options) | |
0756eb3c PH |
155 | { |
156 | while (*s != 0 && isspace(*s)) s++; | |
157 | ||
8c513105 | 158 | if (domain) |
0756eb3c | 159 | { |
8c513105 | 160 | if (!*s) return FALSE; /* missing data */ |
0756eb3c | 161 | *domain = string_dequote(&s); |
8c513105 | 162 | while (*s && isspace(*s)) s++; |
0756eb3c PH |
163 | } |
164 | ||
165 | *hostlist = string_dequote(&s); | |
8c513105 | 166 | while (*s && isspace(*s)) s++; |
0756eb3c PH |
167 | *options = s; |
168 | return TRUE; | |
169 | } | |
170 | ||
171 | ||
172 | ||
173 | /************************************************* | |
174 | * Main entry point * | |
175 | *************************************************/ | |
176 | ||
177 | /* The manualroute router provides a manual routing facility (surprise, | |
178 | surprise). The data that defines the routing can either be set in route_data | |
179 | (which means it can be found by, for example, looking up the domain in a file), | |
180 | or a list of domain patterns and their corresponding data can be provided in | |
181 | route_list. */ | |
182 | ||
183 | /* See local README for interface details. This router returns: | |
184 | ||
185 | DECLINE | |
186 | . no pattern in route_list matched (route_data not set) | |
187 | . route_data was an empty string (route_list not set) | |
188 | . forced expansion failure in route_data (rf_expand_data) | |
189 | . forced expansion of host list | |
190 | . host_find_failed = decline | |
191 | ||
192 | DEFER | |
193 | . transport not defined when needed | |
194 | . lookup defer in route_list when matching domain pattern | |
195 | . non-forced expansion failure in route_data | |
196 | . non-forced expansion failure in host list | |
197 | . unknown routing option | |
198 | . host list missing for remote transport (not verifying) | |
199 | . timeout etc on host lookup (pass_on_timeout not set) | |
200 | . verifying the errors address caused a deferment or a big disaster such | |
201 | as an expansion failure (rf_get_errors_address) | |
202 | . expanding a headers_{add,remove} string caused a deferment or another | |
203 | expansion error (rf_get_munge_headers) | |
204 | . a problem in rf_get_transport: no transport when one is needed; | |
205 | failed to expand dynamic transport; failed to find dynamic transport | |
206 | . failure to expand or find a uid/gid (rf_get_ugid via rf_queue_add) | |
207 | . host_find_failed = freeze or defer | |
208 | . self = freeze or defer | |
209 | ||
210 | PASS | |
211 | . timeout etc on host lookup (pass_on_timeout set) | |
212 | . host_find_failed = pass | |
213 | . self = pass | |
214 | ||
215 | REROUTED | |
216 | . self = reroute | |
217 | ||
218 | FAIL | |
219 | . host_find_failed = fail | |
220 | . self = fail | |
221 | ||
222 | OK | |
223 | . added address to addr_local or addr_remote, as appropriate for the | |
224 | type of transport; this includes the self="send" case. | |
225 | */ | |
226 | ||
227 | int | |
228 | manualroute_router_entry( | |
229 | router_instance *rblock, /* data for this instantiation */ | |
230 | address_item *addr, /* address we are working on */ | |
231 | struct passwd *pw, /* passwd entry after check_local_user */ | |
fd6de02e | 232 | int verify, /* v_none/v_recipient/v_sender/v_expn */ |
0756eb3c PH |
233 | address_item **addr_local, /* add it to this if it's local */ |
234 | address_item **addr_remote, /* add it to this if it's remote */ | |
235 | address_item **addr_new, /* put new addresses on here */ | |
236 | address_item **addr_succeed) /* put old address here on success */ | |
237 | { | |
238 | int rc, lookup_type; | |
239 | uschar *route_item = NULL; | |
55414b25 JH |
240 | const uschar *options = NULL; |
241 | const uschar *hostlist = NULL; | |
242 | const uschar *domain; | |
243 | uschar *newhostlist; | |
244 | const uschar *listptr; | |
0756eb3c PH |
245 | manualroute_router_options_block *ob = |
246 | (manualroute_router_options_block *)(rblock->options_block); | |
247 | transport_instance *transport = NULL; | |
248 | BOOL individual_transport_set = FALSE; | |
249 | BOOL randomize = ob->hosts_randomize; | |
250 | ||
251 | addr_new = addr_new; /* Keep picky compilers happy */ | |
252 | addr_succeed = addr_succeed; | |
253 | ||
254 | DEBUG(D_route) debug_printf("%s router called for %s\n domain = %s\n", | |
255 | rblock->name, addr->address, addr->domain); | |
256 | ||
257 | /* The initialization check ensures that either route_list or route_data is | |
258 | set. */ | |
259 | ||
8c513105 | 260 | if (ob->route_list) |
0756eb3c PH |
261 | { |
262 | int sep = -(';'); /* Default is semicolon */ | |
263 | listptr = ob->route_list; | |
264 | ||
265 | while ((route_item = string_nextinlist(&listptr, &sep, NULL, 0)) != NULL) | |
266 | { | |
267 | int rc; | |
268 | ||
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 */ | |
272 | ||
273 | /* Check the current domain; if it matches, break the loop */ | |
274 | ||
275 | if ((rc = match_isinlist(addr->domain, &domain, UCHAR_MAX+1, | |
55414b25 | 276 | &domainlist_anchor, NULL, MCL_DOMAIN, TRUE, CUSS &lookup_value)) == OK) |
0756eb3c PH |
277 | break; |
278 | ||
279 | /* If there was a problem doing the check, defer */ | |
280 | ||
281 | if (rc == DEFER) | |
282 | { | |
283 | addr->message = US"lookup defer in route_list"; | |
284 | return DEFER; | |
285 | } | |
286 | } | |
287 | ||
8c513105 | 288 | if (!route_item) return DECLINE; /* No pattern in the list matched */ |
0756eb3c PH |
289 | } |
290 | ||
291 | /* Handle a single routing item in route_data. If it expands to an empty | |
292 | string, decline. */ | |
293 | ||
294 | else | |
295 | { | |
8c513105 JH |
296 | if (!(route_item = rf_expand_data(addr, ob->route_data, &rc))) |
297 | return rc; | |
0756eb3c | 298 | (void) parse_route_item(route_item, NULL, &hostlist, &options); |
8b455685 | 299 | if (!hostlist[0]) return DECLINE; |
0756eb3c PH |
300 | } |
301 | ||
302 | /* Expand the hostlist item. It may then pointing to an empty string, or to a | |
303 | single host or a list of hosts; options is pointing to the rest of the | |
304 | routelist item, which is either empty or contains various option words. */ | |
305 | ||
8b455685 | 306 | DEBUG(D_route) debug_printf("original list of hosts = '%s' options = '%s'\n", |
0756eb3c PH |
307 | hostlist, options); |
308 | ||
309 | newhostlist = expand_string_copy(hostlist); | |
310 | lookup_value = NULL; /* Finished with */ | |
311 | expand_nmax = -1; | |
312 | ||
313 | /* If the expansion was forced to fail, just decline. Otherwise there is a | |
314 | configuration problem. */ | |
315 | ||
8b455685 | 316 | if (!newhostlist) |
0756eb3c | 317 | { |
8768d548 | 318 | if (f.expand_string_forcedfail) return DECLINE; |
0756eb3c PH |
319 | addr->message = string_sprintf("%s router: failed to expand \"%s\": %s", |
320 | rblock->name, hostlist, expand_string_message); | |
321 | return DEFER; | |
322 | } | |
323 | else hostlist = newhostlist; | |
324 | ||
8b455685 | 325 | DEBUG(D_route) debug_printf("expanded list of hosts = '%s' options = '%s'\n", |
0756eb3c PH |
326 | hostlist, options); |
327 | ||
328 | /* Set default lookup type and scan the options */ | |
329 | ||
66387a73 | 330 | lookup_type = LK_DEFAULT; |
0756eb3c | 331 | |
8b455685 | 332 | while (*options) |
0756eb3c | 333 | { |
55414b25 JH |
334 | unsigned n; |
335 | const uschar *s = options; | |
0756eb3c | 336 | while (*options != 0 && !isspace(*options)) options++; |
55414b25 | 337 | n = options-s; |
0756eb3c | 338 | |
55414b25 JH |
339 | if (Ustrncmp(s, "randomize", n) == 0) randomize = TRUE; |
340 | else if (Ustrncmp(s, "no_randomize", n) == 0) randomize = FALSE; | |
66387a73 JH |
341 | else if (Ustrncmp(s, "byname", n) == 0) |
342 | lookup_type = lookup_type & ~(LK_DEFAULT | LK_BYDNS) | LK_BYNAME; | |
343 | else if (Ustrncmp(s, "bydns", n) == 0) | |
344 | lookup_type = lookup_type & ~(LK_DEFAULT | LK_BYNAME) & LK_BYDNS; | |
345 | else if (Ustrncmp(s, "ipv4_prefer", n) == 0) lookup_type |= LK_IPV4_PREFER; | |
346 | else if (Ustrncmp(s, "ipv4_only", n) == 0) lookup_type |= LK_IPV4_ONLY; | |
0756eb3c PH |
347 | else |
348 | { | |
349 | transport_instance *t; | |
66387a73 | 350 | for (t = transports; t; t = t->next) |
833c70bc | 351 | if (Ustrncmp(t->name, s, n) == 0) |
0756eb3c PH |
352 | { |
353 | transport = t; | |
354 | individual_transport_set = TRUE; | |
355 | break; | |
356 | } | |
55414b25 | 357 | |
66387a73 | 358 | if (!t) |
0756eb3c PH |
359 | { |
360 | s = string_sprintf("unknown routing option or transport name \"%s\"", s); | |
361 | log_write(0, LOG_MAIN, "Error in %s router: %s", rblock->name, s); | |
362 | addr->message = string_sprintf("error in router: %s", s); | |
363 | return DEFER; | |
364 | } | |
365 | } | |
366 | ||
55414b25 | 367 | if (*options) |
0756eb3c PH |
368 | { |
369 | options++; | |
370 | while (*options != 0 && isspace(*options)) options++; | |
371 | } | |
372 | } | |
373 | ||
374 | /* Set up the errors address, if any. */ | |
375 | ||
d43cbe25 | 376 | rc = rf_get_errors_address(addr, rblock, verify, &addr->prop.errors_address); |
0756eb3c PH |
377 | if (rc != OK) return rc; |
378 | ||
aded2255 | 379 | /* Set up the additional and removable headers for this address. */ |
0756eb3c | 380 | |
d43cbe25 JH |
381 | rc = rf_get_munge_headers(addr, rblock, &addr->prop.extra_headers, |
382 | &addr->prop.remove_headers); | |
0756eb3c PH |
383 | if (rc != OK) return rc; |
384 | ||
385 | /* If an individual transport is not set, get the transport for this router, if | |
386 | any. It might be expanded, or it might be unset if this router has verify_only | |
387 | set. */ | |
388 | ||
389 | if (!individual_transport_set) | |
390 | { | |
391 | if (!rf_get_transport(rblock->transport_name, &(rblock->transport), addr, | |
392 | rblock->name, NULL)) | |
393 | return DEFER; | |
394 | transport = rblock->transport; | |
395 | } | |
396 | ||
397 | /* Deal with the case of a local transport. The host list is passed over as a | |
398 | single text string that ends up in $host. */ | |
399 | ||
66387a73 | 400 | if (transport && transport->info->local) |
0756eb3c | 401 | { |
8b455685 | 402 | if (hostlist[0]) |
0756eb3c PH |
403 | { |
404 | host_item *h; | |
f3ebb786 | 405 | addr->host_list = h = store_get(sizeof(host_item), FALSE); |
0756eb3c PH |
406 | h->name = string_copy(hostlist); |
407 | h->address = NULL; | |
408 | h->port = PORT_NONE; | |
409 | h->mx = MX_NONE; | |
410 | h->status = hstatus_unknown; | |
411 | h->why = hwhy_unknown; | |
412 | h->last_try = 0; | |
413 | h->next = NULL; | |
414 | } | |
415 | ||
416 | /* There is nothing more to do other than to queue the address for the | |
417 | local transport, filling in any uid/gid. This can be done by the common | |
418 | rf_queue_add() function. */ | |
419 | ||
420 | addr->transport = transport; | |
421 | return rf_queue_add(addr, addr_local, addr_remote, rblock, pw)? | |
422 | OK : DEFER; | |
423 | } | |
424 | ||
425 | /* There is either no transport (verify_only) or a remote transport. A host | |
426 | list is mandatory in either case, except when verifying, in which case the | |
427 | address is just accepted. */ | |
428 | ||
8b455685 | 429 | if (!hostlist[0]) |
0756eb3c | 430 | { |
fd6de02e | 431 | if (verify != v_none) goto ROUTED; |
0756eb3c | 432 | addr->message = string_sprintf("error in %s router: no host(s) specified " |
37f3dc43 | 433 | "for domain %s", rblock->name, addr->domain); |
0756eb3c PH |
434 | log_write(0, LOG_MAIN, "%s", addr->message); |
435 | return DEFER; | |
436 | } | |
437 | ||
438 | /* Otherwise we finish the routing here by building a chain of host items | |
439 | for the list of configured hosts, and then finding their addresses. */ | |
440 | ||
8b455685 | 441 | host_build_hostlist(&addr->host_list, hostlist, randomize); |
0756eb3c PH |
442 | rc = rf_lookup_hostlist(rblock, addr, rblock->ignore_target_hosts, lookup_type, |
443 | ob->hff_code, addr_new); | |
444 | if (rc != OK) return rc; | |
445 | ||
c456d9bb PH |
446 | /* If host_find_failed is set to "ignore", it is possible for all the hosts to |
447 | be ignored, in which case we will end up with an empty host list. What happens | |
448 | is controlled by host_all_ignored. */ | |
449 | ||
66387a73 | 450 | if (!addr->host_list) |
c456d9bb PH |
451 | { |
452 | int i; | |
453 | DEBUG(D_route) debug_printf("host_find_failed ignored every host\n"); | |
454 | if (ob->hai_code == hff_decline) return DECLINE; | |
455 | if (ob->hai_code == hff_pass) return PASS; | |
456 | ||
457 | for (i = 0; i < hff_count; i++) | |
458 | if (ob->hai_code == hff_codes[i]) break; | |
459 | ||
460 | addr->message = string_sprintf("lookup failed for all hosts in %s router: " | |
461 | "host_find_failed=ignore host_all_ignored=%s", rblock->name, hff_names[i]); | |
462 | ||
463 | if (ob->hai_code == hff_defer) return DEFER; | |
464 | if (ob->hai_code == hff_fail) return FAIL; | |
465 | ||
466 | addr->special_action = SPECIAL_FREEZE; | |
467 | return DEFER; | |
468 | } | |
469 | ||
0756eb3c PH |
470 | /* Finally, since we have done all the routing here, there must be a transport |
471 | defined for these hosts. It will be a remote one, as a local transport is | |
472 | dealt with above. However, we don't need one if verifying only. */ | |
473 | ||
fd6de02e | 474 | if (transport == NULL && verify == v_none) |
0756eb3c PH |
475 | { |
476 | log_write(0, LOG_MAIN, "Error in %s router: no transport defined", | |
477 | rblock->name); | |
478 | addr->message = US"error in router: transport missing"; | |
479 | return DEFER; | |
480 | } | |
481 | ||
482 | /* Fill in the transport, queue for remote delivery. The yield of | |
483 | rf_queue_add() is always TRUE for a remote transport. */ | |
484 | ||
485 | ROUTED: | |
486 | ||
487 | addr->transport = transport; | |
488 | (void)rf_queue_add(addr, addr_local, addr_remote, rblock, NULL); | |
489 | return OK; | |
490 | } | |
491 | ||
d185889f | 492 | #endif /*!MACRO_PREDEF*/ |
0756eb3c | 493 | /* End of routers/manualroute.c */ |