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